1.3.6 (**2012-05-17**)

- changed setup-app into setup-rhodecode and added arguments for auto-setup 

  mode that doesn't need user interaction 

    paster setup-rhodecode production.ini

entering this "root" path ``setup-rhodecode`` will also prompt you for a username 

and password for the initial admin account which ``setup-rhodecode`` sets 

up for you.

- The ``setup-rhodecode`` command will create all of the 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 RhodeCode will simply 

  add all of the repositories at the chosen location to it's database. 

  (Note: make sure you specify the correct path to the root).

- Use the admin account you created above when running ``setup-rhodecode`` 

  to login to the web app.

import os

from paste.script.appinstall import AbstractInstallCommand

from paste.script.command import BadCommand

from paste.deploy import appconfig

class SetupCommand(AbstractInstallCommand):

    default_verbosity = 1

    max_args = 1

    min_args = 1

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

    usage = "CONFIG_FILE"

    description = """\

    Note: this is an experimental command, and it will probably change

    in several ways by the next release.

    Setup an application 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 may

    consist of things like creating directories and setting up

    databases.

    """

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

    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)

    def admin_prompt(self, second=False, defaults={}):

            # defaults

            username = defaults.get('username')

            password = defaults.get('password')

            email = defaults.get('email')

            if username is None:

                username = raw_input('Specify admin username:')

            if password is None:

                    #second try

                    password = get_password()

                    if not password:

                        sys.exit()

            if email is None:

                email = raw_input('Specify admin email:')

    def config_prompt(self, test_repo_path='', retries=3, defaults={}):

        _path = defaults.get('repos_location')

        if _path is not None:

            path = _path

        elif not self.tests and not test_repo_path:

            self.message = safe_unicode(commit.message)

            self.message = commit.message.decode(commit.encoding or 'utf-8')

            response = self.app.get(url(controller='files',

    opts = dbmanage.config_prompt(None, defaults=command.options.__dict__)

    dbmanage.create_settings(opts)

    dbmanage.admin_prompt(defaults=command.options.__dict__)

    setup-rhodecode=rhodecode.config.setup_rhodecode:SetupCommand