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

        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

log = logging.getLogger(__name__)

def notify(msg):

    """

    Notification for migrations messages

    """

    ml = len(msg) + (4 * 2)

    print >> sys.stdout, ('*** %s ***\n%s' % (msg, '*' * ml)).upper()

class DbManage(object):

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

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.log_sql = log_sql

        self.db_exists = False

        self.init_db()

    def init_db(self):

        engine = create_engine(self.dburi, echo=self.log_sql)

        init_model(engine)

        self.sa = Session()

        """

        Create a auth database

        """

        log.info("Any existing database is going to be destroyed")

            destroy = True

        else:

            destroy = ask_ok('Are you sure to destroy old database ? [y/n]')

        if not destroy:

        if destroy:

            Base.metadata.drop_all()

        checkfirst = not override

        Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s' % self.dbname)

    def set_db_version(self):

        ver = DbMigrateVersion()

        ver.version = __dbversion__

        ver.repository_id = 'rhodecode_db_migrations'

        ver.repository_path = 'versions'

        Fixes rhodecode settings adds ga_code key for google analytics

        """

        hgsettings3 = RhodeCodeSetting('ga_code', '')

        try:

            self.sa.add(hgsettings3)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

        if not self.tests:

            import getpass

            # defaults

            username = defaults.get('username')

            password = defaults.get('password')

            email = defaults.get('email')

            def get_password():

                password = getpass.getpass('Specify admin password '

                                           '(min 6 chars):')

                confirm = getpass.getpass('Confirm password:')

                if password != confirm:

                    log.error('passwords mismatch')

                    return False

            return

        u2p = UserToPerm.query()\

            .filter(UserToPerm.user == default_user).all()

        fixed = False

        if len(u2p) != len(User.DEFAULT_PERMISSIONS):

            for p in u2p:

                Session().delete(p)

            fixed = True

            self.populate_default_permissions()

        return fixed

        _path = defaults.get('repos_location')

        if retries == 3:

            log.info('Setting up repositories config')

        if _path is not None:

            path = _path

        elif not self.tests and not test_repo_path:

            path = raw_input(

                 'Enter a valid absolute path to store repositories. '

                 'All repositories in that path will be added automatically:'

            )

        else:

psql -U postgres -h localhost -c 'drop database if exists rhodecode;'

psql -U postgres -h localhost -c 'create database rhodecode;'

API_KEY=`psql -R " " -A -U postgres -h localhost -c "select api_key from users where admin=TRUE" -d rhodecode | awk '{print $2}'`

echo "run those after running server"

paster serve rc.ini --pid-file=rc.pid --daemon

sleep 3

rhodecode-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_user username:demo1 password:qweqwe email:demo1@rhodecode.org

rhodecode-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_user username:demo2 password:qweqwe email:demo2@rhodecode.org

rhodecode-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_user username:demo3 password:qweqwe email:demo3@rhodecode.org

rhodecode-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_users_group group_name:demo12

rhodecode-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 add_user_to_users_group usersgroupid:demo12 userid:demo1

rhodecode-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 add_user_to_users_group usersgroupid:demo12 userid:demo2

echo "killing server"

kill `cat rc.pid`

from rhodecode.config.environment import load_environment

from rhodecode.lib.db_manage import DbManage

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

def setup_app(command, conf, vars):

    """Place any commands to setup rhodecode here"""

    dbconf = conf['sqlalchemy.db1.url']

    dbmanage = DbManage(log_sql=True, dbconf=dbconf, root=conf['here'],

    dbmanage.set_db_version()

    dbmanage.create_settings(opts)

    dbmanage.create_default_user()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    load_environment(conf.global_conf, conf.local_conf, initial=True)

    dbmanage.finish()