id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c175100 |
ac.AddCommand(newUserChangePasswordCommand())
ac.AddCommand(newUserGrantRoleCommand())
ac.AddCommand(newUserRevokeRoleCommand())
return ac
} | |
c175101 | if len(splitted) < 2 {
user = args[0]
if !passwordInteractive {
fmt.Scanf("%s", &password)
} else {
password = readPasswordInteractive(args[0])
}
} else {
user = splitted[0]
password = splitted[1]
if len(user) == 0 {
ExitWithError(ExitBadArgs, fmt.Errorf("empty user name is not allowed"))
}
}
}
resp, err := mustClientFromCmd(cmd).Auth.UserAdd(context.TODO(), user, password)
if err != nil {
ExitWithError(ExitError, err)
}
display.UserAdd(user, *resp)
} | |
c175102 |
roleResp, err := client.Auth.RoleGet(context.TODO(), role)
if err != nil {
ExitWithError(ExitError, err)
}
display.RoleGet(role, *roleResp)
}
} else {
display.UserGet(name, *resp)
}
} | |
c175103 | readPasswordInteractive(args[0])
}
resp, err := mustClientFromCmd(cmd).Auth.UserChangePassword(context.TODO(), args[0], password)
if err != nil {
ExitWithError(ExitError, err)
}
display.UserChangePassword(*resp)
} | |
c175104 |
eh.StartIndex = eh.Queue.Events[eh.Queue.Front].Index()
return e
} | |
c175105 | nkey := path.Clean(key)
if nkey[len(nkey)-1] != '/' {
nkey = nkey + "/"
}
ok = ok || strings.HasPrefix(e.Node.Key, nkey)
}
if (e.Action == Delete || e.Action == Expire) && e.PrevNode != nil && e.PrevNode.Dir {
ok = ok || strings.HasPrefix(key, e.PrevNode.Key)
}
if ok {
return e, nil
}
}
i = (i + 1) % eh.Queue.Capacity
if i == eh.Queue.Back {
return nil, nil
}
}
} | |
c175106 | eh.Queue.Back,
}
copy(clonedQueue.Events, eh.Queue.Events)
return &EventHistory{
StartIndex: eh.StartIndex,
Queue: clonedQueue,
LastIndex: eh.LastIndex,
}
} | |
c175107 |
if err := os.Rename(snapPath, cfg.backendPath()); err != nil {
return nil, fmt.Errorf("failed to rename database snapshot file (%v)", err)
}
return openBackend(cfg), nil
} | |
c175108 | or taking too long",
zap.String("path", fn),
zap.Duration("took", time.Since(now)),
)
} else {
plog.Warningf("another etcd process is using %q and holds the file lock, or loading backend file is taking >10 seconds", fn)
plog.Warningf("waiting for it to exit before starting...")
}
}
return <-beOpened
} | |
c175109 | <= kv.ConsistentIndex() {
return oldbe, nil
}
oldbe.Close()
return openSnapshotBackend(cfg, snap.New(cfg.Logger, cfg.SnapDir()), snapshot)
} | |
c175110 | <value>",
Flags: []cli.Flag{
cli.IntFlag{Name: "ttl", Value: 0, Usage: "key time-to-live in seconds"},
},
Action: func(c *cli.Context) error {
updateCommandFunc(c, mustNewKeyAPI(c))
return nil
},
}
} | |
c175111 | err := ki.Set(ctx, key, value, &client.SetOptions{TTL: time.Duration(ttl) * time.Second, PrevExist: client.PrevExist})
cancel()
if err != nil {
handleError(c, ExitServerError, err)
}
printResponseKey(resp, c.GlobalString("output"))
} | |
c175112 |
return q.items[q.front], q.items[q.back]
}
return nil, nil
} | |
c175113 | queueCapacity { //dequeue
q.totalReqSize -= q.items[q.front].Size
q.front = (q.back + 1) % queueCapacity
} else {
q.size++
}
q.items[q.back] = p
q.totalReqSize += q.items[q.back].Size
} | |
c175114 | pr := float64(q.Len()) / float64(sampleDuration) * float64(time.Second)
br := float64(q.ReqSize()) / float64(sampleDuration) * float64(time.Second)
return pr, br
} | |
c175115 | q.rwl.Unlock()
q.back = -1
q.front = 0
q.size = 0
q.totalReqSize = 0
} | |
c175116 | := exist[s]; !ok {
ss = append(ss, s)
exist[s] = struct{}{}
}
}
return ss
} | |
c175117 | n; i++ {
ss = append(ss, randString(slen))
}
return ss
} | |
c175118 | err.(Error); ok {
return cErr.Code == ErrorCodeKeyNotFound
}
return false
} | |
c175119 | return roleNotFoundRegExp.MatchString(ae.Message)
}
return false
} | |
c175120 | return userNotFoundRegExp.MatchString(ae.Message)
}
return false
} | |
c175121 | id)
if err != nil {
return "", err
}
return d.joinCluster(config)
} | |
c175122 | if err != nil {
return "", err
}
return d.getCluster()
} | |
c175123 | it and
// see if that parses correctly. If not, we ignore the
// error and complain about the original one
var err2 error
proxyURL, err2 = url.Parse("http://" + proxy)
if err2 == nil {
err = nil
}
}
if err != nil {
return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err)
}
if lg != nil {
lg.Info("running proxy with discovery", zap.String("proxy-url", proxyURL.String()))
} else {
plog.Infof("using proxy %q", proxyURL.String())
}
return http.ProxyURL(proxyURL), nil
} | |
c175124 | return isSafeRetryMutableRPC(err)
default:
lg.Warn("unrecognized retry policy", zap.String("retryPolicy", callOpts.retryPolicy.String()))
return false
}
} | |
c175125 | *options) {
o.retryPolicy = rp
}}
} | |
c175126 | *options) {
o.retryAuth = retryAuth
}}
} | |
c175127 | *options) {
o.max = maxRetries
}}
} | |
c175128 | *options) {
o.backoffFunc = bf
}}
} | |
c175129 | ss.recvRateQueue.Insert(
&RequestStats{
SendingTime: now,
Size: reqSize,
},
)
ss.RecvAppendRequestCnt++
} | |
c175130 | SendingTime: time.Now(),
Size: reqSize,
},
)
ss.SendAppendRequestCnt++
} | |
c175131 | only newest update
widx := 0
for ridx := 1; ridx < bb.used; ridx++ {
if !bytes.Equal(bb.buf[ridx].key, bb.buf[widx].key) {
widx++
}
bb.buf[widx] = bb.buf[ridx]
}
bb.used = widx + 1
} | |
c175132 | nil {
return false, err
} else if !txnresp.Succeeded {
return false, nil
}
return true, nil
} | |
c175133 | id := cl.MemberByName(member).ID
m := rcl.Member(id)
if m == nil {
return false
}
if len(m.ClientURLs) > 0 {
return true
}
return false
} | |
c175134 | return getClusterFromRemotePeers(lg, urls, 10*time.Second, true, rt)
} | |
c175135 | )
} else {
plog.Warningf("could not parse the cluster ID from cluster res: %v", err)
}
}
continue
}
// check the length of membership members
// if the membership members are present then prepare and return raft cluster
// if membership members are not present then the raft cluster formed will be
// an invalid empty cluster hence return failed to get raft cluster member(s) from the given urls error
if len(membs) > 0 {
return membership.NewClusterFromMembers(lg, "", id, membs), nil
}
return nil, fmt.Errorf("failed to get raft cluster member(s) from the given URLs")
}
return nil, fmt.Errorf("could not retrieve cluster information from the given URLs")
} | |
c175136 | continue
}
us = append(us, m.PeerURLs...)
}
sort.Strings(us)
return us
} | |
c175137 | if lg != nil {
lg.Warn("failed to get version", zap.String("remote-member-id", m.ID.String()), zap.Error(err))
} else {
plog.Warningf("cannot get the version of member %s (%v)", m.ID, err)
}
vers[m.ID.String()] = nil
} else {
vers[m.ID.String()] = ver
}
}
return vers
} | |
c175138 | zap.String("local-member-version", lv.String()),
zap.String("remote-member-id", mid),
zap.String("remote-member-version", ver.Server),
)
} else {
plog.Warningf("the local etcd version %s is not up-to-date", lv.String())
plog.Warningf("member %s has a higher version %s", mid, ver.Server)
}
}
if cv == nil {
cv = v
} else if v.LessThan(*cv) {
cv = v
}
}
return cv
} | |
c175139 |
} else {
plog.Warningf("failed to read out the response body from the peerURL(%s) of member %s (%v)", u, m.ID, err)
}
continue
}
var vers version.Versions
if err = json.Unmarshal(b, &vers); err != nil {
if lg != nil {
lg.Warn(
"failed to unmarshal response",
zap.String("address", addr),
zap.String("remote-member-id", m.ID.String()),
zap.Error(err),
)
} else {
plog.Warningf("failed to unmarshal the response body got from the peerURL(%s) of member %s (%v)", u, m.ID, err)
}
continue
}
return &vers, nil
}
return nil, err
} | |
c175140 | maxDuration: maxDuration,
records: make(map[uint64]time.Time),
}
} | |
c175141 |
td.records = make(map[uint64]time.Time)
} | |
c175142 | - td.maxDuration
if exceed > 0 {
ok = false
}
}
td.records[which] = now
return ok, exceed
} | |
c175143 | newPeerHandler(lg, s.Cluster(), s.RaftHandler(), s.LeaseHandler())
} | |
c175144 | if len(ki.generations) == 0 {
ki.generations = append(ki.generations, generation{})
}
g := &ki.generations[len(ki.generations)-1]
if len(g.revs) == 0 { // create a new key
keysGauge.Inc()
g.created = rev
}
g.revs = append(g.revs, rev)
g.ver++
ki.modified = rev
} | |
c175145 | %s", string(ki.key))
}
}
if ki.generations[len(ki.generations)-1].isEmpty() {
return ErrRevisionNotFound
}
ki.put(lg, main, sub)
ki.generations = append(ki.generations, generation{})
keysGauge.Dec()
return nil
} | |
c175146 | on empty keyIndex %s", string(ki.key))
}
}
g := ki.findGeneration(atRev)
if g.isEmpty() {
return revision{}, revision{}, 0, ErrRevisionNotFound
}
n := g.walk(func(rev revision) bool { return rev.main > atRev })
if n != -1 {
return g.revs[n], g.created, g.ver - int64(len(g.revs)-n-1), nil
}
return revision{}, revision{}, 0, ErrRevisionNotFound
} | |
c175147 | 1; gi > 0; gi-- {
g := ki.generations[gi]
if g.isEmpty() {
continue
}
if since.GreaterThan(g.created) {
break
}
}
var revs []revision
var last int64
for ; gi < len(ki.generations); gi++ {
for _, r := range ki.generations[gi].revs {
if since.GreaterThan(r) {
continue
}
if r.main == last {
// replace the revision with a new one that has higher sub value,
// because the original one should not be seen by external
revs[len(revs)-1] = r
continue
}
revs = append(revs, r)
last = r.main
}
}
return revs
} | |
c175148 | revIndex == len(g.revs)-1 && genIdx != len(ki.generations)-1 {
delete(available, g.revs[revIndex])
}
}
} | |
c175149 |
cg--
continue
}
g := ki.generations[cg]
if cg != lastg {
if tomb := g.revs[len(g.revs)-1].main; tomb <= rev {
return nil
}
}
if g.revs[0].main <= rev {
return &ki.generations[cg]
}
cg--
}
return nil
} | |
c175150 | if !wa.victim {
panic("watcher not victim but not in watch groups")
}
var victimBatch watcherBatch
for _, wb := range s.victims {
if wb[wa] != nil {
victimBatch = wb
break
}
}
if victimBatch != nil {
slowWatcherGauge.Dec()
delete(victimBatch, wa)
break
}
// victim being processed so not accessible; retry
s.mu.Unlock()
time.Sleep(time.Millisecond)
}
watcherGauge.Dec()
wa.ch = nil
s.mu.Unlock()
} | |
c175151 | }
syncDuration := time.Since(st)
waitDuration := 100 * time.Millisecond
// more work pending?
if unsyncedWatchers != 0 && lastUnsyncedWatchers > unsyncedWatchers {
// be fair to other store operations by yielding time taken
waitDuration = syncDuration
}
select {
case <-time.After(waitDuration):
case <-s.stopc:
return
}
}
} | |
c175152 | if !isEmpty {
tickc = time.After(10 * time.Millisecond)
}
select {
case <-tickc:
case <-s.victimc:
case <-s.stopc:
return
}
}
} | |
c175153 | newVictim != nil && newVictim[w] != nil {
// couldn't send watch response; stays victim
continue
}
w.victim = false
if eb.moreRev != 0 {
w.minRev = eb.moreRev
}
if w.minRev <= curRev {
s.unsynced.add(w)
} else {
slowWatcherGauge.Dec()
s.synced.add(w)
}
}
s.store.revMu.RUnlock()
s.mu.Unlock()
}
if len(newVictim) > 0 {
s.mu.Lock()
s.victims = append(s.victims, newVictim)
s.mu.Unlock()
}
return moved
} | |
c175154 |
ty := mvccpb.PUT
if isTombstone(revs[i]) {
ty = mvccpb.DELETE
// patch in mod revision so watchers won't skip
kv.ModRevision = bytesToRev(revs[i]).main
}
evs = append(evs, mvccpb.Event{Kv: &kv, Type: ty})
}
return evs
} | |
c175155 | rev}) {
pendingEventsGauge.Add(float64(len(eb.evs)))
} else {
// move slow watcher to victims
w.minRev = rev + 1
if victim == nil {
victim = make(watcherBatch)
}
w.victim = true
victim[w] = eb
s.synced.delete(w)
slowWatcherGauge.Inc()
}
}
s.addVictim(victim)
} | |
c175156 | if strings.Contains(opFunc.Name(), op) {
return true
}
}
}
}
return false
} | |
c175157 |
t.unsafePut(bucketName, key, value, false)
} | |
c175158 | {
t.unsafePut(bucketName, key, value, true)
} | |
c175159 | zap.String("bucket-name", string(bucketName)),
)
} else {
plog.Fatalf("bucket %s does not exist", bucketName)
}
}
return unsafeRange(bucket.Cursor(), key, endKey, limit)
} | |
c175160 | t.backend.lg != nil {
t.backend.lg.Fatal(
"failed to delete a key",
zap.String("bucket-name", string(bucketName)),
zap.Error(err),
)
} else {
plog.Fatalf("cannot delete key from bucket (%v)", err)
}
}
t.pending++
} | |
c175161 | func(k, v []byte) error) error {
return unsafeForEach(t.tx, bucketName, visitor)
} | |
c175162 |
t.Lock()
t.commit(false)
t.Unlock()
} | |
c175163 | t.commit(true)
t.Unlock()
} | |
c175164 | Clear remaining TTL when we renew if it is set
// By applying a RAFT entry only when the remainingTTL is already set, we limit the number
// of RAFT entries written per lease to a max of 2 per checkpoint interval.
if clearRemainingTTL {
le.cp(context.Background(), &pb.LeaseCheckpointRequest{Checkpoints: []*pb.LeaseCheckpoint{{ID: int64(l.ID), Remaining_TTL: 0}}})
}
le.mu.Lock()
l.refresh(0)
item := &LeaseWithTime{id: l.ID, time: l.expiry.UnixNano()}
heap.Push(&le.leaseHeap, item)
le.mu.Unlock()
leaseRenewed.Inc()
return l.ttl, nil
} | |
c175165 | it := range items {
l.itemSet[it] = struct{}{}
le.itemMap[it] = id
}
l.mu.Unlock()
return nil
} | |
c175166 |
le.mu.RUnlock()
if len(ls) != 0 {
select {
case <-le.stopC:
return
case le.expiredC <- ls:
default:
// the receiver of expiredC is probably busy handling
// other stuff
// let's try this next time after 500ms
}
}
} | |
c175167 | != 0 {
le.cp(context.Background(), &pb.LeaseCheckpointRequest{Checkpoints: cps})
}
if len(cps) < maxLeaseCheckpointBatchSize {
return
}
}
} | |
c175168 | need to revoke (nothing is expiry)
return l, false, false
}
// if the lease is actually expired, add to the removal list. If it is not expired, we can ignore it because another entry will have been inserted into the heap
heap.Pop(&le.leaseHeap) // O(log N)
return l, true, false
} | |
c175169 | l.expired() {
leases = append(leases, l)
// reach expired limit
if len(leases) == limit {
break
}
}
}
return leases
} | |
c175170 | + time.Duration(l.RemainingTTL())*time.Second)
l.expiryMu.Lock()
defer l.expiryMu.Unlock()
l.expiry = newExpiry
} | |
c175171 | l.expiryMu.Unlock()
l.expiry = forever
} | |
c175172 | keys = append(keys, k.Key)
}
l.mu.RUnlock()
return keys
} | |
c175173 |
if l.expiry.IsZero() {
return time.Duration(math.MaxInt64)
}
return time.Until(l.expiry)
} | |
c175174 | compactionCommandFunc,
}
cmd.Flags().BoolVar(&compactPhysical, "physical", false, "'true' to wait for compaction to physically remove all old revisions")
return cmd
} | |
c175175 |
}
c := mustClientFromCmd(cmd)
ctx, cancel := commandCtx(cmd)
_, cerr := c.Compact(ctx, rev, opts...)
cancel()
if cerr != nil {
ExitWithError(ExitError, cerr)
}
fmt.Println("compacted revision", rev)
} | |
c175176 | standard input.
If <lease> isn't given as a command line argument and '--ignore-lease' is not specified,
this command tries to read the value from standard input.
For example,
$ cat file | put <key>
will store the content of the file to <key>.
`,
Run: putCommandFunc,
}
cmd.Flags().StringVar(&leaseStr, "lease", "0", "lease ID (in hexadecimal) to attach to the key")
cmd.Flags().BoolVar(&putPrevKV, "prev-kv", false, "return the previous key-value pair before modification")
cmd.Flags().BoolVar(&putIgnoreVal, "ignore-value", false, "updates the key using its current value")
cmd.Flags().BoolVar(&putIgnoreLease, "ignore-lease", false, "updates the key using its current lease")
return cmd
} | |
c175177 | cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.Put(*resp)
} | |
c175178 | if err != nil {
plog.Infof("Error enabling Transport HTTP/2 support: %v", err)
}
}
p := &reverseProxy{
director: newDirector(urlsFunc, failureWait, refreshInterval),
transport: t,
}
mux := http.NewServeMux()
mux.Handle("/", p)
mux.HandleFunc("/v2/config/local/proxy", p.configHandler)
return mux
} | |
c175179 | readonlyHandlerFunc(hdlr)
return http.HandlerFunc(readonly)
} | |
c175180 |
$ set -- <key> <value>`,
Flags: []cli.Flag{
cli.IntFlag{Name: "ttl", Value: 0, Usage: "key time-to-live in seconds"},
cli.StringFlag{Name: "swap-with-value", Value: "", Usage: "previous value"},
cli.IntFlag{Name: "swap-with-index", Value: 0, Usage: "previous index"},
},
Action: func(c *cli.Context) error {
setCommandFunc(c, mustNewKeyAPI(c))
return nil
},
}
} | |
c175181 | cancel := contextWithTotalTimeout(c)
resp, err := ki.Set(ctx, key, value, &client.SetOptions{TTL: time.Duration(ttl) * time.Second, PrevIndex: uint64(prevIndex), PrevValue: prevValue})
cancel()
if err != nil {
handleError(c, ExitServerError, err)
}
printResponseKey(resp, c.GlobalString("output"))
} | |
c175182 | blocking key
_, err = WaitEvents(
client,
string(lastKey.Kvs[0].Key),
rwm.myKey.Revision(),
[]mvccpb.Event_EventType{mvccpb.DELETE})
return false, err
} | |
c175183 | supported on %s_%s", runtime.GOOS, runtime.GOARCH)
} | |
c175184 | etcd node snapshots",
}
cmd.AddCommand(NewSnapshotSaveCommand())
cmd.AddCommand(NewSnapshotRestoreCommand())
cmd.AddCommand(newSnapshotStatusCommand())
return cmd
} | |
c175185 |
Short: "Transfers leadership to another etcd cluster member.",
Run: transferLeadershipCommandFunc,
}
return cmd
} | |
c175186 | _, ep := range eps {
cfg := clientConfigFromCmd(cmd)
cfg.endpoints = []string{ep}
cli := cfg.mustClient()
resp, serr := cli.Status(ctx, ep)
if serr != nil {
ExitWithError(ExitError, serr)
}
if resp.Header.GetMemberId() == resp.Leader {
leaderCli = cli
leaderID = resp.Leader
break
}
cli.Close()
}
if leaderCli == nil {
ExitWithError(ExitBadArgs, fmt.Errorf("no leader endpoint given at %v", eps))
}
var resp *clientv3.MoveLeaderResponse
resp, err = leaderCli.MoveLeader(ctx, target)
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.MoveLeader(leaderID, target, *resp)
} | |
c175187 | nil, err
}
return os.NewFile(uintptr(fd), path), nil
} | |
c175188 | is an empty directory or a key-value pair",
ArgsUsage: "<key>",
Action: func(c *cli.Context) error {
rmdirCommandFunc(c, mustNewKeyAPI(c))
return nil
},
}
} | |
c175189 | handleError(c, ExitServerError, err)
}
if !resp.Node.Dir || c.GlobalString("output") != "simple" {
printResponseKey(resp, c.GlobalString("output"))
}
} | |
c175190 | "prev-kv", false, "return deleted key-value pairs")
cmd.Flags().BoolVar(&delFromKey, "from-key", false, "delete keys that are greater than or equal to the given key using byte compare")
return cmd
} | |
c175191 |
resp, err := mustClientFromCmd(cmd).Delete(ctx, key, opts...)
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.Del(*resp)
} | |
c175192 | current system env
return NewExpectWithEnv(name, arg, nil)
} | |
c175193 | = sync.NewCond(&ep.mu)
ep.cmd.Stderr = ep.cmd.Stdout
ep.cmd.Stdin = nil
if ep.fpty, err = pty.Start(ep.cmd); err != nil {
return nil, err
}
ep.wg.Add(1)
go ep.read()
return ep, nil
} | |
c175194 | ep.cond.Wait()
}
if len(ep.lines) == 0 {
break
}
l := ep.lines[0]
ep.lines = ep.lines[1:]
if f(l) {
ep.mu.Unlock()
return l, nil
}
}
ep.mu.Unlock()
return "", ep.err
} | |
c175195 | string) bool { return strings.Contains(txt, s) })
} | |
c175196 | defer ep.mu.Unlock()
return ep.count
} | |
c175197 | ep.cmd.Process.Signal(sig)
} | |
c175198 | if err != nil {
panic(err)
}
return string(b)
} | |
c175199 | string(req.RangeEnd))
} else {
ivl = adt.NewStringAffinePoint(string(req.Key))
}
iv = c.cachedRanges.Find(ivl)
if iv == nil {
val := map[string]struct{}{key: {}}
c.cachedRanges.Insert(ivl, val)
} else {
val := iv.Val.(map[string]struct{})
val[key] = struct{}{}
iv.Val = val
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.