method = args.method

    if method == '_create_config':

        sys.exit()

    try:

        margs = dict(map(lambda s: s.split(':', 1), other))

        sys.stderr.write('Error parsing arguments \n')

        sys.exit()

    api_call(apikey, host, args.format, method, **margs)

    return 0

        try:

            by_id = repo_name.split('_')

            if len(by_id) == 2 and by_id[1].isdigit() and by_id[0] == '':

                repo_name = Repository.get(by_id[1]).repo_name

                match_dict['repo_name'] = repo_name

            pass

        return is_valid_repo(repo_name, config['base_path'])

    def check_group(environ, match_dict):

        """

                .options(joinedload(UserLog.repository))

        #FILTERING

        c.search_term = request.GET.get('filter')

        try:

            users_log = _journal_filter(users_log, c.search_term)

            # we want this to crash for now

            raise

        users_log = users_log.order_by(UserLog.action_date.desc())

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

                repo_id = Repository.get_by_repo_name(repo_name).repo_id

                user_id = User.get_by_username('default').user_id

                self.scm_model.toggle_following_repo(repo_id, user_id)

                h.flash(_('Updated repository visibility in public journal'),

                        category='success')

                Session().commit()

                h.flash(_('An error occurred during setting this'

                          ' repository in public journal'),

                        category='error')

        else:

            h.flash(_('Token mismatch'), category='error')

def get_ignore_ws(fid, GET):

    ig_ws_global = GET.get('ignorews')

    ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))

    if ig_ws:

        try:

            return int(ig_ws[0].split(':')[-1])

            pass

    return ig_ws_global

def _ignorews_url(GET, fileid=None):

    fileid = str(fileid) if fileid else None

        retval = ln_ctx[0].split(':')[-1]

    else:

        retval = ln_ctx_global

    try:

        return int(retval)

        return 3

def _context_url(GET, fileid=None):

    """

    Generates url for context lines

    def get_error_explanation(self, code):

        ''' get the error explanations of int codes

            [400, 401, 403, 404, 500]'''

        try:

            code = int(code)

            code = 500

        if code == 400:

            return _('The request could not be understood by the server'

                     ' due to malformed syntax.')

        if code == 401:

            journal = self.sa.query(UserLog)\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))

            #filter

            try:

                journal = _journal_filter(journal, c.search_term)

                # we want this to crash for now

                raise

            journal = journal.filter(filtering_criterion)\

                        .order_by(UserLog.action_date.desc())

        else:

            journal = []

            if user_id:

                try:

                    self.scm_model.toggle_following_user(user_id,

                                                self.rhodecode_user.user_id)

                    Session.commit()

                    return 'ok'

                    raise HTTPBadRequest()

            repo_id = request.POST.get('follows_repo_id')

            if repo_id:

                try:

                    self.scm_model.toggle_following_repo(repo_id,

                                                self.rhodecode_user.user_id)

                    Session.commit()

                    return 'ok'

                    raise HTTPBadRequest()

        log.debug('token mismatch %s vs %s' % (cur_token, token))

        raise HTTPBadRequest()

    @LoginRequired()

        # comments

        c.comments = cc_model.get_comments(c.rhodecode_db_repo.repo_id,

                                           pull_request=pull_request_id)

        try:

            cur_status = c.statuses[c.pull_request.revisions[0]][0]

            log.error(traceback.format_exc())

            cur_status = 'undefined'

        if c.pull_request.is_closed() and 0:

            c.current_changeset_status = cur_status

        else:

            # changeset(pull-request) status calulation based on reviewers

            data = repo_name.split('/')

            if len(data) >= 2:

                by_id = data[1].split('_')

                if len(by_id) == 2 and by_id[1].isdigit():

                    _repo_name = Repository.get(by_id[1]).repo_name

                    data[1] = _repo_name

            log.debug('Failed to extract repo_name from id %s' % (

                      traceback.format_exc()

                      )

            )

        return '/'.join(data)

        paths.ui_value = paths.ui_value.replace('*', '')

        try:

            self.sa.add(paths)

            self.sa.commit()

            self.sa.rollback()

            raise

    def fix_default_user(self):

        """

        Fixes a old default user with some 'nicer' default values,

        def_user.lastname = 'User'

        def_user.email = 'anonymous@rhodecode.org'

        try:

            self.sa.add(def_user)

            self.sa.commit()

            self.sa.rollback()

            raise

    def fix_settings(self):

        """

        Fixes rhodecode settings adds ga_code key for google analytics

        hgsettings3 = RhodeCodeSetting('ga_code', '')

        try:

            self.sa.add(hgsettings3)

            self.sa.commit()

            self.sa.rollback()

            raise

    def admin_prompt(self, second=False):

        if not self.tests:

            import getpass

            log.debug('processed prefix:`%s` => %s' % (pattern_index, newtext))

        # if we actually did something above

        if link_:

            # wrap not links into final link => link_

            newtext = linkify_others(newtext, link_)

        log.error(traceback.format_exc())

        pass

    return literal(newtext)

        #======================================================================

        # EXTRACT REPOSITORY NAME FROM ENV

        #======================================================================

        try:

            repo_name = self.__get_repository(environ)

            log.debug('Extracted repo name is %s' % repo_name)

            return HTTPInternalServerError()(environ, start_response)

        # quick check if that dir exists...

        if not is_valid_repo(repo_name, self.basepath, 'git'):

            return HTTPNotFound()(environ, start_response)

                #==============================================================

                try:

                    user = self.__get_user(username)

                    if user is None or not user.active:

                        return HTTPForbidden()(environ, start_response)

                    username = user.username

                    log.error(traceback.format_exc())

                    return HTTPInternalServerError()(environ, start_response)

                #check permissions for this repository

                perm = self._check_permission(action, user, repo_name, ip_addr)

                if not perm:

        :param environ: environ where PATH_INFO is stored

        """

        try:

            environ['PATH_INFO'] = self._get_by_id(environ['PATH_INFO'])

            repo_name = GIT_PROTO_PAT.match(environ['PATH_INFO']).group(1)

            log.error(traceback.format_exc())

            raise

        return repo_name

    def __get_user(self, username):

        #======================================================================

        # EXTRACT REPOSITORY NAME FROM ENV

        #======================================================================

        try:

            repo_name = environ['REPO_NAME'] = self.__get_repository(environ)

            log.debug('Extracted repo name is %s' % repo_name)

            return HTTPInternalServerError()(environ, start_response)

        # quick check if that dir exists...

        if not is_valid_repo(repo_name, self.basepath, 'hg'):

            return HTTPNotFound()(environ, start_response)

                #==============================================================

                try:

                    user = self.__get_user(username)

                    if user is None or not user.active:

                        return HTTPForbidden()(environ, start_response)

                    username = user.username

                    log.error(traceback.format_exc())

                    return HTTPInternalServerError()(environ, start_response)

                #check permissions for this repository

                perm = self._check_permission(action, user, repo_name, ip_addr)

                if not perm:

        """

        try:

            environ['PATH_INFO'] = self._get_by_id(environ['PATH_INFO'])

            repo_name = '/'.join(environ['PATH_INFO'].split('/')[1:])

            if repo_name.endswith('/'):

                repo_name = repo_name.rstrip('/')

            log.error(traceback.format_exc())

            raise

        return repo_name

    def __get_user(self, username):

        sa.add(user_log)

        log.info('Logging action:%s on %s by user:%s ip:%s' %

                 (action, safe_unicode(repo), user_obj, ipaddr))

        if commit:

            sa.commit()

        log.error(traceback.format_exc())

        raise

