Handle that the repository has changed.

        Adds an action log entry with the new revisions, and the head revision

        cache and in-memory caches are invalidated/updated.

        :param username: username who pushes

        :param action: push/push_local/push_remote

        :param repo_name: name of repo

        :param revisions: list of revisions that we pushed

        """

        set_hook_environment(username, ip_addr, repo_name, repo_alias=repo.alias, action=action)

        process_pushed_raw_ids(revisions) # also calls mark_for_invalidation

    def pull_changes(self, repo, username, ip_addr, clone_uri=None):

        """

        Pull from "clone URL" or fork origin.

        """

        dbrepo = self.__get_repo(repo)

        if clone_uri is None:

            clone_uri = dbrepo.clone_uri or dbrepo.fork and dbrepo.fork.repo_full_path

        if not clone_uri:

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        repo_name = dbrepo.repo_name

        except Exception:

            log.error(traceback.format_exc())

            raise

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

                      content, f_path):

        """

        Commit a change to a single file

        :param repo: a db_repo.scm_instance

        """

        user = db.User.guess_instance(user)

        imc.change(FileNode(f_path, content, mode=cs.get_file_mode(f_path)))

        try:

            tip = imc.commit(message=message, author=author,

                             parents=[cs], branch=cs.branch)

        except Exception as e:

            log.error(traceback.format_exc())

            # clear caches - we also want a fresh object if commit fails

            self.mark_for_invalidation(repo_name)

            raise IMCCommitError(str(e))

        self._handle_push(repo,

                          username=user.username,

                          ip_addr=ip_addr,

        for f_path in nodes:

            content = nodes[f_path]['content']

            f_path = self._sanitize_path(f_path)

            if not isinstance(content, str) and not isinstance(content, bytes):

                content = content.read()

            processed_nodes.append((f_path, content))

        message = message

        committer = user.full_contact

        if not author:

            author = committer

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

            imc.add(FileNode(path, content=content))

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,

                     author=None, trigger_push_hook=True):

        """

        Commits specified nodes to repo. Again.

        """

        user = db.User.guess_instance(user)

        scm_instance = repo.scm_instance_no_cache()

        message = message

        committer = user.full_contact

        if not author:

            author = committer

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for _filename, data in nodes.items():

            # new filename, can be renamed from the old one

            filename = self._sanitize_path(data['filename'])

            old_filename = self._sanitize_path(_filename)

            content = data['content']

            filenode = FileNode(old_filename, content=content)

            op = data['op']

            if op == 'add':

                imc.add(filenode)

            elif op == 'del':

                imc.remove(filenode)

        for f_path in nodes:

            f_path = self._sanitize_path(f_path)

            # content can be empty but for compatibility it allows same dicts

            # structure as add_nodes

            content = nodes[f_path].get('content')

            processed_nodes.append((f_path, content))

        message = message

        committer = user.full_contact

        if not author:

            author = committer

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        if isinstance(parent_cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [parent_cs]

        # add multiple nodes

        for path, content in processed_nodes:

            imc.remove(FileNode(path, content=content))

        tip = imc.commit(message=message,

                         author=author,

                         parents=parents,

                         branch=parent_cs.branch)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              ip_addr=ip_addr,