_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q174600 | WaitPeerListening | validation | func WaitPeerListening(network, address string, timeout time.Duration) bool {
return WaitFunc(100*time.Millisecond, timeout, func() bool {
c, err := net.Dial(network, address)
if err == nil {
c.Close()
return true
}
return false
})
} | go | {
"resource": ""
} |
q174601 | NewEvent | validation | func NewEvent(name string, body interface{}) Event {
return Event{
name: name,
body: body,
occuredTime: time.Now(),
}
} | go | {
"resource": ""
} |
q174602 | Subscribe | validation | func (b *Bus) Subscribe(h Handler) bool {
b.mu.Lock()
defer b.mu.Unlock()
for _, v := range b.handlers {
if v == h {
return false
}
}
b.handlers = append(b.handlers, h)
return true
} | go | {
"resource": ""
} |
q174603 | Unsubscribe | validation | func (b *Bus) Unsubscribe(h Handler) bool {
b.mu.Lock()
defer b.mu.Unlock()
for i, v := range b.handlers {
if v == h {
b.handlers = append(b.handlers[:i], b.handlers[i+1:]...)
return true
}
}
return false
} | go | {
"resource": ""
} |
q174604 | Publish | validation | func (b *Bus) Publish(eventName string, eventBody interface{}) {
e := NewEvent(eventName, eventBody)
b.mu.RLock()
defer b.mu.RUnlock()
for _, h := range b.handlers {
h.Handle(e)
}
} | go | {
"resource": ""
} |
q174605 | HandleOnly | validation | func HandleOnly(h Handler, names ...string) Handler {
return HandlerFunc(func(e Event) {
for _, name := range names {
if e.Name() == name {
h.Handle(e)
break
}
}
})
} | go | {
"resource": ""
} |
q174606 | ContextWithPublisher | validation | func ContextWithPublisher(ctx context.Context, pub Publisher) context.Context {
return context.WithValue(ctx, KeyPublisher, pub)
} | go | {
"resource": ""
} |
q174607 | PublisherContext | validation | func PublisherContext(ctx context.Context) Publisher {
pub, ok := ctx.Value(KeyPublisher).(Publisher)
if !ok {
return nil
}
return pub
} | go | {
"resource": ""
} |
q174608 | PublishNamedEvent | validation | func PublishNamedEvent(pub Publisher, eventBody interface{}) {
name := reflect.TypeOf(eventBody).Name()
pub.Publish(name, eventBody)
} | go | {
"resource": ""
} |
q174609 | PublishEventContext | validation | func PublishEventContext(ctx context.Context, eventName string, eventBody interface{}) {
pub := PublisherContext(ctx)
if pub == nil {
return
}
pub.Publish(eventName, eventBody)
} | go | {
"resource": ""
} |
q174610 | PublishNamedEventContext | validation | func PublishNamedEventContext(ctx context.Context, eventBody interface{}) {
name := reflect.TypeOf(eventBody).Name()
PublishEventContext(ctx, name, eventBody)
} | go | {
"resource": ""
} |
q174611 | String | validation | func (level Level) String() string {
switch level {
case EMERGENCY:
return "EMERGENCY"
case ALERT:
return "ALERT"
case CRITICAL:
return "CRITICAL"
case ERROR:
return "ERROR"
case WARNING:
return "WARNING"
case NOTICE:
return "NOTICE"
case INFO:
return "INFO"
default:
return "DEBUG"
}
} | go | {
"resource": ""
} |
q174612 | UnmarshalJSON | validation | func (level *Level) UnmarshalJSON(data []byte) error {
switch string(bytes.ToUpper(data)) {
case `"EMERGENCY"`, "0":
*level = EMERGENCY
case `"ALERT"`, "1":
*level = ALERT
case `"CRITICAL"`, "2":
*level = CRITICAL
case `"ERROR"`, "3":
*level = ERROR
case `"WARNING"`, "4":
*level = WARNING
case `"NOTICE... | go | {
"resource": ""
} |
q174613 | NewSTM | test | func NewSTM(c *v3.Client, apply func(STM) error, so ...stmOption) (*v3.TxnResponse, error) {
opts := &stmOptions{ctx: c.Ctx()}
for _, f := range so {
f(opts)
}
if len(opts.prefetch) != 0 {
f := apply
apply = func(s STM) error {
s.Get(opts.prefetch...)
return f(s)
}
}
return runSTM(mkSTM(c, opts), ap... | go | {
"resource": ""
} |
q174614 | first | test | func (rs readSet) first() int64 {
ret := int64(math.MaxInt64 - 1)
for _, resp := range rs {
if rev := resp.Header.Revision; rev < ret {
ret = rev
}
}
return ret
} | go | {
"resource": ""
} |
q174615 | cmps | test | func (ws writeSet) cmps(rev int64) []v3.Cmp {
cmps := make([]v3.Cmp, 0, len(ws))
for key := range ws {
cmps = append(cmps, v3.Compare(v3.ModRevision(key), "<", rev))
}
return cmps
} | go | {
"resource": ""
} |
q174616 | NewSTMRepeatable | test | func NewSTMRepeatable(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
return NewSTM(c, apply, WithAbortContext(ctx), WithIsolation(RepeatableReads))
} | go | {
"resource": ""
} |
q174617 | NewSTMSerializable | test | func NewSTMSerializable(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
return NewSTM(c, apply, WithAbortContext(ctx), WithIsolation(Serializable))
} | go | {
"resource": ""
} |
q174618 | NewSTMReadCommitted | test | func NewSTMReadCommitted(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
return NewSTM(c, apply, WithAbortContext(ctx), WithIsolation(ReadCommitted))
} | go | {
"resource": ""
} |
q174619 | NewCertPool | test | func NewCertPool(CAFiles []string) (*x509.CertPool, error) {
certPool := x509.NewCertPool()
for _, CAFile := range CAFiles {
pemByte, err := ioutil.ReadFile(CAFile)
if err != nil {
return nil, err
}
for {
var block *pem.Block
block, pemByte = pem.Decode(pemByte)
if block == nil {
break
}
... | go | {
"resource": ""
} |
q174620 | NewCert | test | func NewCert(certfile, keyfile string, parseFunc func([]byte, []byte) (tls.Certificate, error)) (*tls.Certificate, error) {
cert, err := ioutil.ReadFile(certfile)
if err != nil {
return nil, err
}
key, err := ioutil.ReadFile(keyfile)
if err != nil {
return nil, err
}
if parseFunc == nil {
parseFunc = tls... | go | {
"resource": ""
} |
q174621 | Pause | test | func (p *peer) Pause() {
p.mu.Lock()
defer p.mu.Unlock()
p.paused = true
p.msgAppReader.pause()
p.msgAppV2Reader.pause()
} | go | {
"resource": ""
} |
q174622 | Resume | test | func (p *peer) Resume() {
p.mu.Lock()
defer p.mu.Unlock()
p.paused = false
p.msgAppReader.resume()
p.msgAppV2Reader.resume()
} | go | {
"resource": ""
} |
q174623 | pick | test | func (p *peer) pick(m raftpb.Message) (writec chan<- raftpb.Message, picked string) {
var ok bool
// Considering MsgSnap may have a big size, e.g., 1G, and will block
// stream for a long time, only use one of the N pipelines to send MsgSnap.
if isMsgSnap(m) {
return p.pipeline.msgc, pipelineMsg
} else if writec... | go | {
"resource": ""
} |
q174624 | post | test | func (s *snapshotSender) post(req *http.Request) (err error) {
ctx, cancel := context.WithCancel(context.Background())
req = req.WithContext(ctx)
defer cancel()
type responseAndError struct {
resp *http.Response
body []byte
err error
}
result := make(chan responseAndError, 1)
go func() {
resp, err := ... | go | {
"resource": ""
} |
q174625 | newTxnResp | test | func newTxnResp(rt *pb.TxnRequest, txnPath []bool) (txnResp *pb.TxnResponse, txnCount int) {
reqs := rt.Success
if !txnPath[0] {
reqs = rt.Failure
}
resps := make([]*pb.ResponseOp, len(reqs))
txnResp = &pb.TxnResponse{
Responses: resps,
Succeeded: txnPath[0],
Header: &pb.ResponseHeader{},
}
for i, req... | go | {
"resource": ""
} |
q174626 | applyCompare | test | func applyCompare(rv mvcc.ReadView, c *pb.Compare) bool {
// TODO: possible optimizations
// * chunk reads for large ranges to conserve memory
// * rewrite rules for common patterns:
// ex. "[a, b) createrev > 0" => "limit 1 /\ kvs > 0"
// * caching
rr, err := rv.Range(c.Key, mkGteRange(c.RangeEnd), mvcc.RangeOpt... | go | {
"resource": ""
} |
q174627 | OpCompact | test | func OpCompact(rev int64, opts ...CompactOption) CompactOp {
ret := CompactOp{revision: rev}
ret.applyCompactOpts(opts)
return ret
} | go | {
"resource": ""
} |
q174628 | NewPriorityQueue | test | func NewPriorityQueue(client *v3.Client, key string) *PriorityQueue {
return &PriorityQueue{client, context.TODO(), key + "/"}
} | go | {
"resource": ""
} |
q174629 | Enqueue | test | func (q *PriorityQueue) Enqueue(val string, pr uint16) error {
prefix := fmt.Sprintf("%s%05d", q.key, pr)
_, err := newSequentialKV(q.client, prefix, val)
return err
} | go | {
"resource": ""
} |
q174630 | NewLeaderStats | test | func NewLeaderStats(id string) *LeaderStats {
return &LeaderStats{
leaderStats: leaderStats{
Leader: id,
Followers: make(map[string]*FollowerStats),
},
}
} | go | {
"resource": ""
} |
q174631 | Succ | test | func (fs *FollowerStats) Succ(d time.Duration) {
fs.Lock()
defer fs.Unlock()
total := float64(fs.Counts.Success) * fs.Latency.Average
totalSquare := float64(fs.Counts.Success) * fs.Latency.averageSquare
fs.Counts.Success++
fs.Latency.Current = float64(d) / (1000000.0)
if fs.Latency.Current > fs.Latency.Maxim... | go | {
"resource": ""
} |
q174632 | Fail | test | func (fs *FollowerStats) Fail() {
fs.Lock()
defer fs.Unlock()
fs.Counts.Fail++
} | go | {
"resource": ""
} |
q174633 | delete | test | func (wbs *watchBroadcasts) delete(w *watcher) int {
wbs.mu.Lock()
defer wbs.mu.Unlock()
wb, ok := wbs.watchers[w]
if !ok {
panic("deleting missing watcher from broadcasts")
}
delete(wbs.watchers, w)
wb.delete(w)
if wb.empty() {
delete(wbs.bcasts, wb)
wb.stop()
}
return len(wbs.bcasts)
} | go | {
"resource": ""
} |
q174634 | startStreamWriter | test | func startStreamWriter(lg *zap.Logger, local, id types.ID, status *peerStatus, fs *stats.FollowerStats, r Raft) *streamWriter {
w := &streamWriter{
lg: lg,
localID: local,
peerID: id,
status: status,
fs: fs,
r: r,
msgc: make(chan raftpb.Message, streamBufSize),
connc: make(chan *outgoing... | go | {
"resource": ""
} |
q174635 | checkStreamSupport | test | func checkStreamSupport(v *semver.Version, t streamType) bool {
nv := &semver.Version{Major: v.Major, Minor: v.Minor}
for _, s := range supportedStream[nv.String()] {
if s == t {
return true
}
}
return false
} | go | {
"resource": ""
} |
q174636 | maybeUpdate | test | func (pr *Progress) maybeUpdate(n uint64) bool {
var updated bool
if pr.Match < n {
pr.Match = n
updated = true
pr.resume()
}
if pr.Next < n+1 {
pr.Next = n + 1
}
return updated
} | go | {
"resource": ""
} |
q174637 | IsPaused | test | func (pr *Progress) IsPaused() bool {
switch pr.State {
case ProgressStateProbe:
return pr.Paused
case ProgressStateReplicate:
return pr.ins.full()
case ProgressStateSnapshot:
return true
default:
panic("unexpected state")
}
} | go | {
"resource": ""
} |
q174638 | needSnapshotAbort | test | func (pr *Progress) needSnapshotAbort() bool {
return pr.State == ProgressStateSnapshot && pr.Match >= pr.PendingSnapshot
} | go | {
"resource": ""
} |
q174639 | add | test | func (in *inflights) add(inflight uint64) {
if in.full() {
panic("cannot add into a full inflights")
}
next := in.start + in.count
size := in.size
if next >= size {
next -= size
}
if next >= len(in.buffer) {
in.growBuf()
}
in.buffer[next] = inflight
in.count++
} | go | {
"resource": ""
} |
q174640 | growBuf | test | func (in *inflights) growBuf() {
newSize := len(in.buffer) * 2
if newSize == 0 {
newSize = 1
} else if newSize > in.size {
newSize = in.size
}
newBuffer := make([]uint64, newSize)
copy(newBuffer, in.buffer)
in.buffer = newBuffer
} | go | {
"resource": ""
} |
q174641 | freeTo | test | func (in *inflights) freeTo(to uint64) {
if in.count == 0 || to < in.buffer[in.start] {
// out of the left side of the window
return
}
idx := in.start
var i int
for i = 0; i < in.count; i++ {
if to < in.buffer[idx] { // found the first large inflight
break
}
// increase index and maybe rotate
size... | go | {
"resource": ""
} |
q174642 | SaveDBFrom | test | func (s *Snapshotter) SaveDBFrom(r io.Reader, id uint64) (int64, error) {
start := time.Now()
f, err := ioutil.TempFile(s.dir, "tmp")
if err != nil {
return 0, err
}
var n int64
n, err = io.Copy(f, r)
if err == nil {
fsyncStart := time.Now()
err = fileutil.Fsync(f)
snapDBFsyncSec.Observe(time.Since(fsyn... | go | {
"resource": ""
} |
q174643 | DBFilePath | test | func (s *Snapshotter) DBFilePath(id uint64) (string, error) {
if _, err := fileutil.ReadDir(s.dir); err != nil {
return "", err
}
fn := s.dbFilePath(id)
if fileutil.Exist(fn) {
return fn, nil
}
if s.lg != nil {
s.lg.Warn(
"failed to find [SNAPSHOT-INDEX].snap.db",
zap.Uint64("snapshot-index", id),
... | go | {
"resource": ""
} |
q174644 | Set | test | func (us *UniqueStringsValue) Set(s string) error {
us.Values = make(map[string]struct{})
for _, v := range strings.Split(s, ",") {
us.Values[v] = struct{}{}
}
return nil
} | go | {
"resource": ""
} |
q174645 | NewUniqueStringsValue | test | func NewUniqueStringsValue(s string) (us *UniqueStringsValue) {
us = &UniqueStringsValue{Values: make(map[string]struct{})}
if s == "" {
return us
}
if err := us.Set(s); err != nil {
plog.Panicf("new UniqueStringsValue should never fail: %v", err)
}
return us
} | go | {
"resource": ""
} |
q174646 | UniqueStringsFromFlag | test | func UniqueStringsFromFlag(fs *flag.FlagSet, flagName string) []string {
return (*fs.Lookup(flagName).Value.(*UniqueStringsValue)).stringSlice()
} | go | {
"resource": ""
} |
q174647 | UniqueStringsMapFromFlag | test | func UniqueStringsMapFromFlag(fs *flag.FlagSet, flagName string) map[string]struct{} {
return (*fs.Lookup(flagName).Value.(*UniqueStringsValue)).Values
} | go | {
"resource": ""
} |
q174648 | Percentiles | test | func Percentiles(nums []float64) (pcs []float64, data []float64) {
return pctls, percentiles(nums)
} | go | {
"resource": ""
} |
q174649 | VerifyBootstrap | test | func (c *ServerConfig) VerifyBootstrap() error {
if err := c.hasLocalMember(); err != nil {
return err
}
if err := c.advertiseMatchesCluster(); err != nil {
return err
}
if checkDuplicateURL(c.InitialPeerURLsMap) {
return fmt.Errorf("initial cluster %s has duplicate url", c.InitialPeerURLsMap)
}
if c.Initi... | go | {
"resource": ""
} |
q174650 | VerifyJoinExisting | test | func (c *ServerConfig) VerifyJoinExisting() error {
// The member has announced its peer urls to the cluster before starting; no need to
// set the configuration again.
if err := c.hasLocalMember(); err != nil {
return err
}
if checkDuplicateURL(c.InitialPeerURLsMap) {
return fmt.Errorf("initial cluster %s has... | go | {
"resource": ""
} |
q174651 | hasLocalMember | test | func (c *ServerConfig) hasLocalMember() error {
if urls := c.InitialPeerURLsMap[c.Name]; urls == nil {
return fmt.Errorf("couldn't find local name %q in the initial cluster configuration", c.Name)
}
return nil
} | go | {
"resource": ""
} |
q174652 | advertiseMatchesCluster | test | func (c *ServerConfig) advertiseMatchesCluster() error {
urls, apurls := c.InitialPeerURLsMap[c.Name], c.PeerURLs.StringSlice()
urls.Sort()
sort.Strings(apurls)
ctx, cancel := context.WithTimeout(context.TODO(), 30*time.Second)
defer cancel()
ok, err := netutil.URLStringsEqual(ctx, c.Logger, apurls, urls.StringSl... | go | {
"resource": ""
} |
q174653 | ReqTimeout | test | func (c *ServerConfig) ReqTimeout() time.Duration {
// 5s for queue waiting, computation and disk IO delay
// + 2 * election timeout for possible leader election
return 5*time.Second + 2*time.Duration(c.ElectionTicks*int(c.TickMs))*time.Millisecond
} | go | {
"resource": ""
} |
q174654 | getStatus | test | func getStatus(r *raft) Status {
s := getStatusWithoutProgress(r)
if s.RaftState == StateLeader {
s.Progress = getProgressCopy(r)
}
return s
} | go | {
"resource": ""
} |
q174655 | GetDefaultHost | test | func GetDefaultHost() (string, error) {
rmsgs, rerr := getDefaultRoutes()
if rerr != nil {
return "", rerr
}
// prioritize IPv4
if rmsg, ok := rmsgs[syscall.AF_INET]; ok {
if host, err := chooseHost(syscall.AF_INET, rmsg); host != "" || err != nil {
return host, err
}
delete(rmsgs, syscall.AF_INET)
}
... | go | {
"resource": ""
} |
q174656 | getIfaceAddr | test | func getIfaceAddr(idx uint32, family uint8) (*syscall.NetlinkMessage, error) {
dat, err := syscall.NetlinkRIB(syscall.RTM_GETADDR, int(family))
if err != nil {
return nil, err
}
msgs, msgErr := syscall.ParseNetlinkMessage(dat)
if msgErr != nil {
return nil, msgErr
}
ifaddrmsg := syscall.IfAddrmsg{}
for _,... | go | {
"resource": ""
} |
q174657 | getIfaceLink | test | func getIfaceLink(idx uint32) (*syscall.NetlinkMessage, error) {
dat, err := syscall.NetlinkRIB(syscall.RTM_GETLINK, syscall.AF_UNSPEC)
if err != nil {
return nil, err
}
msgs, msgErr := syscall.ParseNetlinkMessage(dat)
if msgErr != nil {
return nil, msgErr
}
ifinfomsg := syscall.IfInfomsg{}
for _, m := ra... | go | {
"resource": ""
} |
q174658 | lsCommandFunc | test | func lsCommandFunc(c *cli.Context, ki client.KeysAPI) {
key := "/"
if len(c.Args()) != 0 {
key = c.Args()[0]
}
sort := c.Bool("sort")
recursive := c.Bool("recursive")
quorum := c.Bool("quorum")
ctx, cancel := contextWithTotalTimeout(c)
resp, err := ki.Get(ctx, key, &client.GetOptions{Sort: sort, Recursive: ... | go | {
"resource": ""
} |
q174659 | printLs | test | func printLs(c *cli.Context, resp *client.Response) {
if c.GlobalString("output") == "simple" {
if !resp.Node.Dir {
fmt.Println(resp.Node.Key)
}
for _, node := range resp.Node.Nodes {
rPrint(c, node)
}
} else {
// user wants JSON or extended output
printResponseKey(resp, c.GlobalString("output"))
}... | go | {
"resource": ""
} |
q174660 | rPrint | test | func rPrint(c *cli.Context, n *client.Node) {
if n.Dir && c.Bool("p") {
fmt.Println(fmt.Sprintf("%v/", n.Key))
} else {
fmt.Println(n.Key)
}
for _, node := range n.Nodes {
rPrint(c, node)
}
} | go | {
"resource": ""
} |
q174661 | NewLeaseRenewerCommand | test | func NewLeaseRenewerCommand() *cobra.Command {
cmd := &cobra.Command{
Use: "lease-renewer",
Short: "Performs lease renew operation",
Run: runLeaseRenewerFunc,
}
cmd.Flags().Int64Var(&leaseTTL, "ttl", 5, "lease's ttl")
return cmd
} | go | {
"resource": ""
} |
q174662 | Read | test | func Read(lg *zap.Logger, snapname string) (*raftpb.Snapshot, error) {
b, err := ioutil.ReadFile(snapname)
if err != nil {
if lg != nil {
lg.Warn("failed to read a snap file", zap.String("path", snapname), zap.Error(err))
} else {
plog.Errorf("cannot read file %v: %v", snapname, err)
}
return nil, err
... | go | {
"resource": ""
} |
q174663 | GetCipherSuite | test | func GetCipherSuite(s string) (uint16, bool) {
v, ok := cipherSuites[s]
return v, ok
} | go | {
"resource": ""
} |
q174664 | post | test | func (p *pipeline) post(data []byte) (err error) {
u := p.picker.pick()
req := createPostRequest(u, RaftPrefix, bytes.NewBuffer(data), "application/protobuf", p.tr.URLs, p.tr.ID, p.tr.ClusterID)
done := make(chan struct{}, 1)
ctx, cancel := context.WithCancel(context.Background())
req = req.WithContext(ctx)
go f... | go | {
"resource": ""
} |
q174665 | send | test | func (r *raft) send(m pb.Message) {
m.From = r.id
if m.Type == pb.MsgVote || m.Type == pb.MsgVoteResp || m.Type == pb.MsgPreVote || m.Type == pb.MsgPreVoteResp {
if m.Term == 0 {
// All {pre-,}campaign messages need to have the term set when
// sending.
// - MsgVote: m.Term is the term the node is campaign... | go | {
"resource": ""
} |
q174666 | sendHeartbeat | test | func (r *raft) sendHeartbeat(to uint64, ctx []byte) {
// Attach the commit as min(to.matched, r.committed).
// When the leader sends out heartbeat message,
// the receiver(follower) might not be matched with the leader
// or it might not have all the committed entries.
// The leader MUST NOT forward the follower's... | go | {
"resource": ""
} |
q174667 | bcastAppend | test | func (r *raft) bcastAppend() {
r.forEachProgress(func(id uint64, _ *Progress) {
if id == r.id {
return
}
r.sendAppend(id)
})
} | go | {
"resource": ""
} |
q174668 | bcastHeartbeat | test | func (r *raft) bcastHeartbeat() {
lastCtx := r.readOnly.lastPendingRequestCtx()
if len(lastCtx) == 0 {
r.bcastHeartbeatWithCtx(nil)
} else {
r.bcastHeartbeatWithCtx([]byte(lastCtx))
}
} | go | {
"resource": ""
} |
q174669 | tickElection | test | func (r *raft) tickElection() {
r.electionElapsed++
if r.promotable() && r.pastElectionTimeout() {
r.electionElapsed = 0
r.Step(pb.Message{From: r.id, Type: pb.MsgHup})
}
} | go | {
"resource": ""
} |
q174670 | tickHeartbeat | test | func (r *raft) tickHeartbeat() {
r.heartbeatElapsed++
r.electionElapsed++
if r.electionElapsed >= r.electionTimeout {
r.electionElapsed = 0
if r.checkQuorum {
r.Step(pb.Message{From: r.id, Type: pb.MsgCheckQuorum})
}
// If current leader cannot transfer leadership in electionTimeout, it becomes leader ag... | go | {
"resource": ""
} |
q174671 | stepCandidate | test | func stepCandidate(r *raft, m pb.Message) error {
// Only handle vote responses corresponding to our candidacy (while in
// StateCandidate, we may get stale MsgPreVoteResp messages in this term from
// our pre-candidate state).
var myVoteRespType pb.MessageType
if r.state == StatePreCandidate {
myVoteRespType = ... | go | {
"resource": ""
} |
q174672 | restore | test | func (r *raft) restore(s pb.Snapshot) bool {
if s.Metadata.Index <= r.raftLog.committed {
return false
}
if r.raftLog.matchTerm(s.Metadata.Index, s.Metadata.Term) {
r.logger.Infof("%x [commit: %d, lastindex: %d, lastterm: %d] fast-forwarded commit to snapshot [index: %d, term: %d]",
r.id, r.raftLog.committed,... | go | {
"resource": ""
} |
q174673 | promotable | test | func (r *raft) promotable() bool {
_, ok := r.prs[r.id]
return ok
} | go | {
"resource": ""
} |
q174674 | checkQuorumActive | test | func (r *raft) checkQuorumActive() bool {
var act int
r.forEachProgress(func(id uint64, pr *Progress) {
if id == r.id { // self is always active
act++
return
}
if pr.RecentActive && !pr.IsLearner {
act++
}
pr.RecentActive = false
})
return act >= r.quorum()
} | go | {
"resource": ""
} |
q174675 | increaseUncommittedSize | test | func (r *raft) increaseUncommittedSize(ents []pb.Entry) bool {
var s uint64
for _, e := range ents {
s += uint64(PayloadSize(e))
}
if r.uncommittedSize > 0 && r.uncommittedSize+s > r.maxUncommittedSize {
// If the uncommitted tail of the Raft log is empty, allow any size
// proposal. Otherwise, limit the siz... | go | {
"resource": ""
} |
q174676 | reduceUncommittedSize | test | func (r *raft) reduceUncommittedSize(ents []pb.Entry) {
if r.uncommittedSize == 0 {
// Fast-path for followers, who do not track or enforce the limit.
return
}
var s uint64
for _, e := range ents {
s += uint64(PayloadSize(e))
}
if s > r.uncommittedSize {
// uncommittedSize may underestimate the size of t... | go | {
"resource": ""
} |
q174677 | newPeriodic | test | func newPeriodic(lg *zap.Logger, clock clockwork.Clock, h time.Duration, rg RevGetter, c Compactable) *Periodic {
pc := &Periodic{
lg: lg,
clock: clock,
period: h,
rg: rg,
c: c,
revs: make([]int64, 0),
}
pc.ctx, pc.cancel = context.WithCancel(context.Background())
return pc
} | go | {
"resource": ""
} |
q174678 | Pause | test | func (pc *Periodic) Pause() {
pc.mu.Lock()
pc.paused = true
pc.mu.Unlock()
} | go | {
"resource": ""
} |
q174679 | Resume | test | func (pc *Periodic) Resume() {
pc.mu.Lock()
pc.paused = false
pc.mu.Unlock()
} | go | {
"resource": ""
} |
q174680 | Lock | test | func (m *Mutex) Lock(ctx context.Context) error {
s := m.s
client := m.s.Client()
m.myKey = fmt.Sprintf("%s%x", m.pfx, s.Lease())
cmp := v3.Compare(v3.CreateRevision(m.myKey), "=", 0)
// put self in lock waiters via myKey; oldest waiter holds lock
put := v3.OpPut(m.myKey, "", v3.WithLease(s.Lease()))
// reuse k... | go | {
"resource": ""
} |
q174681 | NewLocker | test | func NewLocker(s *Session, pfx string) sync.Locker {
return &lockerMutex{NewMutex(s, pfx)}
} | go | {
"resource": ""
} |
q174682 | NewFIFOScheduler | test | func NewFIFOScheduler() Scheduler {
f := &fifo{
resume: make(chan struct{}, 1),
donec: make(chan struct{}, 1),
}
f.finishCond = sync.NewCond(&f.mu)
f.ctx, f.cancel = context.WithCancel(context.Background())
go f.run()
return f
} | go | {
"resource": ""
} |
q174683 | Schedule | test | func (f *fifo) Schedule(j Job) {
f.mu.Lock()
defer f.mu.Unlock()
if f.cancel == nil {
panic("schedule: schedule to stopped scheduler")
}
if len(f.pendings) == 0 {
select {
case f.resume <- struct{}{}:
default:
}
}
f.pendings = append(f.pendings, j)
} | go | {
"resource": ""
} |
q174684 | Stop | test | func (f *fifo) Stop() {
f.mu.Lock()
f.cancel()
f.cancel = nil
f.mu.Unlock()
<-f.donec
} | go | {
"resource": ""
} |
q174685 | NewServer | test | func NewServer(
lg *zap.Logger,
network string,
address string,
) *Server {
return &Server{
lg: lg,
network: network,
address: address,
last: rpcpb.Operation_NOT_STARTED,
advertiseClientPortToProxy: make(map[int]proxy.Serv... | go | {
"resource": ""
} |
q174686 | StartServe | test | func (srv *Server) StartServe() error {
var err error
srv.ln, err = net.Listen(srv.network, srv.address)
if err != nil {
return err
}
var opts []grpc.ServerOption
opts = append(opts, grpc.MaxRecvMsgSize(int(maxRequestBytes+grpcOverheadBytes)))
opts = append(opts, grpc.MaxSendMsgSize(maxSendBytes))
opts = app... | go | {
"resource": ""
} |
q174687 | Stop | test | func (srv *Server) Stop() {
srv.lg.Info("gRPC server stopping", zap.String("address", srv.address))
srv.grpcServer.Stop()
srv.lg.Info("gRPC server stopped", zap.String("address", srv.address))
} | go | {
"resource": ""
} |
q174688 | Transport | test | func (srv *Server) Transport(stream rpcpb.Transport_TransportServer) (err error) {
errc := make(chan error)
go func() {
for {
var req *rpcpb.Request
req, err = stream.Recv()
if err != nil {
errc <- err
// TODO: handle error and retry
return
}
if req.Member != nil {
srv.Member = req.Me... | go | {
"resource": ""
} |
q174689 | RegisterInterruptHandler | test | func RegisterInterruptHandler(h InterruptHandler) {
interruptRegisterMu.Lock()
defer interruptRegisterMu.Unlock()
interruptHandlers = append(interruptHandlers, h)
} | go | {
"resource": ""
} |
q174690 | HandleInterrupts | test | func HandleInterrupts(lg *zap.Logger) {
notifier := make(chan os.Signal, 1)
signal.Notify(notifier, syscall.SIGINT, syscall.SIGTERM)
go func() {
sig := <-notifier
interruptRegisterMu.Lock()
ihs := make([]InterruptHandler, len(interruptHandlers))
copy(ihs, interruptHandlers)
interruptRegisterMu.Unlock()
... | go | {
"resource": ""
} |
q174691 | OpGet | test | func OpGet(key string, opts ...OpOption) Op {
// WithPrefix and WithFromKey are not supported together
if isWithPrefix(opts) && isWithFromKey(opts) {
panic("`WithPrefix` and `WithFromKey` cannot be set at the same time, choose one")
}
ret := Op{t: tRange, key: []byte(key)}
ret.applyOpts(opts)
return ret
} | go | {
"resource": ""
} |
q174692 | OpDelete | test | func OpDelete(key string, opts ...OpOption) Op {
// WithPrefix and WithFromKey are not supported together
if isWithPrefix(opts) && isWithFromKey(opts) {
panic("`WithPrefix` and `WithFromKey` cannot be set at the same time, choose one")
}
ret := Op{t: tDeleteRange, key: []byte(key)}
ret.applyOpts(opts)
switch {
... | go | {
"resource": ""
} |
q174693 | OpPut | test | func OpPut(key, val string, opts ...OpOption) Op {
ret := Op{t: tPut, key: []byte(key), val: []byte(val)}
ret.applyOpts(opts)
switch {
case ret.end != nil:
panic("unexpected range in put")
case ret.limit != 0:
panic("unexpected limit in put")
case ret.rev != 0:
panic("unexpected revision in put")
case ret.... | go | {
"resource": ""
} |
q174694 | OpTxn | test | func OpTxn(cmps []Cmp, thenOps []Op, elseOps []Op) Op {
return Op{t: tTxn, cmps: cmps, thenOps: thenOps, elseOps: elseOps}
} | go | {
"resource": ""
} |
q174695 | WithFromKey | test | func WithFromKey() OpOption {
return func(op *Op) {
if len(op.key) == 0 {
op.key = []byte{0}
}
op.end = []byte("\x00")
}
} | go | {
"resource": ""
} |
q174696 | withTop | test | func withTop(target SortTarget, order SortOrder) []OpOption {
return []OpOption{WithPrefix(), WithSort(target, order), WithLimit(1)}
} | go | {
"resource": ""
} |
q174697 | Exist | test | func Exist(dir string) bool {
names, err := fileutil.ReadDir(dir, fileutil.WithExt(".wal"))
if err != nil {
return false
}
return len(names) != 0
} | go | {
"resource": ""
} |
q174698 | searchIndex | test | func searchIndex(lg *zap.Logger, names []string, index uint64) (int, bool) {
for i := len(names) - 1; i >= 0; i-- {
name := names[i]
_, curIndex, err := parseWALName(name)
if err != nil {
if lg != nil {
lg.Panic("failed to parse WAL file name", zap.String("path", name), zap.Error(err))
} else {
plo... | go | {
"resource": ""
} |
q174699 | isValidSeq | test | func isValidSeq(lg *zap.Logger, names []string) bool {
var lastSeq uint64
for _, name := range names {
curSeq, _, err := parseWALName(name)
if err != nil {
if lg != nil {
lg.Panic("failed to parse WAL file name", zap.String("path", name), zap.Error(err))
} else {
plog.Panicf("parse correct name shou... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.