Add the specified COMMIT to this replica's list of received
        commit requests.

        :param commit: the COMMIT to add to the list
        :param sender: the name of the node that sent the COMMIT
435059
def addToCommits(self, commit: Commit, sender: str):
        
        # BLS multi-sig:
        self._bls_bft_replica.process_commit(commit, sender)

        self.commits.addVote(commit, sender)
        self.tryOrder(commit)
791448
def commit(self, commit):
        '''
        
        '''

        c = self.commit
        if c:
            if not commit:
                commit = c[0]
            if commit in c:
                self._checkout(treeish=commit)
1284702
def _commitData(self, commit):
		
		return {
			"hexsha": commit.hexsha,
			"adate": commit.authored_date,
			"cdate": commit.committed_date,
			"author": "%s <%s>" % (commit.author.name, commit.author.email),
			"message": commit.message
		}
912300
def git_commit(self, sha):
        
        json = {}
        if sha:
            url = self._build_url('git', 'commits', sha, base_url=self._api)
            json = self._json(self._get(url), 200)
        return Commit(json, self) if json else None
1331764
def commit(self, sha):
        
        url = self._build_url('commits', sha, base_url=self._api)
        json = self._json(self._get(url), 200)
        return RepoCommit(json, self) if json else None
633149
def commit(cls):
        
        cls.objects.deleted().true_delete()
        cls.objects.changed().true_update(_new=False, _changed=False)
1265073
def _commit(self, ref):
        ''
        path_times = self._weakref_path_map[ref]
        path_times.append(nanotime())
        del self._weakref_path_map[ref]
        path = tuple(path_times[1::2])
        times = path_times[::2]
        if path not in self.path_stats:
            # tuple to save a tiny bit of memory
            self.path_stats[path] = tuple([
                Duration(interval=False) for i in range(len(path))])
        path_stats = self.path_stats[path]
        for i in range(1, len(times)):
            path_stats[i - 1]._stats.add(times[i] - times[i - 1])
1154330
def commit(self, index_update=True, label_guesser_update=True):
        
        logger.info("Index: Commiting changes")
        self.docsearch.index.commit(index_update=index_update,
                                    label_guesser_update=label_guesser_update)
320509
def commit(self):
        
        logger.debug('Committing job {0}'.format(self.name))
        self.backend.commit_job(self._serialize())
        self.parent.commit()
843388
def add_propagate(self, req: Request, sender: str):
        
        data = self.add(req)
        data.propagates[sender] = req
1022700
def _add_and_commit(self, doc_filepath, author, commit_msg):
        """"""
        try:
            git(self.gitdir, self.gitwd, "add", doc_filepath)
            git(self.gitdir, self.gitwd, "commit", author=author, message=commit_msg)
        except Exception as e:
            # We can ignore this if no changes are new,
            # otherwise raise a 400
            if "nothing to commit" in e.message:  # @EJM is this dangerous?
                _LOG.debug('"nothing to commit" found in error response')
            else:
                _LOG.exception('"git commit" failed')
                self.reset_hard()
                raise
115653
def commit(self) -> None:
        
        now = datetime.now(timezone.utc)
        if self.first_commit_at is None:
            self.first_commit_at = now

        if self.mode == "r":
            response = self.engine.session.transaction_read(self._request)
        elif self.mode == "w":
            if now - self.first_commit_at > MAX_TOKEN_LIFETIME:
                raise TransactionTokenExpired
            response = self.engine.session.transaction_write(self._request, self.tx_id)
        else:
            raise ValueError(f"unrecognized mode {self.mode}")

        self._handle_response(response)
285764
def commit(self):
        
        with self.native(writeAccess=True) as conn:
            if not self._closed(conn):
                return self._commit(conn)
1192988
def commit
      begin
        @repo.commit("Update features with Gitnesse")
      rescue Git::GitExecuteError => e
        unless e.message =~ /nothing to commit/
          puts "  A Git error occured. The message it passed to us was:"
          abort e.message
        end
      end
    end
1109771
def commit(self):
        '''
        
        '''
        providen, provstack = get()
        wasnew = (providen is None)
        if wasnew:
            providen = self.getProvIden(provstack)
            setiden(providen)
        return wasnew, s_common.ehex(providen), provstack
75857
def get_git_commit(self, sha):
        
        assert isinstance(sha, (str, unicode)), sha
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/git/commits/" + sha
        )
        return github.GitCommit.GitCommit(self._requester, headers, data, completed=True)
1262722
def add_write(key, value, binary = false)
      if (@is_commit)
        raise RuntimeError.new('No further request supported after a commit!')
      end
      @requests << {'write' => {key => JSONConnection.encode_value(value, binary)}}
      self
    end