Create the database, tables, and initial content by running the following

command::

    kallithea-cli db-create -c my.ini

This will first prompt you for a "root" path. This "root" path is the location

where Kallithea will store all of its repositories on the current machine. This

location must be writable for the running Kallithea application. Next,

``db-create`` will prompt you for a username and password for the initial admin

account it sets up for you.

The ``db-create`` values can also be given on the command line.

Example::

    kallithea-cli db-create -c my.ini --user=nn --password=secret --email=nn@example.com --repos=/srv/repos

The ``db-create`` command will create all needed tables and an

admin account. When choosing a root path you can either use a new

empty location, or a location which already contains existing

repositories. If you choose a location which contains existing

repositories Kallithea will add all of the repositories at the chosen

location to its database.  (Note: make sure you specify the correct

path to the root).

Prepare front-end files

^^^^^^^^^^^^^^^^^^^^^^^

Finally, the front-end files must be prepared. This requires ``npm`` version 6

or later, which needs ``node.js`` (version 12 or later). Prepare the front-end

by running::

    kallithea-cli front-end-build

Running

^^^^^^^

You are now ready to use Kallithea. To run it using a gearbox web server,

simply execute::

    gearbox serve -c my.ini

- This command runs the Kallithea server. The web app should be available at

  http://127.0.0.1:5000. The IP address and port is configurable via the

  configuration file created in the previous step.

- Log in to Kallithea using the admin account created when running ``db-create``.

- The default permissions on each repository is read, and the owner is admin.

  Remember to update these if needed.

- In the admin panel you can toggle LDAP, anonymous, and permissions

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

@cli_base.register_command(config_file=True)

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

    """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

    elif force_no:

        force_ask = False

    else:

        force_ask = None

    cli_args = dict(

            username=user,

            password=password,

            email=email,

            repos_location=repos,

            force_ask=force_ask,

            public_access=public_access,

    )

    dbmanage = DbManage(dbconf=dbconf, root=kallithea.CONFIG['here'],

                        tests=False, cli_args=cli_args)

    repo_root_path = dbmanage.prompt_repo_root_path(None)

    dbmanage.create_settings(repo_root_path)

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    Session().commit()

    # initial repository scan

    kallithea.config.application.make_app(

            kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)

    added, _ = kallithea.lib.utils.repo2db_mapper(kallithea.model.scm.ScmModel().repo_scan())

    if added:

        click.echo('Initial repository scan: added following repositories:')

        click.echo('\t%s' % '\n\t'.join(added))

    else:

        click.echo('Initial repository scan: no repositories found.')

    click.echo('Database set up successfully.')

    click.echo("Don't forget to build the front-end using 'kallithea-cli front-end-build'.")

        self.dbname = dbconf.split('/')[-1]

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.cli_args = cli_args or {}

        self.init_db(SESSION=SESSION)

    def _ask_ok(self, msg):

        """Invoke ask_ok unless the force_ask option provides the answer"""

        force_ask = self.cli_args.get('force_ask')

        if force_ask is not None:

            return force_ask

        from kallithea.lib.utils2 import ask_ok

        return ask_ok(msg)

    def init_db(self, SESSION=None):

        if SESSION:

            self.sa = SESSION

        else:

            # init new sessions

            engine = create_engine(self.dburi)

            init_model(engine)

            self.sa = Session()

        """

        Create database (optional) and tables.

        """

        url = sqlalchemy.engine.url.make_url(self.dburi)

        database = url.database

        if not self.tests:

            if not self._ask_ok('Are you sure to destroy old database? [y/n]'):

                print('Nothing done.')

                sys.exit(0)

            if url.drivername == 'mysql':

                url.database = None  # don't connect to the database (it might not exist)

                engine = sqlalchemy.create_engine(url)

                with engine.connect() as conn:

                    conn.execute('DROP DATABASE IF EXISTS `%s`' % database)

                    conn.execute('CREATE DATABASE `%s` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci' % database)

            elif url.drivername == 'postgresql':

                from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT

                url.database = 'postgres'  # connect to the system database (as the real one might not exist)

                engine = sqlalchemy.create_engine(url)

                with engine.connect() as conn:

                    conn.connection.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)

                    conn.execute('DROP DATABASE IF EXISTS "%s"' % database)

                    conn.execute('CREATE DATABASE "%s"' % database)

            else:

                # Some databases enforce foreign key constraints and Base.metadata.drop_all() doesn't work, but this is

                # known to work on SQLite - possibly not on other databases with strong referential integrity

                Base.metadata.drop_all()

        Base.metadata.create_all(checkfirst=False)

        # Create an Alembic configuration and generate the version table,

        # "stamping" it with the most recent Alembic migration revision, to

        # tell Alembic that all the schema upgrades are already in effect.