@author: marcink

"""

from os.path import dirname as dn, join as jn

import os

import sys

import uuid

ROOT = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(ROOT)

from pylons_app.lib.auth import get_crypt_password

from pylons_app.model import init_model

from pylons_app.model.meta import Session, Base

from sqlalchemy.engine import create_engine

import logging

log = logging.getLogger('db manage')

log.setLevel(logging.DEBUG)

console_handler = logging.StreamHandler()

console_handler.setFormatter(logging.Formatter("%(asctime)s.%(msecs)03d" 

                                  " %(levelname)-5.5s [%(name)s] %(message)s"))

log.addHandler(console_handler)

class DbManage(object):

            if self.db_exists:

                os.remove(jn(ROOT, self.dbname))

        Base.metadata.create_all(checkfirst=override)

        log.info('Created tables for %s', self.dbname)

    def admin_prompt(self):

        import getpass

        username = raw_input('Specify admin username:')

        password = getpass.getpass('Specify admin password:')

        self.create_user(username, password, True)

    def config_prompt(self):

        path = raw_input('Specify valid full path to your repositories'

                        ' you can change this later application settings:')

        if not os.path.isdir(path):

            log.error('You entered wrong path')

            sys.exit()

        hooks = HgAppUi()

        hooks.ui_section = 'hooks'

        hooks.ui_key = 'changegroup'

        web4 = HgAppUi()

        web4.ui_section = 'web'

        web4.ui_key = 'baseurl'

        web4.ui_value = '/'                        

        paths = HgAppUi()

        paths.ui_section = 'paths'

        paths.ui_key = '/'

        paths.ui_value = os.path.join(path, '*')

        try:

            self.sa.add(hooks)

            self.sa.add(web1)

            self.sa.add(web2)

            self.sa.add(web3)

            self.sa.add(web4)

            self.sa.add(paths)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise        

        log.info('created ui config')

    def create_user(self, username, password, admin=False):

        log.info('creating default user')

        #create default user for handling default permissions.

        def_user = User()

        def_user.username = 'default'

from beaker.cache import cache_region

"""

Created on April 18, 2010

Utilities for hg app

@author: marcink

"""

import os

import logging

from mercurial import ui, config, hg

from mercurial.error import RepoError

log = logging.getLogger(__name__)

def get_repo_slug(request):

    return request.environ['pylons.routes_dict'].get('repo_name')

def is_mercurial(environ):

    """

    Returns True if request's target is mercurial server - header

    ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.

    """

    http_accept = environ.get('HTTP_ACCEPT')

            hg.verify(r)

        #here we hnow that repo exists it was verified

        log.info('%s repo is already created', repo_name)

        return False

    except RepoError:

        #it means that there is no valid repo there...

        log.info('%s repo is free for creation', repo_name)

        return True

@cache_region('super_short_term', 'cached_hg_ui')

def get_hg_ui_cached():

    sa = Session()

    return sa.query(HgAppUi).all()    

def make_ui(read_from='file', path=None, checkpaths=True):        

    """

    A function that will read python rc files or database

    and make an mercurial ui object from read options

    @param path: path to mercurial config file

    @param checkpaths: check the path

    @param read_from: read from 'file' or 'db'

    """

    #propagated from mercurial documentation

    sections = ['alias', 'auth',

                'decode/encode', 'defaults',

    elif read_from == 'db':

        hg_ui = get_hg_ui_cached()

        for ui_ in hg_ui:

            baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)

    return baseui

def set_hg_app_config(config):

def invalidate_cache(name, *args):

    """Invalidates given name cache"""

    from beaker.cache import region_invalidate

    log.info('INVALIDATING CACHE FOR %s', name)

    """propagate our arguments to make sure invalidation works. First

    argument has to be the name of cached func name give to cache decorator

    without that the invalidation would not work"""

    tmp = [name]

    tmp.extend(args)