# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

"""

Created on April 10, 2010

database managment and creation for hg app

@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):

    def __init__(self, log_sql):

        self.dbname = 'hg_app.db'

        dburi = 'sqlite:////%s' % jn(ROOT, self.dbname)

        engine = create_engine(dburi, echo=log_sql) 

        init_model(engine)

        self.sa = Session()

        self.db_exists = False

    def check_for_db(self, override):

        log.info('checking for exisiting db')

        if os.path.isfile(jn(ROOT, self.dbname)):

            self.db_exists = True

            log.info('database exisist')

            if not override:

                raise Exception('database already exists')

    def create_tables(self, override=False):

        """

        Create a auth database

        """

        self.check_for_db(override)

        if override:

            log.info("database exisist and it's going to be destroyed")

            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'

        hooks.ui_value = 'hg update >&2'

        web1 = HgAppUi()

        web1.ui_section = 'web'

        web1.ui_key = 'push_ssl'

        web1.ui_value = 'false'

        web2 = HgAppUi()

        web2.ui_section = 'web'

        web2.ui_key = 'allow_archive'

        web2.ui_value = 'gz zip bz2'

        web3 = HgAppUi()

        web3.ui_section = 'web'

        web3.ui_key = 'allow_push'

        web3.ui_value = '*'

        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'

        def_user.password = get_crypt_password(str(uuid.uuid1())[:8])

        def_user.name = 'default'

        def_user.lastname = 'default'

        def_user.email = 'default@default.com'

        def_user.admin = False

        def_user.active = False

        log.info('creating administrator user %s', username)

        new_user = User()

        new_user.username = username

        new_user.password = get_crypt_password(password)

        new_user.name = 'Hg'

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

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')

    if http_accept and http_accept.startswith('application/mercurial'):

        return True

    return False

def check_repo_dir(paths):

    repos_path = paths[0][1].split('/')

    if repos_path[-1] in ['*', '**']:

        repos_path = repos_path[:-1]

    if repos_path[0] != '/':

        repos_path[0] = '/'

    if not os.path.isdir(os.path.join(*repos_path)):

        raise Exception('Not a valid repository in %s' % paths[0][1])

    if os.path.isdir(os.path.join(base_path, repo_name)):return False

    return True

def check_repo(repo_name, base_path, verify=True):

    repo_path = os.path.join(base_path, repo_name)

    try:

        if not check_repo_fast(repo_name, base_path):

            return False

        r = hg.repository(ui.ui(), repo_path)

        if verify:

            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',

                'diff', 'email',

                'extensions', 'format',

                'merge-patterns', 'merge-tools',

                'hooks', 'http_proxy',

                'smtp', 'patch',

                'paths', 'profiling',

                'server', 'trusted',

                'ui', 'web', ]

    baseui = ui.ui()

    if read_from == 'file':

        if not os.path.isfile(path):

            log.warning('Unable to read config file %s' % path)

            return False

        cfg = config.config()

        cfg.read(path)

        for section in sections:

            for k, v in cfg.items(section):

                baseui.setconfig(section, k, v)

        if checkpaths:check_repo_dir(cfg.items('paths'))                

    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)

    args = tuple(tmp)

    if name == 'cached_repo_list':

        from pylons_app.model.hg_model import _get_repos_cached

        region_invalidate(_get_repos_cached, None, *args)

    if name == 'full_changelog':

        from pylons_app.model.hg_model import _full_changelog_cached

        region_invalidate(_full_changelog_cached, None, *args)

from vcs.backends.base import BaseChangeset

from vcs.utils.lazy import LazyProperty