result : "Pulled from `<reponame>`"

    error :  null

rescan_repos

------------

Dispatch rescan repositories action. If remove_obsolete is set

RhodeCode will delete repos that are in database but not in the filesystem.

This command can be executed only using api_key belonging to user with admin

rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "rescan_repos"

    args :    {

                "remove_obsolete" : "<boolean = Optional(False)>"

              }

OUTPUT::

    id : <id_given_in_input>

    result : "{'added': [<list of names of added repos>],

               'removed': [<list of names of removed repos>]}"

    error :  null

invalidate_cache

----------------

Invalidate cache for repository.

This command can be executed only using api_key belonging to user with admin

rights or regular user that have write or admin or write access to repository.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "invalidate_cache"

    args :    {

                "repoid" : "<reponame or repo_id>"

              }

OUTPUT::

    id : <id_given_in_input>

    error :  null

lock

----

Set locking state on given repository by given user. If userid param is skipped

, then it is set to id of user whos calling this method. If locked param is skipped

then function shows current lock state of given repo.

This command can be executed only using api_key belonging to user with admin

rights or regular user that have admin or write access to repository.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "lock"

    args :    {

                "repoid" : "<reponame or repo_id>"

                "userid" : "<user_id or username = Optional(=apiuser)>",

                "locked" : "<bool true|false = Optional(=None)>"

              }

OUTPUT::

    id : <id_given_in_input>

    result : "User `<username>` set lock state for repo `<reponame>` to `true|false`"

    error :  null

show_ip

-------

Shows IP address as seen from RhodeCode server, together with all

defined IP addresses for given user.

This command can be executed only using api_key belonging to user with admin

rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "show_ip"

    args :    {

                "userid" : "<user_id or username>",

              }

