if __name__=='__main__':

    if len(sys.argv)>2 and sys.argv[1]=='--md5update':

        update_md5(sys.argv[2:])

    else:

        main(sys.argv[1:])

        app = Cascade([static_app, app])

        app = make_gzip_middleware(app, global_conf, compress_level=1)

    app.config = config

    return app

        p = int(request.params.get('page', 1))

        c.users_log = Page(users_log, page=p, items_per_page=10)

        c.log_data = render('admin/admin_log.html')

        if request.params.get('partial'):

            return c.log_data

        return render('admin/admin.html')

        for (id, type, ctx, vtx, edges) in tree:

            if type != CHANGESET:

                continue

            data.append(('', vtx, edges))

        c.jsdata = json.dumps(data)

        if code == 403:

            return _("You don't have permission to view this page")

        if code == 404:

            return _('The resource could not be found')

        if code == 500:

            return _('The server encountered an unexpected condition which prevented it from fulfilling the request.')

        for name, chs in c.rhodecode_repo.tags.items():

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        hist_l.append(tags_group)

        return hist_l

                          author_email=entry.user.email,

                          author_name=entry.user.full_contact,

                          description=desc)

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

    rsa_key = '/home/id_rsa'

    B_MANAGER = BackupManager(repo_location, rsa_key, backup_server)

    B_MANAGER.backup_repos()

    B_MANAGER.transfer_files()

    B_MANAGER.rm_file()

            return ret

        except LockHeld:

            log.info('LockHeld')

            return 'Task with key %s already running' % lockkey

    return decorator(__wrapper, func)

                else:

                    code_stats[key] = 1

    map(aggregate, tip.walk('/'))

    return code_stats or {}

        start = COLOR_SEQ % (COLORS['SQL'])

        def_record = format_sql(logging.Formatter.format(self, record))

        end = RESET_SEQ

        colored_record = start + def_record + end

        return colored_record

            self.sa.add(create_repo_perm)

            self.sa.add(default_repo_perm)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    filename, ext = os.path.splitext(filename)

    sys.path.append(path)

    module = __import__(filename)

    reload(module) # Might be out of date during tests

    del sys.path[-1]

    return module

    return

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine

    return

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine

        return repo_name

    else:

        def make_link(group):

            return link_to(group.group_name, url('repos_group', id=group.group_id))

        return literal(' » '.join(map(make_link, groups)) + \

                       " » " + repo_name)

    action = action % ','.join(revs)

    action_logger(username, action, repository, extra_params['ip'])

    return 0

                pprint.pprint(environ, output, depth=3)

                resp += cgi.escape(output.getvalue(), True)

                resp += '</pre>'

            return resp

class DbMigrateVersion(Base):

    __tablename__ = 'db_migrate_version'

    __table_args__ = {'useexisting':True}

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

            cache_key.cache_active = True

            self.sa.add(cache_key)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()

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

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        assert "There is no file nor directory at the given path: %r at revision %r" % (f_path, rev[:12]) in response.session['flash'][0][1], 'No flash message'

        #register new user for email test

        response = self.app.post(url(controller='login', action='password_reset'),

                                            {'email':email, })

        print response.session['flash']

        assert 'You have successfully registered into rhodecode' in response.session['flash'][0], 'No flash message about user registration'

        assert 'Your new password was sent' in response.session['flash'][1], 'No flash message about password reset'

    def test_repo_search(self):

        self.log_user()

        response = self.app.get(url(controller='search', action='index'), {'q':'repository:%s def test' % HG_REPO})

        print response.body

        assert '4 results' in response.body, 'no message about proper search results'

        assert 'Permission denied' not in response.body, 'Wrong permissions settings for that repo and user'

        #check if fork is marked as fork

        response = self.app.get(url(controller='summary', action='index',

                                    repo_name=fork_name))

        assert 'Fork of %s' % repo_name in response.body, 'no message about that this repo is a fork'

    def _enable_stats(self):

        r = Repository.by_repo_name(HG_REPO)

        r.enable_statistics = True

        self.sa.add(r)

        self.sa.commit()

    #test_clone_wrong_credentials()

    #test_pull()

    test_push_new_file(commits=15)

    #test_push_wrong_path()

    #test_push_wrong_credentials()

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

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