def get_repos(path, recursive=False, skip_removed_repos=True):

    """

                log.debug("Removing non-existing repository found in db `%s`" %

                          repo.repo_name)

                try:

                    sa.delete(repo)

                    sa.commit()

                    removed.append(repo.repo_name)

                    #don't hold further removals on error

                    log.error(traceback.format_exc())

                    sa.rollback()

    return added, removed

    ver = (stdout.split(' ')[-1] or '').strip() or '0.0.0'

    if len(ver.split('.')) > 3:

        #StrictVersion needs to be only 3 element type

        ver = '.'.join(ver.split('.')[:3])

    try:

        _ver = StrictVersion(ver)

        _ver = StrictVersion('0.0.0')

        stderr = traceback.format_exc()

    req_ver = '1.7.4'

    to_old_git = False

    if  _ver < StrictVersion(req_ver):

    _url = engine or ''

    from sqlalchemy.engine import url as sa_url

    try:

        _url = sa_url.make_url(engine)

        if _url.password:

            _url.password = 'XXXXX'

        pass

    return str(_url)

def get_server_url(environ):

    req = webob.Request(environ)

    """

    if not env:

        env = os.environ

    try:

        rc_extras = json.loads(env['RC_SCM_DATA'])

        print os.environ

        print >> sys.stderr, traceback.format_exc()

        rc_extras = {}

    try:

        for k in ['username', 'repository', 'locked_by', 'scm', 'make_lock',

            revision = self.revisions[-1]

        if ((is_bstr(revision) and revision.isdigit() and len(revision) < 12)

            or isinstance(revision, int) or is_null(revision)):

            try:

                revision = self.revisions[int(revision)]

                raise ChangesetDoesNotExistError("Revision %s does not exist "

                    "for this repository" % (revision))

        elif is_bstr(revision):

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

            return dummy

    @changeset_cache.setter

    def changeset_cache(self, val):

        try:

            self._changeset_cache = json.dumps(val)

            log.error(traceback.format_exc())

    @classmethod

    def url_sep(cls):

        return URL_SEP

            if org_repo_name != new_name:

                # rename repository

                self.__rename_repo(old=org_repo_name, new=new_name)

            return cur_repo

            log.error(traceback.format_exc())

            raise

    def create_repo(self, repo_name, repo_type, description, owner,

                    private=False, clone_uri=None, repos_group=None,

                    landing_rev='tip', just_db=False, fork_of=None,

                                      created_by=owner.username)

            # now automatically start following this repository as owner

            ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,

                                                    owner.user_id)

            return new_repo

            log.error(traceback.format_exc())

            raise

    def create(self, form_data, cur_user, just_db=False, fork=None):

        """

        Backward compatibility function, just a wrapper on top of create_repo

            owner = repo.user

            try:

                self.sa.delete(repo)

                self.__delete_repo(repo)

                log_delete_repository(old_repo_dict,

                                      deleted_by=owner.username)

                log.error(traceback.format_exc())

                raise

    def grant_user_permission(self, repo, user, perm):

        """

        Grant permission for user on given repository, or update existing one

        repo = self._get_repo(repo_name)

        try:

            obj = self.sa.query(Statistics)\

                    .filter(Statistics.repository == repo).scalar()

            if obj:

                self.sa.delete(obj)

            log.error(traceback.format_exc())

            raise

    def __create_repo(self, repo_name, alias, parent, clone_uri=False):

        """

        makes repository on filesystem. It's group aware means it'll create

                # we need to flush here, in order to check if database won't

                # throw any exceptions, create filesystem dirs at the very end

                self.sa.flush()

                self.__create_group(new_repos_group.group_name)

            return new_repos_group

            log.error(traceback.format_exc())

            raise

    def _update_permissions(self, repos_group, perms_new=None,

                            perms_updates=None, recursive=False):

        from rhodecode.model.repo import RepoModel

                    obj.repo_name = new_name

                self.sa.add(obj)

            self.__rename_group(old_path, new_path)

            return repos_group

            log.error(traceback.format_exc())

            raise

    def delete(self, repos_group, force_delete=False):

        repos_group = self._get_repos_group(repos_group)

        try:

            self.sa.delete(repos_group)

            self.__delete_group(repos_group, force_delete)

            log.error('Error removing repos_group %s' % repos_group)

            raise

    def delete_permission(self, repos_group, obj, obj_type, recursive):

        """

        Revokes permission for repos_group for given obj(user or users_group),

            try:

                self.sa.delete(f)

                action_logger(UserTemp(user_id),

                              'stopped_following_repo',

                              RepoTemp(follow_repo_id))

                return

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_repo_id = follow_repo_id

            self.sa.add(f)

            action_logger(UserTemp(user_id),

                          'started_following_repo',

                          RepoTemp(follow_repo_id))

            log.error(traceback.format_exc())

            raise

    def toggle_following_user(self, follow_user_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user_id == follow_user_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                return

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_user_id = follow_user_id

            self.sa.add(f)

            log.error(traceback.format_exc())

            raise

    def is_following_repo(self, repo_name, user_id, cache=False):

        r = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        try:

            if repo.alias == 'git':

                repo.fetch(clone_uri)

            else:

                repo.pull(clone_uri)

            self.mark_for_invalidation(repo_name)

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message,

                      content, f_path):

        """

                                         % 'RC_HOOK_VER').search(data)

                    if matches:

                        try:

                            ver = matches.groups()[0]

                            log.debug('got %s it is rhodecode' % (ver))

                            _rhodecode_hook = True

                            log.error(traceback.format_exc())

            else:

                # there is no hook in this dir, so we want to create one

                _rhodecode_hook = True

            if _rhodecode_hook or force_create:

                    k = 'name'

                setattr(new_user, k, v)

            new_user.api_key = generate_api_key(form_data['username'])

            self.sa.add(new_user)

            return new_user

            log.error(traceback.format_exc())

            raise

    def create_or_update(self, username, password, email, firstname='',

                         lastname='', active=True, admin=False, ldap_dn=None):

        """

            kw = {'registered_user_url': edit_url}

            NotificationModel().create(created_by=new_user, subject=subject,

                                       body=body, recipients=None,

                                       type_=Notification.TYPE_REGISTRATION,

                                       email_kwargs=kw)

            log.error(traceback.format_exc())

            raise

    def update(self, user_id, form_data, skip_attrs=[]):

        from rhodecode.lib.auth import get_crypt_password

        try:

                    user.api_key = generate_api_key(user.username)

                else:

                    if k == 'firstname':

                        k = 'name'

                    setattr(user, k, v)

            self.sa.add(user)

            log.error(traceback.format_exc())

            raise

    def update_user(self, user, **kwargs):

        from rhodecode.lib.auth import get_crypt_password

        try:

                    v = get_crypt_password(v)

                    user.api_key = generate_api_key(user.username)

                setattr(user, k, v)

            self.sa.add(user)

            return user

            log.error(traceback.format_exc())

            raise

    def delete(self, user):

        user = self._get_user(user)

                raise UserOwnsReposException(

                    _(u'user "%s" still owns %s repositories and cannot be '

                      'removed. Switch owners or remove those repositories. %s')

                    % (user.username, len(repos), ', '.join(repos))

                )

            self.sa.delete(user)

            log.error(traceback.format_exc())

            raise

    def reset_password_link(self, data):

        from rhodecode.lib.celerylib import tasks, run_task

        from rhodecode.model.notification import EmailNotificationModel

                log.debug('sending email')

                run_task(tasks.send_email, user_email,

                         _("password reset link"), body, body)

                log.info('send new password mail to %s' % user_email)

            else:

                log.debug("password reset email %s not found" % user_email)

            log.error(traceback.format_exc())

            return False

        return True

    def reset_password(self, data):

                    user.api_key = auth.generate_api_key(user.username)

                    Session().add(user)

                    Session().commit()

                    log.info('change password for %s' % user_email)

                if new_passwd is None:

                    raise Exception('unable to generate new password')

                log.error(traceback.format_exc())

                Session().rollback()

            run_task(tasks.send_email, user_email,

                     _('Your new password'),

                     _('Your new RhodeCode password:%s') % (new_passwd))

            log.info('send new password mail to %s' % user_email)

            log.error('Failed to update user password')

            log.error(traceback.format_exc())

        return True

    def fill_data(self, auth_user, user_id=None, api_key=None):

                log.debug('filling %s data' % dbuser)

                for k, v in dbuser.get_dict().items():

                    setattr(auth_user, k, v)

            else:

                return False

            log.error(traceback.format_exc())

            auth_user.is_authenticated = False

            return False

        return True

        try:

            new = UserGroup()

            new.users_group_name = name

            new.users_group_active = active

            self.sa.add(new)

            return new

            log.error(traceback.format_exc())

            raise

    def update(self, users_group, form_data):

        try:

                            member = UserGroupMember(users_group.users_group_id, u_id)

                            members_list.append(member)

                    setattr(users_group, 'members', members_list)

                setattr(users_group, k, v)

            self.sa.add(users_group)

            log.error(traceback.format_exc())

            raise

    def delete(self, users_group, force=False):

        """

        Deletes repos group, unless force flag is used

            if assigned_groups and not force:

                raise UserGroupsAssignedException('RepoGroup assigned to %s' %

                                                   assigned_groups)

            self.sa.delete(users_group)

            log.error(traceback.format_exc())

            raise

    def add_user_to_group(self, users_group, user):

        users_group = self.__get_users_group(users_group)

        user = self._get_user(user)

            users_group.members.append(users_group_member)

            user.group_member.append(users_group_member)

            self.sa.add(users_group_member)

            return users_group_member

            log.error(traceback.format_exc())

            raise

    def remove_user_from_group(self, users_group, user):

        users_group = self.__get_users_group(users_group)