_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q175000 | RemoveMember | test | func (c *RaftCluster) RemoveMember(id types.ID) {
c.Lock()
defer c.Unlock()
if c.v2store != nil {
mustDeleteMemberFromStore(c.v2store, id)
}
if c.be != nil {
mustDeleteMemberFromBackend(c.be, id)
}
m, ok := c.members[id]
delete(c.members, id)
c.removed[id] = true
if c.lg != nil {
if ok {
c.lg.Info(... | go | {
"resource": ""
} |
q175001 | ValidateClusterAndAssignIDs | test | func ValidateClusterAndAssignIDs(lg *zap.Logger, local *RaftCluster, existing *RaftCluster) error {
ems := existing.Members()
lms := local.Members()
if len(ems) != len(lms) {
return fmt.Errorf("member count is unequal")
}
sort.Sort(MembersByPeerURLs(ems))
sort.Sort(MembersByPeerURLs(lms))
ctx, cancel := conte... | go | {
"resource": ""
} |
q175002 | Keep | test | func (ti *treeIndex) Keep(rev int64) map[revision]struct{} {
available := make(map[revision]struct{})
ti.RLock()
defer ti.RUnlock()
ti.tree.Ascend(func(i btree.Item) bool {
keyi := i.(*keyIndex)
keyi.keep(rev, available)
return true
})
return available
} | go | {
"resource": ""
} |
q175003 | closeRequireLeader | test | func (l *lessor) closeRequireLeader() {
l.mu.Lock()
defer l.mu.Unlock()
for _, ka := range l.keepAlives {
reqIdxs := 0
// find all required leader channels, close, mark as nil
for i, ctx := range ka.ctxs {
md, ok := metadata.FromOutgoingContext(ctx)
if !ok {
continue
}
ks := md[rpctypes.Metadat... | go | {
"resource": ""
} |
q175004 | resetRecv | test | func (l *lessor) resetRecv() (pb.Lease_LeaseKeepAliveClient, error) {
sctx, cancel := context.WithCancel(l.stopCtx)
stream, err := l.remote.LeaseKeepAlive(sctx, append(l.callOpts, withMax(0))...)
if err != nil {
cancel()
return nil, err
}
l.mu.Lock()
defer l.mu.Unlock()
if l.stream != nil && l.streamCancel ... | go | {
"resource": ""
} |
q175005 | recvKeepAlive | test | func (l *lessor) recvKeepAlive(resp *pb.LeaseKeepAliveResponse) {
karesp := &LeaseKeepAliveResponse{
ResponseHeader: resp.GetHeader(),
ID: LeaseID(resp.ID),
TTL: resp.TTL,
}
l.mu.Lock()
defer l.mu.Unlock()
ka, ok := l.keepAlives[karesp.ID]
if !ok {
return
}
if karesp.TTL <= 0 {... | go | {
"resource": ""
} |
q175006 | deadlineLoop | test | func (l *lessor) deadlineLoop() {
for {
select {
case <-time.After(time.Second):
case <-l.donec:
return
}
now := time.Now()
l.mu.Lock()
for id, ka := range l.keepAlives {
if ka.deadline.Before(now) {
// waited too long for response; lease may be expired
ka.close()
delete(l.keepAlives, i... | go | {
"resource": ""
} |
q175007 | sendKeepAliveLoop | test | func (l *lessor) sendKeepAliveLoop(stream pb.Lease_LeaseKeepAliveClient) {
for {
var tosend []LeaseID
now := time.Now()
l.mu.Lock()
for id, ka := range l.keepAlives {
if ka.nextKeepAlive.Before(now) {
tosend = append(tosend, id)
}
}
l.mu.Unlock()
for _, id := range tosend {
r := &pb.LeaseK... | go | {
"resource": ""
} |
q175008 | NewKV | test | func NewKV(cl *v3.Client, pfx string, opts ...concurrency.SessionOption) (v3.KV, func(), error) {
cctx, cancel := context.WithCancel(cl.Ctx())
lkv := &leasingKV{
cl: cl,
kv: cl.KV,
pfx: pfx,
leases: leaseCache{revokes: make(map[string]time.Time)},
ctx: cctx,
cancel: ... | go | {
"resource": ""
} |
q175009 | rescind | test | func (lkv *leasingKV) rescind(ctx context.Context, key string, rev int64) {
if lkv.leases.Evict(key) > rev {
return
}
cmp := v3.Compare(v3.CreateRevision(lkv.pfx+key), "<", rev)
op := v3.OpDelete(lkv.pfx + key)
for ctx.Err() == nil {
if _, err := lkv.kv.Txn(ctx).If(cmp).Then(op).Commit(); err == nil {
retur... | go | {
"resource": ""
} |
q175010 | LeaseValue | test | func LeaseValue(key string) Cmp {
return Cmp{Key: []byte(key), Target: pb.Compare_LEASE}
} | go | {
"resource": ""
} |
q175011 | ValueBytes | test | func (cmp *Cmp) ValueBytes() []byte {
if tu, ok := cmp.TargetUnion.(*pb.Compare_Value); ok {
return tu.Value
}
return nil
} | go | {
"resource": ""
} |
q175012 | WithRange | test | func (cmp Cmp) WithRange(end string) Cmp {
cmp.RangeEnd = []byte(end)
return cmp
} | go | {
"resource": ""
} |
q175013 | WithPrefix | test | func (cmp Cmp) WithPrefix() Cmp {
cmp.RangeEnd = getPrefix(cmp.Key)
return cmp
} | go | {
"resource": ""
} |
q175014 | mustInt64 | test | func mustInt64(val interface{}) int64 {
if v, ok := val.(int64); ok {
return v
}
if v, ok := val.(int); ok {
return int64(v)
}
panic("bad value")
} | go | {
"resource": ""
} |
q175015 | mustInt64orLeaseID | test | func mustInt64orLeaseID(val interface{}) int64 {
if v, ok := val.(LeaseID); ok {
return int64(v)
}
return mustInt64(val)
} | go | {
"resource": ""
} |
q175016 | Next | test | func (gw *gRPCWatcher) Next() ([]*naming.Update, error) {
if gw.wch == nil {
// first Next() returns all addresses
return gw.firstNext()
}
if gw.err != nil {
return nil, gw.err
}
// process new events on target/*
wr, ok := <-gw.wch
if !ok {
gw.err = status.Error(codes.Unavailable, ErrWatcherClosed.Error... | go | {
"resource": ""
} |
q175017 | getJournalWriteSyncer | test | func getJournalWriteSyncer() (zapcore.WriteSyncer, error) {
jw, err := logutil.NewJournalWriter(os.Stderr)
if err != nil {
return nil, fmt.Errorf("can't find journal (%v)", err)
}
return zapcore.AddSync(jw), nil
} | go | {
"resource": ""
} |
q175018 | newKV | test | func newKV(store *store, nodePath string, value string, createdIndex uint64, parent *node, expireTime time.Time) *node {
return &node{
Path: nodePath,
CreatedIndex: createdIndex,
ModifiedIndex: createdIndex,
Parent: parent,
store: store,
ExpireTime: expireTime,
Value: ... | go | {
"resource": ""
} |
q175019 | newDir | test | func newDir(store *store, nodePath string, createdIndex uint64, parent *node, expireTime time.Time) *node {
return &node{
Path: nodePath,
CreatedIndex: createdIndex,
ModifiedIndex: createdIndex,
Parent: parent,
ExpireTime: expireTime,
Children: make(map[string]*node),
store: ... | go | {
"resource": ""
} |
q175020 | Read | test | func (n *node) Read() (string, *v2error.Error) {
if n.IsDir() {
return "", v2error.NewError(v2error.EcodeNotFile, "", n.store.CurrentIndex)
}
return n.Value, nil
} | go | {
"resource": ""
} |
q175021 | Write | test | func (n *node) Write(value string, index uint64) *v2error.Error {
if n.IsDir() {
return v2error.NewError(v2error.EcodeNotFile, "", n.store.CurrentIndex)
}
n.Value = value
n.ModifiedIndex = index
return nil
} | go | {
"resource": ""
} |
q175022 | List | test | func (n *node) List() ([]*node, *v2error.Error) {
if !n.IsDir() {
return nil, v2error.NewError(v2error.EcodeNotDir, "", n.store.CurrentIndex)
}
nodes := make([]*node, len(n.Children))
i := 0
for _, node := range n.Children {
nodes[i] = node
i++
}
return nodes, nil
} | go | {
"resource": ""
} |
q175023 | GetChild | test | func (n *node) GetChild(name string) (*node, *v2error.Error) {
if !n.IsDir() {
return nil, v2error.NewError(v2error.EcodeNotDir, n.Path, n.store.CurrentIndex)
}
child, ok := n.Children[name]
if ok {
return child, nil
}
return nil, nil
} | go | {
"resource": ""
} |
q175024 | Add | test | func (n *node) Add(child *node) *v2error.Error {
if !n.IsDir() {
return v2error.NewError(v2error.EcodeNotDir, "", n.store.CurrentIndex)
}
_, name := path.Split(child.Path)
if _, ok := n.Children[name]; ok {
return v2error.NewError(v2error.EcodeNodeExist, "", n.store.CurrentIndex)
}
n.Children[name] = child... | go | {
"resource": ""
} |
q175025 | Remove | test | func (n *node) Remove(dir, recursive bool, callback func(path string)) *v2error.Error {
if !n.IsDir() { // key-value pair
_, name := path.Split(n.Path)
// find its parent and remove the node from the map
if n.Parent != nil && n.Parent.Children[name] == n {
delete(n.Parent.Children, name)
}
if callback !... | go | {
"resource": ""
} |
q175026 | Compare | test | func (n *node) Compare(prevValue string, prevIndex uint64) (ok bool, which int) {
indexMatch := prevIndex == 0 || n.ModifiedIndex == prevIndex
valueMatch := prevValue == "" || n.Value == prevValue
ok = valueMatch && indexMatch
switch {
case valueMatch && indexMatch:
which = CompareMatch
case indexMatch && !valu... | go | {
"resource": ""
} |
q175027 | Clone | test | func (n *node) Clone() *node {
if !n.IsDir() {
newkv := newKV(n.store, n.Path, n.Value, n.CreatedIndex, n.Parent, n.ExpireTime)
newkv.ModifiedIndex = n.ModifiedIndex
return newkv
}
clone := newDir(n.store, n.Path, n.CreatedIndex, n.Parent, n.ExpireTime)
clone.ModifiedIndex = n.ModifiedIndex
for key, child ... | go | {
"resource": ""
} |
q175028 | isConnectedToQuorumSince | test | func isConnectedToQuorumSince(transport rafthttp.Transporter, since time.Time, self types.ID, members []*membership.Member) bool {
return numConnectedSince(transport, since, self, members) >= (len(members)/2)+1
} | go | {
"resource": ""
} |
q175029 | isConnectedSince | test | func isConnectedSince(transport rafthttp.Transporter, since time.Time, remote types.ID) bool {
t := transport.ActiveSince(remote)
return !t.IsZero() && t.Before(since)
} | go | {
"resource": ""
} |
q175030 | numConnectedSince | test | func numConnectedSince(transport rafthttp.Transporter, since time.Time, self types.ID, members []*membership.Member) int {
connectedNum := 0
for _, m := range members {
if m.ID == self || isConnectedSince(transport, since, m.ID) {
connectedNum++
}
}
return connectedNum
} | go | {
"resource": ""
} |
q175031 | longestConnected | test | func longestConnected(tp rafthttp.Transporter, membs []types.ID) (types.ID, bool) {
var longest types.ID
var oldest time.Time
for _, id := range membs {
tm := tp.ActiveSince(id)
if tm.IsZero() { // inactive
continue
}
if oldest.IsZero() { // first longest candidate
oldest = tm
longest = id
}
i... | go | {
"resource": ""
} |
q175032 | isTornEntry | test | func (d *decoder) isTornEntry(data []byte) bool {
if len(d.brs) != 1 {
return false
}
fileOff := d.lastValidOff + frameSizeBytes
curOff := 0
chunks := [][]byte{}
// split data on sector boundaries
for curOff < len(data) {
chunkLen := int(minSectorSize - (fileOff % minSectorSize))
if chunkLen > len(data)-c... | go | {
"resource": ""
} |
q175033 | StartMockServersOnNetwork | test | func StartMockServersOnNetwork(count int, network string) (ms *MockServers, err error) {
switch network {
case "tcp":
return startMockServersTcp(count)
case "unix":
return startMockServersUnix(count)
default:
return nil, fmt.Errorf("unsupported network type: %s", network)
}
} | go | {
"resource": ""
} |
q175034 | StartAt | test | func (ms *MockServers) StartAt(idx int) (err error) {
ms.mu.Lock()
defer ms.mu.Unlock()
if ms.Servers[idx].ln == nil {
ms.Servers[idx].ln, err = net.Listen(ms.Servers[idx].Network, ms.Servers[idx].Address)
if err != nil {
return fmt.Errorf("failed to listen %v", err)
}
}
svr := grpc.NewServer()
pb.Regi... | go | {
"resource": ""
} |
q175035 | StopAt | test | func (ms *MockServers) StopAt(idx int) {
ms.mu.Lock()
defer ms.mu.Unlock()
if ms.Servers[idx].ln == nil {
return
}
ms.Servers[idx].GrpcServer.Stop()
ms.Servers[idx].GrpcServer = nil
ms.Servers[idx].ln = nil
ms.wg.Done()
} | go | {
"resource": ""
} |
q175036 | Stop | test | func (ms *MockServers) Stop() {
for idx := range ms.Servers {
ms.StopAt(idx)
}
ms.wg.Wait()
} | go | {
"resource": ""
} |
q175037 | NewCheckCommand | test | func NewCheckCommand() *cobra.Command {
cc := &cobra.Command{
Use: "check <subcommand>",
Short: "commands for checking properties of the etcd cluster",
}
cc.AddCommand(NewCheckPerfCommand())
cc.AddCommand(NewCheckDatascaleCommand())
return cc
} | go | {
"resource": ""
} |
q175038 | NewCheckPerfCommand | test | func NewCheckPerfCommand() *cobra.Command {
cmd := &cobra.Command{
Use: "perf [options]",
Short: "Check the performance of the etcd cluster",
Run: newCheckPerfCommand,
}
// TODO: support customized configuration
cmd.Flags().StringVar(&checkPerfLoad, "load", "s", "The performance check's workload model. A... | go | {
"resource": ""
} |
q175039 | NewCheckDatascaleCommand | test | func NewCheckDatascaleCommand() *cobra.Command {
cmd := &cobra.Command{
Use: "datascale [options]",
Short: "Check the memory usage of holding data for different workloads on a given server endpoint.",
Long: "If no endpoint is provided, localhost will be used. If multiple endpoints are provided, first endpoint... | go | {
"resource": ""
} |
q175040 | NewGetCommand | test | func NewGetCommand() *cobra.Command {
cmd := &cobra.Command{
Use: "get [options] <key> [range_end]",
Short: "Gets the key or a range of keys",
Run: getCommandFunc,
}
cmd.Flags().StringVar(&getConsistency, "consistency", "l", "Linearizable(l) or Serializable(s)")
cmd.Flags().StringVar(&getSortOrder, "orde... | go | {
"resource": ""
} |
q175041 | NewGetCommand | test | func NewGetCommand() cli.Command {
return cli.Command{
Name: "get",
Usage: "retrieve the value of a key",
ArgsUsage: "<key>",
Flags: []cli.Flag{
cli.BoolFlag{Name: "sort", Usage: "returns result in sorted order"},
cli.BoolFlag{Name: "quorum, q", Usage: "require quorum for get request"},
},
A... | go | {
"resource": ""
} |
q175042 | PickPeerURL | test | func (m *Member) PickPeerURL() string {
if len(m.PeerURLs) == 0 {
panic("member should always have some peer url")
}
return m.PeerURLs[rand.Intn(len(m.PeerURLs))]
} | go | {
"resource": ""
} |
q175043 | HandleMetricsHealth | test | func HandleMetricsHealth(mux *http.ServeMux, srv etcdserver.ServerV2) {
mux.Handle(PathMetrics, promhttp.Handler())
mux.Handle(PathHealth, NewHealthHandler(func() Health { return checkHealth(srv) }))
} | go | {
"resource": ""
} |
q175044 | NewRemoveCommand | test | func NewRemoveCommand() cli.Command {
return cli.Command{
Name: "rm",
Usage: "remove a key or a directory",
ArgsUsage: "<key>",
Flags: []cli.Flag{
cli.BoolFlag{Name: "dir", Usage: "removes the key if it is an empty directory or a key-value pair"},
cli.BoolFlag{Name: "recursive, r", Usage: "remov... | go | {
"resource": ""
} |
q175045 | rmCommandFunc | test | func rmCommandFunc(c *cli.Context, ki client.KeysAPI) {
if len(c.Args()) == 0 {
handleError(c, ExitBadArgs, errors.New("key required"))
}
key := c.Args()[0]
recursive := c.Bool("recursive")
dir := c.Bool("dir")
prevValue := c.String("with-value")
prevIndex := c.Int("with-index")
ctx, cancel := contextWithTot... | go | {
"resource": ""
} |
q175046 | checkIntervals | test | func checkIntervals(reqs []*pb.RequestOp) (map[string]struct{}, adt.IntervalTree, error) {
var dels adt.IntervalTree
// collect deletes from this level; build first to check lower level overlapped puts
for _, req := range reqs {
tv, ok := req.Request.(*pb.RequestOp_RequestDeleteRange)
if !ok {
continue
}
... | go | {
"resource": ""
} |
q175047 | ReportEventReceived | test | func ReportEventReceived(n int) {
pendingEventsGauge.Sub(float64(n))
totalEventsCounter.Add(float64(n))
} | go | {
"resource": ""
} |
q175048 | RegisterKVHandler | test | func RegisterKVHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterKVHandlerClient(ctx, mux, etcdserverpb.NewKVClient(conn))
} | go | {
"resource": ""
} |
q175049 | RegisterWatchHandler | test | func RegisterWatchHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterWatchHandlerClient(ctx, mux, etcdserverpb.NewWatchClient(conn))
} | go | {
"resource": ""
} |
q175050 | RegisterLeaseHandler | test | func RegisterLeaseHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterLeaseHandlerClient(ctx, mux, etcdserverpb.NewLeaseClient(conn))
} | go | {
"resource": ""
} |
q175051 | RegisterClusterHandler | test | func RegisterClusterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterClusterHandlerClient(ctx, mux, etcdserverpb.NewClusterClient(conn))
} | go | {
"resource": ""
} |
q175052 | RegisterMaintenanceHandler | test | func RegisterMaintenanceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterMaintenanceHandlerClient(ctx, mux, etcdserverpb.NewMaintenanceClient(conn))
} | go | {
"resource": ""
} |
q175053 | RegisterAuthHandler | test | func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterAuthHandlerClient(ctx, mux, etcdserverpb.NewAuthClient(conn))
} | go | {
"resource": ""
} |
q175054 | startEtcd | test | func startEtcd(cfg *embed.Config) (<-chan struct{}, <-chan error, error) {
e, err := embed.StartEtcd(cfg)
if err != nil {
return nil, nil, err
}
osutil.RegisterInterruptHandler(e.Close)
select {
case <-e.Server.ReadyNotify(): // wait for e.Server to join the cluster
case <-e.Server.StopNotify(): // publish abo... | go | {
"resource": ""
} |
q175055 | identifyDataDirOrDie | test | func identifyDataDirOrDie(lg *zap.Logger, dir string) dirType {
names, err := fileutil.ReadDir(dir)
if err != nil {
if os.IsNotExist(err) {
return dirEmpty
}
if lg != nil {
lg.Fatal("failed to list data directory", zap.String("dir", dir), zap.Error(err))
} else {
plog.Fatalf("error listing data dir: ... | go | {
"resource": ""
} |
q175056 | openLast | test | func openLast(lg *zap.Logger, dirpath string) (*fileutil.LockedFile, error) {
names, err := readWALNames(lg, dirpath)
if err != nil {
return nil, err
}
last := filepath.Join(dirpath, names[len(names)-1])
return fileutil.LockFile(last, os.O_RDWR, fileutil.PrivateFileMode)
} | go | {
"resource": ""
} |
q175057 | gotLeader | test | func (l *leader) gotLeader() {
l.mu.Lock()
defer l.mu.Unlock()
select {
case <-l.leaderc:
l.leaderc = make(chan struct{})
default:
}
} | go | {
"resource": ""
} |
q175058 | lostNotify | test | func (l *leader) lostNotify() <-chan struct{} {
l.mu.RLock()
defer l.mu.RUnlock()
return l.leaderc
} | go | {
"resource": ""
} |
q175059 | newGRPCProxyCommand | test | func newGRPCProxyCommand() *cobra.Command {
lpc := &cobra.Command{
Use: "grpc-proxy <subcommand>",
Short: "grpc-proxy related command",
}
lpc.AddCommand(newGRPCProxyStartCommand())
return lpc
} | go | {
"resource": ""
} |
q175060 | NewMemberCommand | test | func NewMemberCommand() *cobra.Command {
mc := &cobra.Command{
Use: "member <subcommand>",
Short: "Membership related commands",
}
mc.AddCommand(NewMemberAddCommand())
mc.AddCommand(NewMemberRemoveCommand())
mc.AddCommand(NewMemberUpdateCommand())
mc.AddCommand(NewMemberListCommand())
return mc
} | go | {
"resource": ""
} |
q175061 | NewMemberAddCommand | test | func NewMemberAddCommand() *cobra.Command {
cc := &cobra.Command{
Use: "add <memberName> [options]",
Short: "Adds a member into the cluster",
Run: memberAddCommandFunc,
}
cc.Flags().StringVar(&memberPeerURLs, "peer-urls", "", "comma separated peer URLs for the new member.")
return cc
} | go | {
"resource": ""
} |
q175062 | NewMemberRemoveCommand | test | func NewMemberRemoveCommand() *cobra.Command {
cc := &cobra.Command{
Use: "remove <memberID>",
Short: "Removes a member from the cluster",
Run: memberRemoveCommandFunc,
}
return cc
} | go | {
"resource": ""
} |
q175063 | NewMemberUpdateCommand | test | func NewMemberUpdateCommand() *cobra.Command {
cc := &cobra.Command{
Use: "update <memberID> [options]",
Short: "Updates a member in the cluster",
Run: memberUpdateCommandFunc,
}
cc.Flags().StringVar(&memberPeerURLs, "peer-urls", "", "comma separated peer URLs for the updated member.")
return cc
} | go | {
"resource": ""
} |
q175064 | NewMemberListCommand | test | func NewMemberListCommand() *cobra.Command {
cc := &cobra.Command{
Use: "list",
Short: "Lists all members in the cluster",
Long: `When --write-out is set to simple, this command prints out comma-separated member lists for each endpoint.
The items in the lists are ID, Status, Name, Peer Addrs, Client Addrs.
`,
... | go | {
"resource": ""
} |
q175065 | memberAddCommandFunc | test | func memberAddCommandFunc(cmd *cobra.Command, args []string) {
if len(args) < 1 {
ExitWithError(ExitBadArgs, errors.New("member name not provided"))
}
if len(args) > 1 {
ev := "too many arguments"
for _, s := range args {
if strings.HasPrefix(strings.ToLower(s), "http") {
ev += fmt.Sprintf(`, did you me... | go | {
"resource": ""
} |
q175066 | memberRemoveCommandFunc | test | func memberRemoveCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("member ID is not provided"))
}
id, err := strconv.ParseUint(args[0], 16, 64)
if err != nil {
ExitWithError(ExitBadArgs, fmt.Errorf("bad member ID arg (%v), expecting ID in Hex", err))
}... | go | {
"resource": ""
} |
q175067 | memberUpdateCommandFunc | test | func memberUpdateCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("member ID is not provided"))
}
id, err := strconv.ParseUint(args[0], 16, 64)
if err != nil {
ExitWithError(ExitBadArgs, fmt.Errorf("bad member ID arg (%v), expecting ID in Hex", err))
}... | go | {
"resource": ""
} |
q175068 | memberListCommandFunc | test | func memberListCommandFunc(cmd *cobra.Command, args []string) {
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).MemberList(ctx)
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.MemberList(*resp)
} | go | {
"resource": ""
} |
q175069 | Open | test | func Open(lg *zap.Logger, dirpath string, snap walpb.Snapshot) (*WAL, error) {
w, err := openAtIndex(lg, dirpath, snap, true)
if err != nil {
return nil, err
}
if w.dirFile, err = fileutil.OpenDir(w.dir); err != nil {
return nil, err
}
return w, nil
} | go | {
"resource": ""
} |
q175070 | OpenForRead | test | func OpenForRead(lg *zap.Logger, dirpath string, snap walpb.Snapshot) (*WAL, error) {
return openAtIndex(lg, dirpath, snap, false)
} | go | {
"resource": ""
} |
q175071 | Verify | test | func Verify(lg *zap.Logger, walDir string, snap walpb.Snapshot) error {
var metadata []byte
var err error
var match bool
rec := &walpb.Record{}
names, nameIndex, err := selectWALFiles(lg, walDir, snap)
if err != nil {
return err
}
// open wal files in read mode, so that there is no conflict
// when the sa... | go | {
"resource": ""
} |
q175072 | Close | test | func (w *WAL) Close() error {
w.mu.Lock()
defer w.mu.Unlock()
if w.fp != nil {
w.fp.Close()
w.fp = nil
}
if w.tail() != nil {
if err := w.sync(); err != nil {
return err
}
}
for _, l := range w.locks {
if l == nil {
continue
}
if err := l.Close(); err != nil {
if w.lg != nil {
w.lg.W... | go | {
"resource": ""
} |
q175073 | notify | test | func (w *watcher) notify(e *Event, originalPath bool, deleted bool) bool {
// watcher is interested the path in three cases and under one condition
// the condition is that the event happens after the watcher's sinceIndex
// 1. the path at which the event happens is the path the watcher is watching at.
// For exam... | go | {
"resource": ""
} |
q175074 | Remove | test | func (w *watcher) Remove() {
w.hub.mutex.Lock()
defer w.hub.mutex.Unlock()
close(w.eventChan)
if w.remove != nil {
w.remove()
}
} | go | {
"resource": ""
} |
q175075 | mkPathDepth | test | func (s *v2v3Store) mkPathDepth(nodePath string, depth int) string {
normalForm := path.Clean(path.Join("/", nodePath))
n := strings.Count(normalForm, "/") + depth
return fmt.Sprintf("%s/%03d/k/%s", s.pfx, n, normalForm)
} | go | {
"resource": ""
} |
q175076 | mkV2Node | test | func (s *v2v3Store) mkV2Node(kv *mvccpb.KeyValue) *v2store.NodeExtern {
if kv == nil {
return nil
}
n := &v2store.NodeExtern{
Key: s.mkNodePath(string(kv.Key)),
Dir: kv.Key[len(kv.Key)-1] == '/',
CreatedIndex: mkV2Rev(kv.CreateRevision),
ModifiedIndex: mkV2Rev(kv.ModRevision),
}
if !... | go | {
"resource": ""
} |
q175077 | prevKeyFromPuts | test | func prevKeyFromPuts(resp *clientv3.TxnResponse) *mvccpb.KeyValue {
for _, r := range resp.Responses {
pkv := r.GetResponsePut().PrevKv
if pkv != nil && pkv.CreateRevision > 0 {
return pkv
}
}
return nil
} | go | {
"resource": ""
} |
q175078 | NewWeightedReport | test | func NewWeightedReport(r Report, precision string) Report {
return &weightedReport{
baseReport: r,
report: newReport(precision),
results: make(chan Result, 16),
}
} | go | {
"resource": ""
} |
q175079 | NewURLsMapFromStringMap | test | func NewURLsMapFromStringMap(m map[string]string, sep string) (URLsMap, error) {
var err error
um := URLsMap{}
for k, v := range m {
um[k], err = NewURLs(strings.Split(v, sep))
if err != nil {
return nil, err
}
}
return um, nil
} | go | {
"resource": ""
} |
q175080 | String | test | func (c URLsMap) String() string {
var pairs []string
for name, urls := range c {
for _, url := range urls {
pairs = append(pairs, fmt.Sprintf("%s=%s", name, url.String()))
}
}
sort.Strings(pairs)
return strings.Join(pairs, ",")
} | go | {
"resource": ""
} |
q175081 | URLs | test | func (c URLsMap) URLs() []string {
var urls []string
for _, us := range c {
for _, u := range us {
urls = append(urls, u.String())
}
}
sort.Strings(urls)
return urls
} | go | {
"resource": ""
} |
q175082 | parse | test | func parse(s string) map[string][]string {
m := make(map[string][]string)
for s != "" {
key := s
if i := strings.IndexAny(key, ","); i >= 0 {
key, s = key[:i], key[i+1:]
} else {
s = ""
}
if key == "" {
continue
}
value := ""
if i := strings.Index(key, "="); i >= 0 {
key, value = key[:i], ... | go | {
"resource": ""
} |
q175083 | NewClientHandler | test | func NewClientHandler(lg *zap.Logger, server etcdserver.ServerPeer, timeout time.Duration) http.Handler {
mux := http.NewServeMux()
etcdhttp.HandleBasic(mux, server)
handleV2(lg, mux, server, timeout)
return requestLogger(lg, mux)
} | go | {
"resource": ""
} |
q175084 | writeKeyEvent | test | func writeKeyEvent(w http.ResponseWriter, resp etcdserver.Response, noValueOnSuccess bool) error {
ev := resp.Event
if ev == nil {
return errors.New("cannot write empty Event")
}
w.Header().Set("Content-Type", "application/json")
w.Header().Set("X-Etcd-Index", fmt.Sprint(ev.EtcdIndex))
w.Header().Set("X-Raft-In... | go | {
"resource": ""
} |
q175085 | writeKeyError | test | func writeKeyError(lg *zap.Logger, w http.ResponseWriter, err error) {
if err == nil {
return
}
switch e := err.(type) {
case *v2error.Error:
e.WriteTo(w)
default:
switch err {
case etcdserver.ErrTimeoutDueToLeaderFail, etcdserver.ErrTimeoutDueToConnectionLost:
if lg != nil {
lg.Warn(
"v2 respo... | go | {
"resource": ""
} |
q175086 | getUint64 | test | func getUint64(form url.Values, key string) (i uint64, err error) {
if vals, ok := form[key]; ok {
i, err = strconv.ParseUint(vals[0], 10, 64)
}
return
} | go | {
"resource": ""
} |
q175087 | getBool | test | func getBool(form url.Values, key string) (b bool, err error) {
if vals, ok := form[key]; ok {
b, err = strconv.ParseBool(vals[0])
}
return
} | go | {
"resource": ""
} |
q175088 | waitDeletes | test | func waitDeletes(ctx context.Context, client *v3.Client, pfx string, maxCreateRev int64) (*pb.ResponseHeader, error) {
getOpts := append(v3.WithLastCreate(), v3.WithMaxCreateRev(maxCreateRev))
for {
resp, err := client.Get(ctx, pfx, getOpts...)
if err != nil {
return nil, err
}
if len(resp.Kvs) == 0 {
r... | go | {
"resource": ""
} |
q175089 | AddOutputPaths | test | func AddOutputPaths(cfg zap.Config, outputPaths, errorOutputPaths []string) zap.Config {
outputs := make(map[string]struct{})
for _, v := range cfg.OutputPaths {
outputs[v] = struct{}{}
}
for _, v := range outputPaths {
outputs[v] = struct{}{}
}
outputSlice := make([]string, 0)
if _, ok := outputs["/dev/null... | go | {
"resource": ""
} |
q175090 | NewConfig | test | func NewConfig() *Config {
lpurl, _ := url.Parse(DefaultListenPeerURLs)
apurl, _ := url.Parse(DefaultInitialAdvertisePeerURLs)
lcurl, _ := url.Parse(DefaultListenClientURLs)
acurl, _ := url.Parse(DefaultAdvertiseClientURLs)
cfg := &Config{
MaxSnapFiles: DefaultMaxSnapshots,
MaxWalFiles: DefaultMaxWALs,
Nam... | go | {
"resource": ""
} |
q175091 | PeerURLsMapAndToken | test | func (cfg *Config) PeerURLsMapAndToken(which string) (urlsmap types.URLsMap, token string, err error) {
token = cfg.InitialClusterToken
switch {
case cfg.Durl != "":
urlsmap = types.URLsMap{}
// If using discovery, generate a temporary cluster based on
// self's advertised peer URLs
urlsmap[cfg.Name] = cfg.A... | go | {
"resource": ""
} |
q175092 | GetDNSClusterNames | test | func (cfg *Config) GetDNSClusterNames() ([]string, error) {
var (
clusterStrs []string
cerr error
serviceNameSuffix string
)
if cfg.DNSClusterServiceName != "" {
serviceNameSuffix = "-" + cfg.DNSClusterServiceName
}
lg := cfg.GetLogger()
// Use both etcd-server-ssl and etcd-server for... | go | {
"resource": ""
} |
q175093 | checkBindURLs | test | func checkBindURLs(urls []url.URL) error {
for _, url := range urls {
if url.Scheme == "unix" || url.Scheme == "unixs" {
continue
}
host, _, err := net.SplitHostPort(url.Host)
if err != nil {
return err
}
if host == "localhost" {
// special case for local address
// TODO: support /etc/hosts ?
... | go | {
"resource": ""
} |
q175094 | GetCluster | test | func GetCluster(serviceScheme, service, name, dns string, apurls types.URLs) ([]string, error) {
tempName := int(0)
tcp2ap := make(map[string]url.URL)
// First, resolve the apurls
for _, url := range apurls {
tcpAddr, err := resolveTCPAddr("tcp", url.Host)
if err != nil {
return nil, err
}
tcp2ap[tcpAdd... | go | {
"resource": ""
} |
q175095 | GetClient | test | func GetClient(service, domain string, serviceName string) (*SRVClients, error) {
var urls []*url.URL
var srvs []*net.SRV
updateURLs := func(service, scheme string) error {
_, addrs, err := lookupSRV(service, "tcp", domain)
if err != nil {
return err
}
for _, srv := range addrs {
urls = append(urls, &... | go | {
"resource": ""
} |
q175096 | GetSRVService | test | func GetSRVService(service, serviceName string, scheme string) (SRVService string) {
if scheme == "https" {
service = fmt.Sprintf("%s-ssl", service)
}
if serviceName != "" {
return fmt.Sprintf("%s-%s", service, serviceName)
}
return service
} | go | {
"resource": ""
} |
q175097 | ReadDir | test | func ReadDir(d string, opts ...ReadDirOption) ([]string, error) {
op := &ReadDirOp{}
op.applyOpts(opts)
dir, err := os.Open(d)
if err != nil {
return nil, err
}
defer dir.Close()
names, err := dir.Readdirnames(-1)
if err != nil {
return nil, err
}
sort.Strings(names)
if op.ext != "" {
tss := make([]... | go | {
"resource": ""
} |
q175098 | compact | test | func compact(c *v3.Client, rev int64) {
fmt.Printf("Compacting with revision %d\n", rev)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
_, err := c.Compact(ctx, rev, v3.WithCompactPhysical())
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
fmt.Printf("Compacted with revision ... | go | {
"resource": ""
} |
q175099 | defrag | test | func defrag(c *v3.Client, ep string) {
fmt.Printf("Defragmenting %q\n", ep)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
_, err := c.Defragment(ctx, ep)
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
fmt.Printf("Defragmented %q\n", ep)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.