# Unix, it will contain #! pointing at the right python executable. The script

# also makes sure sys.argv[0] points back at the script path, and that is what

# can be used to invoke 'kallithea-cli' later.

kallithea_cli_path = sys.argv[0]

def read_config(ini_file_name, strip_section_prefix):

    """Read ini_file_name content, and for all sections like '[X:Y]' where X is

    strip_section_prefix, replace the section name with '[Y]'."""

    def repl(m):

        if m.group(1) == strip_section_prefix:

            return '[%s]' % m.group(2)

        return m.group(0)

    with open(ini_file_name) as f:

        return re.sub(r'^\[([^:]+):(.*)]', repl, f.read(), flags=re.MULTILINE)

# This placeholder is the main entry point for the kallithea-cli command

@click.group(context_settings=dict(help_option_names=['-h', '--help']))

def cli():

    """Various commands to manage a Kallithea instance."""

    """Register a kallithea-cli subcommand.

    with -c and it is read and logging is configured. The configuration is

    available in the kallithea.CONFIG dict.

    If config_file_initialize_app is true, Kallithea, TurboGears global state

    (including tg.config), and database access will also be fully initialized.

    """

    cli_command = cli.command(hidden=hidden)

        def annotator(annotated):

            @click.option('--config_file', '-c', help="Path to .ini file with app configuration.",

                type=click.Path(dir_okay=False, exists=True, readable=True), required=True)

            @functools.wraps(annotated) # reuse meta data from the wrapped function so click can see other options

            def runtime_wrapper(config_file, *args, **kwargs):

                path_to_ini_file = os.path.realpath(config_file)

                kallithea.CONFIG = paste.deploy.appconfig('config:' + path_to_ini_file)

                cp = configparser.ConfigParser(strict=False)

                cp.read_string(read_config(path_to_ini_file, strip_section_prefix=annotated.__name__))

                logging.config.fileConfig(cp,

                    {'__file__': path_to_ini_file, 'here': os.path.dirname(path_to_ini_file)})

                if config_file_initialize_app:

                    kallithea.config.application.make_app(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)

                return annotated(*args, **kwargs)

            return cli_command(runtime_wrapper)

        return annotator

    return cli_command

# -*- 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/>.

import click

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.db_manage import DbManage

from kallithea.model.meta import Session

@click.option('--reuse/--no-reuse', default=False,

        help='Reuse and clean existing database instead of dropping and creating (default: no reuse)')

@click.option('--user', help='Username of administrator account.')

@click.option('--password', help='Password for administrator account.')

@click.option('--email', help='Email address of administrator account.')

@click.option('--repos', help='Absolute path to repositories location.')

@click.option('--force-yes', is_flag=True, help='Answer yes to every question.')

@click.option('--force-no', is_flag=True, help='Answer no to every question.')

@click.option('--public-access/--no-public-access', default=True,

        help='Enable/disable public access on this installation (default: enable)')

def db_create(user, password, email, repos, force_yes, force_no, public_access, reuse):

    """Initialize the database.

    Create all required tables in the database specified in the configuration

    file. Create the administrator account. Set certain settings based on

    values you provide.

    You can pass the answers to all questions as options to this command.

    """

    dbconf = kallithea.CONFIG['sqlalchemy.url']

    # force_ask should be True (yes), False (no), or None (ask)

    if force_yes:

        force_ask = True

# 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/>.

"""

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

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 click

import pkg_resources

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils2 import ask_ok

def extensions_create():

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

    An 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.

    """

    here = kallithea.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 %s already exists, do you want '

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

        if not ask_ok(msg):

            click.echo('Nothing done, exiting...')

            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)

    fileConfig('%(inifile)s', {'__file__': '%(inifile)s', 'here': '%(inifiledir)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)

'''

@click.option('--virtualdir', default='/',

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

def iis_install(virtualdir):

    """Install into IIS using isapi-wsgi."""

    config_file_abs = kallithea.CONFIG['__file__']

    try:

        import isapi_wsgi

        assert isapi_wsgi

    except ImportError:

        sys.stderr.write('missing requirement: isapi-wsgi not installed\n')

        sys.exit(1)

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

    click.echo('Writing %s' % dispatchfile)

    with open(dispatchfile, 'w') as f:

        f.write(dispath_py_template % {

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

            'inifiledir': os.path.dirname(config_file_abs).replace('\\', '\\\\'),

            'virtualdir': virtualdir,

            })

    click.echo('Run \'python "%s" install\' with administrative privileges '