# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.paster_commands.cache_keys

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

cleanup-keys paster command for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: mar 27, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

from kallithea.model.meta import Session

from kallithea.lib.utils import BasePasterCommand

from kallithea.model.db import CacheInvalidation

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "Kallithea"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Cache keys utils"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        _caches = CacheInvalidation.query().order_by(CacheInvalidation.cache_key).all()

        if self.options.show:

            for c_obj in _caches:

                print 'key:%s active:%s' % (c_obj.cache_key, c_obj.cache_active)

        elif self.options.cleanup:

            for c_obj in _caches:

                Session().delete(c_obj)

                Session().commit()

        else:

    def update_parser(self):

        self.parser.add_option(

            '--show',

            action='store_true',

            dest='show',

            help=("show existing cache keys with together with status")

        )

        self.parser.add_option(

            '--cleanup',

            action="store_true",

            dest="cleanup",

            help="cleanup existing cache keys"

        )

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.paster_commands.cleanup

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

cleanup-repos paster command for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jul 14, 2012

:author: marcink

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

import re

import shutil

import datetime

from kallithea.lib.utils import BasePasterCommand, ask_ok, REMOVED_REPO_PAT

from kallithea.lib.utils2 import safe_str

from kallithea.model.db import Ui

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "Kallithea"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Cleanup deleted repos"

    def _parse_older_than(self, val):

        regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')

        parts = regex.match(val)

        if not parts:

            return

        parts = parts.groupdict()

        time_params = {}

        for (name, param) in parts.iteritems():

            if param:

                time_params[name] = int(param)

        return datetime.timedelta(**time_params)

    def _extract_date(self, name):

        """

        Extract the date part from rm__<date> pattern of removed repos,

        and convert it to datetime object

        :param name:

        """

        date_part = name[4:19]  # 4:19 since we don't parse milisecods

        return datetime.datetime.strptime(date_part, '%Y%m%d_%H%M%S')

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        repos_location = Ui.get_repos_location()

        to_remove = []

        for dn_, dirs, f in os.walk(safe_str(repos_location)):

            alldirs = list(dirs)

            del dirs[:]

            if ('.hg' in alldirs or

                'objects' in alldirs and ('refs' in alldirs or 'packed-refs' in f)):

                continue

            for loc in alldirs:

                if REMOVED_REPO_PAT.match(loc):

                    to_remove.append([os.path.join(dn_, loc),

                                      self._extract_date(loc)])

                else:

                    dirs.append(loc)

        #filter older than (if present)!

        now = datetime.datetime.now()

        older_than = self.options.older_than

        if older_than:

            to_remove_filtered = []

            older_than_date = self._parse_older_than(older_than)

            for name, date_ in to_remove:

                repo_age = now - date_

                if repo_age > older_than_date:

                    to_remove_filtered.append([name, date_])

            to_remove = to_remove_filtered

                % (len(to_remove), older_than, older_than_date)

        else:

        if self.options.dont_ask or not to_remove:

            # don't ask just remove !

            remove = True

        else:

            remove = ask_ok('the following repositories will be deleted completely:\n%s\n'

                            'are you sure you want to remove them [y/n]?'

        if remove:

            for path, date_ in to_remove:

                shutil.rmtree(path)

        else:

    def update_parser(self):

        self.parser.add_option(

            '--older-than',

            action='store',

            dest='older_than',

            help=("only remove repos that have been removed "

                 "at least given time ago. "

                 "The default is to remove all removed repositories. "

                 "Possible suffixes: "

                 "d (days), h (hours), m (minutes), s (seconds). "

                 "For example --older-than=30d deletes repositories "

                 "removed more than 30 days ago.")

            )

        self.parser.add_option(

            '--dont-ask',

            action="store_true",

            dest="dont_ask",

            help="remove repositories without asking for confirmation."

        )

import os

import sys

from paste.script.appinstall import AbstractInstallCommand

from paste.script.command import BadCommand

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(AbstractInstallCommand):

    default_verbosity = 1

    max_args = 1

    min_args = 1

    summary = 'Setup IIS given a config file'

    usage = 'CONFIG_FILE'

    description = '''

    Script for installing into IIS using isapi-wsgi.

    '''

    parser = AbstractInstallCommand.standard_parser(

        simulate=True, quiet=True, interactive=True)

    parser.add_option('--virtualdir',

                      action='store',

                      dest='virtualdir',

                      default='/',

                      help='The virtual folder to install into on IIS')

    def command(self):

        config_spec = self.args[0]

        if not config_spec.startswith('config:'):

            config_spec = 'config:' + config_spec

        config_file = config_spec[len('config:'):].split('#', 1)[0]

        config_file = os.path.join(os.getcwd(), config_file)

        try:

            import isapi_wsgi

        except ImportError:

            raise BadCommand('missing requirement: isapi-wsgi not installed')

if hasattr(sys, "isapidllhandle"):

    import win32traceutil

import isapi_wsgi

import os

def __ExtensionFactory__():

    from paste.deploy import loadapp

    from paste.script.util.logging_config import fileConfig

    fileConfig('%(inifile)s')

    application = loadapp('config:%(inifile)s')

    def app(environ, start_response):

        user = environ.get('REMOTE_USER', None)

        if user is not None:

            os.environ['REMOTE_USER'] = user

        return application(environ, start_response)

    return isapi_wsgi.ISAPIThreadPoolHandler(app)

if __name__=='__main__':

    from isapi.install import *

    params = ISAPIParameters()

    sm = [ScriptMapParams(Extension="*", Flags=0)]

    vd = VirtualDirParameters(Name="%(virtualdir)s",

                              Description = "Kallithea",

                              ScriptMaps = sm,

                              ScriptMapUpdate = "replace")

    params.VirtualDirs = [vd]

    HandleCommandLine(params)

'''

        outdata = file % {

                'inifile': config_file.replace('\\', '\\\\'),

                'virtualdir': self.options.virtualdir

                }

        dispatchfile = os.path.join(os.getcwd(), 'dispatch.py')

        self.ensure_file(dispatchfile, outdata, False)

            'to generate the _dispatch.dll file and install it into the '

            'default web site') % (dispatchfile,)

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.paster_commands.ishell

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

interactive shell paster command for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 4, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

from kallithea.lib.utils import BasePasterCommand

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "Kallithea"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Interactive shell"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        import os

        import sys

        import time

        import shutil

        import datetime

        from kallithea.model.db import *

        try:

            from IPython import embed

            from IPython.config.loader import Config

            cfg = Config()

            cfg.InteractiveShellEmbed.confirm_exit = False

            embed(config=cfg, banner1="Kallithea IShell.")

        except ImportError:

            sys.exit(-1)

    def update_parser(self):

        pass

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.paster_commands.make_index

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

make-index paster command for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Aug 17, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

from string import strip

from kallithea.model.repo import RepoModel

from kallithea.lib.utils import BasePasterCommand, load_rcextensions

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "Kallithea"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Creates or updates full text search index"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        from pylons import config

        index_location = config['index_dir']

        load_rcextensions(config['here'])

        repo_location = self.options.repo_location \

            if self.options.repo_location else RepoModel().repos_path

        repo_list = map(strip, self.options.repo_list.split(',')) \

            if self.options.repo_list else None

        repo_update_list = map(strip, self.options.repo_update_list.split(',')) \

            if self.options.repo_update_list else None

        #======================================================================

        # WHOOSH DAEMON

        #======================================================================

        from kallithea.lib.pidlock import LockHeld, DaemonLock

        from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

        try:

            l = DaemonLock(file_=os.path.join(dn(dn(index_location)),

                                              'make_index.lock'))

            WhooshIndexingDaemon(index_location=index_location,

                                 repo_location=repo_location,

                                 repo_list=repo_list,

                                 repo_update_list=repo_update_list)\

                .run(full_index=self.options.full_index)

            l.release()

        except LockHeld:

            sys.exit(1)

    def update_parser(self):

        self.parser.add_option('--repo-location',

                          action='store',

                          dest='repo_location',

                          help="Specifies repositories location to index OPTIONAL",

                          )

        self.parser.add_option('--index-only',

                          action='store',

                          dest='repo_list',

                          help="Specifies a comma separated list of repositories "

                                "to build index on. If not given all repositories "

                                "are scanned for indexing. OPTIONAL",

                          )

        self.parser.add_option('--update-only',

                          action='store',

                          dest='repo_update_list',

                          help="Specifies a comma separated list of repositories "

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.paster_commands.make_rcextensions

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

make-rcext paster command for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Mar 6, 2012

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

import pkg_resources

from kallithea.lib.utils import BasePasterCommand, ask_ok

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    group_name = "Kallithea"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Write template file for extending Kallithea in Python."

    usage = "CONFIG_FILE"

    description = '''\

        A rcextensions directory with a __init__.py file will be created next to

        the ini file. Local customizations in that file will survive upgrades.

        The file contains instructions on how it can be customized.

        '''

    def command(self):

        from pylons import config

        here = config['here']

        content = pkg_resources.resource_string(

            'kallithea', os.path.join('config', 'rcextensions', '__init__.py')

        )

        ext_file = os.path.join(here, 'rcextensions', '__init__.py')

        if os.path.exists(ext_file):

            msg = ('Extension file already exists, do you want '

                   'to overwrite it ? [y/n]')

            if not ask_ok(msg):

                return

        dirname = os.path.dirname(ext_file)

        if not os.path.isdir(dirname):

            os.makedirs(dirname)

        with open(ext_file, 'wb') as f:

            f.write(content)

            print 'Wrote new extensions file to %s' % ext_file

    def update_parser(self):

        pass

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.paster_commands.repo_scan

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

repo-scan paster command for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Feb 9, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

from kallithea.model.scm import ScmModel

from kallithea.lib.utils import BasePasterCommand, repo2db_mapper

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "Kallithea"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Rescan default location for new repositories"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        rm_obsolete = self.options.delete_obsolete

        print 'Now scanning root location for new repos ...'

        added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                        remove_obsolete=rm_obsolete)

        added = ', '.join(added) or '-'

        removed = ', '.join(removed) or '-'

        print 'Scan completed added: %s removed: %s' % (added, removed)

    def update_parser(self):

        self.parser.add_option(

            '--delete-obsolete',

            action='store_true',

            help="Use this flag do delete repositories that are "

                 "present in Kallithea database but not on the filesystem",

        )

import os

import sys

from paste.script.appinstall import AbstractInstallCommand

from paste.script.command import BadCommand

from paste.deploy import appconfig

# Add location of top level folder to sys.path

from os.path import dirname as dn

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

sys.path.append(rc_path)

class Command(AbstractInstallCommand):

    default_verbosity = 1

    max_args = 1

    min_args = 1

    summary = "Setup an application, given a config file"

    usage = "CONFIG_FILE"

    group_name = "Kallithea"

    description = """\

    Setup Kallithea according to its configuration file.  This is

    the second part of a two-phase web application installation

    process (the first phase is prepare-app).  The setup process

    consist of things like setting up databases, creating super user

    """

    parser = AbstractInstallCommand.standard_parser(

        simulate=True, quiet=True, interactive=True)

    parser.add_option('--user',

                      action='store',

                      dest='username',

                      default=None,

                      help='Admin Username')

    parser.add_option('--email',

                      action='store',

                      dest='email',

                      default=None,

                      help='Admin Email')

    parser.add_option('--password',

                      action='store',

                      dest='password',

                      default=None,

                      help='Admin password min 6 chars')

    parser.add_option('--repos',

                      action='store',

                      dest='repos_location',

                      default=None,

                      help='Absolute path to repositories location')

    parser.add_option('--name',

                      action='store',

                      dest='section_name',

                      default=None,

                      help='The name of the section to set up (default: app:main)')

    parser.add_option('--force-yes',

                       action='store_true',

                       dest='force_ask',

                       default=None,

                       help='Force yes to every question')

    parser.add_option('--force-no',

                       action='store_false',

                       dest='force_ask',

                       default=None,

                       help='Force no to every question')

    parser.add_option('--public-access',

                       action='store_true',

                       dest='public_access',

                       default=None,

                       help='Enable public access on this installation (default)')

    parser.add_option('--no-public-access',

                       action='store_false',

                       dest='public_access',

                       default=None,

                       help='Disable public access on this installation ')

    def command(self):

        config_spec = self.args[0]

        section = self.options.section_name

        if section is None:

            if '#' in config_spec:

                config_spec, section = config_spec.split('#', 1)

            else:

                section = 'main'

        if not ':' in section:

            plain_section = section

            section = 'app:' + section

        else:

            plain_section = section.split(':', 1)[0]

        if not config_spec.startswith('config:'):

            config_spec = 'config:' + config_spec

        if plain_section != 'main':

            config_spec += '#' + plain_section

        config_file = config_spec[len('config:'):].split('#', 1)[0]

        config_file = os.path.join(os.getcwd(), config_file)

        self.logging_file_config(config_file)

        conf = appconfig(config_spec, relative_to=os.getcwd())

        ep_name = conf.context.entry_point_name

        ep_group = conf.context.protocol

        dist = conf.context.distribution

        if dist is None:

            raise BadCommand(

                "The section %r is not the application (probably a filter).  "

                "You should add #section_name, where section_name is the "

                "section that configures your application" % plain_section)

        installer = self.get_installer(dist, ep_group, ep_name)

        installer.setup_config(

            self, config_file, section, self.sysconfig_install_vars(installer))

        self.call_sysconfig_functions(

            'post_setup_hook', installer, config_file)

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.