OUTPUT::

        try:

            ScmModel().pull_changes(repo.repo_name,

                                    self.rhodecode_user.username)

            return 'Pulled from `%s`' % repo.repo_name

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'Unable to pull changes from `%s`' % repo.repo_name

            )

    @HasPermissionAllDecorator('hg.admin')

    def rescan_repos(self, apiuser, remove_obsolete=Optional(False)):

        """

        Dispatch rescan repositories action. If remove_obsolete is set

        than also delete repos that are in database but not in the filesystem.

        aka "clean zombies"

        :param apiuser:

        :param remove_obsolete:

        """

        try:

            rm_obsolete = Optional.extract(remove_obsolete)

            added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                            remove_obsolete=rm_obsolete)

            return {'added': added, 'removed': removed}

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'Error occurred during rescan repositories action'

            )

    def invalidate_cache(self, apiuser, repoid):

        """

        Dispatch cache invalidation action on given repo

        :param apiuser:

        :param repoid:

        """

        repo = get_repo_or_error(repoid)

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            # check if we have admin permission for this repo !

            if HasRepoPermissionAnyApi('repository.admin',

                                       'repository.write')(user=apiuser,

                                            repo_name=repo.repo_name) is False:

                raise JSONRPCError('repository `%s` does not exist' % (repoid))

        try:

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'Error occurred during cache invalidation action'

            )

    def lock(self, apiuser, repoid, locked=Optional(None),

             userid=Optional(OAttr('apiuser'))):

        """

        Set locking state on particular repository by given user, if

        this command is runned by non-admin account userid is set to user

        who is calling this method

        :param apiuser:

        :param repoid:

        :param userid:

        :param locked:

        """

        repo = get_repo_or_error(repoid)

        if HasPermissionAnyApi('hg.admin')(user=apiuser):

            pass

        elif HasRepoPermissionAnyApi('repository.admin',

                                     'repository.write')(user=apiuser,

                                                         repo_name=repo.repo_name):

            #make sure normal user does not pass someone else userid,

            #he is not allowed to do that

            if not isinstance(userid, Optional) and userid != apiuser.user_id:

                raise JSONRPCError(

                    'userid is not the same as your user'

                )

        else:

            raise JSONRPCError('repository `%s` does not exist' % (repoid))

        if isinstance(userid, Optional):

            userid = apiuser.user_id

        user = get_user_or_error(userid)

        if isinstance(locked, Optional):

            lockobj = Repository.getlock(repo)

            if lockobj[0] is None:

                return ('Repo `%s` not locked. Locked=`False`.'

                        % (repo.repo_name))

            else:

                userid, time_ = lockobj

                user = get_user_or_error(userid)

        Should only be run when all instances are down and all entries thus stale.

        """

        cls.query().delete()

        Session().commit()

    @classmethod

    def _get_cache_key(cls, key):

        """

        Wrapper for generating a unique cache key for this instance and "key".

        key must / will start with a repo_name which will be stored in .cache_args .

        """

        import rhodecode

        prefix = rhodecode.CONFIG.get('instance_id', '')

        return "%s%s" % (prefix, key)

    @classmethod

    def invalidate(cls, key):

        """

        Returns Invalidation object if the local cache with the given key is invalid,

        None otherwise.

        """

        repo_name = key

        repo_name = remove_suffix(repo_name, '_README')

        repo_name = remove_suffix(repo_name, '_RSS')

        repo_name = remove_suffix(repo_name, '_ATOM')

        cache_key = cls._get_cache_key(key)

        inv_obj = Session().query(cls).filter(cls.cache_key == cache_key).scalar()

        if not inv_obj:

            try:

                inv_obj = CacheInvalidation(cache_key, repo_name)

                Session().add(inv_obj)

                Session().commit()

            except Exception:

                log.error(traceback.format_exc())

                Session().rollback()

                return

        if not inv_obj.cache_active:

            # `cache_active = False` means that this cache

            # no longer is valid

            return inv_obj

    @classmethod

    def set_invalidate(cls, repo_name):

        """

        Mark all caches of a repo as invalid in the database.

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        try:

            for inv_obj in inv_objs:

                log.debug('marking %s key for invalidation based on repo_name=%s'

                          % (inv_obj, safe_str(repo_name)))

                inv_obj.cache_active = False

                Session().add(inv_obj)

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            Session().rollback()

    @classmethod

    def set_valid(cls, cache_key):

        """

        Mark this cache key as active and currently cached

        """

        inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

        inv_obj.cache_active = True

        Session().add(inv_obj)

        Session().commit()

    @classmethod

    def get_cache_map(cls):

        class cachemapdict(dict):

            def __init__(self, *args, **kwargs):

                self.fixkey = kwargs.pop('fixkey', False)

                super(cachemapdict, self).__init__(*args, **kwargs)

            def __getattr__(self, name):

                cache_key = name

                if self.fixkey:

                    cache_key = cls._get_cache_key(name)

                if cache_key in self.__dict__:

                    return self.__dict__[cache_key]

                else:

                    return self[cache_key]

            def __getitem__(self, name):

                cache_key = name

                if self.fixkey:

                    cache_key = cls._get_cache_key(name)

                try:

                    return super(cachemapdict, self).__getitem__(cache_key)

                except KeyError:

                    return None

        cache_map = cachemapdict(fixkey=True)

        for obj in cls.query().all():

            cache_map[obj.cache_key] = cachemapdict(obj.get_dict())

        return cache_map

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        Index('cc_revision_idx', 'revision'),

                    if path[0] == 'hg' and path[0] in BACKENDS.keys():

                        repos[name] = klass(safe_str(path[1]), baseui=baseui)

                    if path[0] == 'git' and path[0] in BACKENDS.keys():

                        repos[name] = klass(path[1])

            except OSError:

                continue

        log.debug('found %s paths with repositories' % (len(repos)))

        return repos

    def get_repos(self, all_repos=None, sort_key=None, simple=False):

        """

        Get all repos from db and for each repo create it's

        backend instance and fill that backed with information from database

        :param all_repos: list of repository names as strings

            give specific repositories list, good for filtering

        :param sort_key: initial sorting of repos

        :param simple: use SimpleCachedList - one without the SCM info

        """

        if all_repos is None:

            all_repos = self.sa.query(Repository)\

                        .filter(Repository.group_id == None)\

                        .order_by(func.lower(Repository.repo_name)).all()

        if simple:

            repo_iter = SimpleCachedRepoList(all_repos,

                                             repos_path=self.repos_path,

                                             order_by=sort_key)

        else:

            repo_iter = CachedRepoList(all_repos,

                                       repos_path=self.repos_path,

                                       order_by=sort_key)

        return repo_iter

    def get_repos_groups(self, all_groups=None):

        if all_groups is None:

            all_groups = RepoGroup.query()\

                .filter(RepoGroup.group_parent_id == None).all()

        return [x for x in RepoGroupList(all_groups)]

    def mark_for_invalidation(self, repo_name):

        """

        Mark caches of this repo invalid in the database.

        :param repo_name: the repo for which caches should be marked invalid

        """

        repo = Repository.get_by_repo_name(repo_name)

        if repo:

            repo.update_changeset_cache()

    def toggle_following_repo(self, follow_repo_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repo_id == follow_repo_id)\

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

        if f is not None:

            try:

                self.sa.delete(f)

                action_logger(UserTemp(user_id),

                              'stopped_following_repo',

                              RepoTemp(follow_repo_id))

                return

            except Exception:

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

        except Exception:

            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

            except Exception:

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_user_id = follow_user_id

    def test_api_pull(self):

        #TODO: issues with rhodecode_extras here.. not sure why !

        pass

#        repo_name = 'test_pull'

#        r = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

#        r.clone_uri = TEST_self.REPO

#        Session.add(r)

#        Session.commit()

#

#        id_, params = _build_data(self.apikey, 'pull',

#                                  repoid=repo_name,)

#        response = self.app.post(API_URL, content_type='application/json',

#                                 params=params)

#

#        expected = 'Pulled from `%s`' % repo_name

#        self._compare_ok(id_, expected, given=response.body)

#

#        fixture.destroy_repo(repo_name)

    def test_api_pull_error(self):

        id_, params = _build_data(self.apikey, 'pull',

                                  repoid=self.REPO,)

        response = api_call(self, params)

        expected = 'Unable to pull changes from `%s`' % self.REPO

        self._compare_error(id_, expected, given=response.body)

    def test_api_rescan_repos(self):

        id_, params = _build_data(self.apikey, 'rescan_repos')

        response = api_call(self, params)

        expected = {'added': [], 'removed': []}

        self._compare_ok(id_, expected, given=response.body)

    @mock.patch.object(ScmModel, 'repo_scan', crash)

    def test_api_rescann_error(self):

        id_, params = _build_data(self.apikey, 'rescan_repos',)

        response = api_call(self, params)

        expected = 'Error occurred during rescan repositories action'

        self._compare_error(id_, expected, given=response.body)

    def test_api_invalidate_cache(self):

        id_, params = _build_data(self.apikey, 'invalidate_cache',

                                  repoid=self.REPO)

        response = api_call(self, params)

        self._compare_ok(id_, expected, given=response.body)

    @mock.patch.object(ScmModel, 'mark_for_invalidation', crash)

    def test_api_invalidate_cache_error(self):

        id_, params = _build_data(self.apikey, 'invalidate_cache',

                                  repoid=self.REPO)

        response = api_call(self, params)

        expected = 'Error occurred during cache invalidation action'

        self._compare_error(id_, expected, given=response.body)

    def test_api_lock_repo_lock_aquire(self):

        id_, params = _build_data(self.apikey, 'lock',

                                  userid=TEST_USER_ADMIN_LOGIN,

                                  repoid=self.REPO,

                                  locked=True)

        response = api_call(self, params)

        expected = ('User `%s` set lock state for repo `%s` to `%s`'

                   % (TEST_USER_ADMIN_LOGIN, self.REPO, True))

        self._compare_ok(id_, expected, given=response.body)

    def test_api_lock_repo_lock_aquire_by_non_admin(self):

        repo_name = 'api_delete_me'

        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

                            cur_user=self.TEST_USER_LOGIN)

        try:

            id_, params = _build_data(self.apikey_regular, 'lock',

                                      repoid=repo_name,

                                      locked=True)

            response = api_call(self, params)

            expected = ('User `%s` set lock state for repo `%s` to `%s`'

                       % (self.TEST_USER_LOGIN, repo_name, True))

            self._compare_ok(id_, expected, given=response.body)

        finally:

            fixture.destroy_repo(repo_name)

    def test_api_lock_repo_lock_aquire_non_admin_with_userid(self):

        repo_name = 'api_delete_me'

        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,

                            cur_user=self.TEST_USER_LOGIN)

        try:

            id_, params = _build_data(self.apikey_regular, 'lock',

                                      userid=TEST_USER_ADMIN_LOGIN,

                                      repoid=repo_name,

                                      locked=True)

            response = api_call(self, params)

            expected = 'userid is not the same as your user'

            self._compare_error(id_, expected, given=response.body)