repo
stringlengths 5
67
| path
stringlengths 4
218
| func_name
stringlengths 0
151
| original_string
stringlengths 52
373k
| language
stringclasses 6
values | code
stringlengths 52
373k
| code_tokens
listlengths 10
512
| docstring
stringlengths 3
47.2k
| docstring_tokens
listlengths 3
234
| sha
stringlengths 40
40
| url
stringlengths 85
339
| partition
stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
etcd-io/etcd
|
integration/cluster.go
|
HTTPMembers
|
func (c *cluster) HTTPMembers() []client.Member {
ms := []client.Member{}
for _, m := range c.Members {
pScheme := schemeFromTLSInfo(m.PeerTLSInfo)
cScheme := schemeFromTLSInfo(m.ClientTLSInfo)
cm := client.Member{Name: m.Name}
for _, ln := range m.PeerListeners {
cm.PeerURLs = append(cm.PeerURLs, pScheme+"://"+ln.Addr().String())
}
for _, ln := range m.ClientListeners {
cm.ClientURLs = append(cm.ClientURLs, cScheme+"://"+ln.Addr().String())
}
ms = append(ms, cm)
}
return ms
}
|
go
|
func (c *cluster) HTTPMembers() []client.Member {
ms := []client.Member{}
for _, m := range c.Members {
pScheme := schemeFromTLSInfo(m.PeerTLSInfo)
cScheme := schemeFromTLSInfo(m.ClientTLSInfo)
cm := client.Member{Name: m.Name}
for _, ln := range m.PeerListeners {
cm.PeerURLs = append(cm.PeerURLs, pScheme+"://"+ln.Addr().String())
}
for _, ln := range m.ClientListeners {
cm.ClientURLs = append(cm.ClientURLs, cScheme+"://"+ln.Addr().String())
}
ms = append(ms, cm)
}
return ms
}
|
[
"func",
"(",
"c",
"*",
"cluster",
")",
"HTTPMembers",
"(",
")",
"[",
"]",
"client",
".",
"Member",
"{",
"ms",
":=",
"[",
"]",
"client",
".",
"Member",
"{",
"}",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"c",
".",
"Members",
"{",
"pScheme",
":=",
"schemeFromTLSInfo",
"(",
"m",
".",
"PeerTLSInfo",
")",
"\n",
"cScheme",
":=",
"schemeFromTLSInfo",
"(",
"m",
".",
"ClientTLSInfo",
")",
"\n",
"cm",
":=",
"client",
".",
"Member",
"{",
"Name",
":",
"m",
".",
"Name",
"}",
"\n",
"for",
"_",
",",
"ln",
":=",
"range",
"m",
".",
"PeerListeners",
"{",
"cm",
".",
"PeerURLs",
"=",
"append",
"(",
"cm",
".",
"PeerURLs",
",",
"pScheme",
"+",
"\"://\"",
"+",
"ln",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"ln",
":=",
"range",
"m",
".",
"ClientListeners",
"{",
"cm",
".",
"ClientURLs",
"=",
"append",
"(",
"cm",
".",
"ClientURLs",
",",
"cScheme",
"+",
"\"://\"",
"+",
"ln",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"ms",
"=",
"append",
"(",
"ms",
",",
"cm",
")",
"\n",
"}",
"\n",
"return",
"ms",
"\n",
"}"
] |
// HTTPMembers returns a list of all active members as client.Members
|
[
"HTTPMembers",
"returns",
"a",
"list",
"of",
"all",
"active",
"members",
"as",
"client",
".",
"Members"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L261-L276
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
waitLeader
|
func (c *cluster) waitLeader(t testing.TB, membs []*member) int {
possibleLead := make(map[uint64]bool)
var lead uint64
for _, m := range membs {
possibleLead[uint64(m.s.ID())] = true
}
cc := MustNewHTTPClient(t, getMembersURLs(membs), nil)
kapi := client.NewKeysAPI(cc)
// ensure leader is up via linearizable get
for {
ctx, cancel := context.WithTimeout(context.Background(), 10*tickDuration+time.Second)
_, err := kapi.Get(ctx, "0", &client.GetOptions{Quorum: true})
cancel()
if err == nil || strings.Contains(err.Error(), "Key not found") {
break
}
}
for lead == 0 || !possibleLead[lead] {
lead = 0
for _, m := range membs {
select {
case <-m.s.StopNotify():
continue
default:
}
if lead != 0 && lead != m.s.Lead() {
lead = 0
time.Sleep(10 * tickDuration)
break
}
lead = m.s.Lead()
}
}
for i, m := range membs {
if uint64(m.s.ID()) == lead {
return i
}
}
return -1
}
|
go
|
func (c *cluster) waitLeader(t testing.TB, membs []*member) int {
possibleLead := make(map[uint64]bool)
var lead uint64
for _, m := range membs {
possibleLead[uint64(m.s.ID())] = true
}
cc := MustNewHTTPClient(t, getMembersURLs(membs), nil)
kapi := client.NewKeysAPI(cc)
// ensure leader is up via linearizable get
for {
ctx, cancel := context.WithTimeout(context.Background(), 10*tickDuration+time.Second)
_, err := kapi.Get(ctx, "0", &client.GetOptions{Quorum: true})
cancel()
if err == nil || strings.Contains(err.Error(), "Key not found") {
break
}
}
for lead == 0 || !possibleLead[lead] {
lead = 0
for _, m := range membs {
select {
case <-m.s.StopNotify():
continue
default:
}
if lead != 0 && lead != m.s.Lead() {
lead = 0
time.Sleep(10 * tickDuration)
break
}
lead = m.s.Lead()
}
}
for i, m := range membs {
if uint64(m.s.ID()) == lead {
return i
}
}
return -1
}
|
[
"func",
"(",
"c",
"*",
"cluster",
")",
"waitLeader",
"(",
"t",
"testing",
".",
"TB",
",",
"membs",
"[",
"]",
"*",
"member",
")",
"int",
"{",
"possibleLead",
":=",
"make",
"(",
"map",
"[",
"uint64",
"]",
"bool",
")",
"\n",
"var",
"lead",
"uint64",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"membs",
"{",
"possibleLead",
"[",
"uint64",
"(",
"m",
".",
"s",
".",
"ID",
"(",
")",
")",
"]",
"=",
"true",
"\n",
"}",
"\n",
"cc",
":=",
"MustNewHTTPClient",
"(",
"t",
",",
"getMembersURLs",
"(",
"membs",
")",
",",
"nil",
")",
"\n",
"kapi",
":=",
"client",
".",
"NewKeysAPI",
"(",
"cc",
")",
"\n",
"for",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"Background",
"(",
")",
",",
"10",
"*",
"tickDuration",
"+",
"time",
".",
"Second",
")",
"\n",
"_",
",",
"err",
":=",
"kapi",
".",
"Get",
"(",
"ctx",
",",
"\"0\"",
",",
"&",
"client",
".",
"GetOptions",
"{",
"Quorum",
":",
"true",
"}",
")",
"\n",
"cancel",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"||",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"\"Key not found\"",
")",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"lead",
"==",
"0",
"||",
"!",
"possibleLead",
"[",
"lead",
"]",
"{",
"lead",
"=",
"0",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"membs",
"{",
"select",
"{",
"case",
"<-",
"m",
".",
"s",
".",
"StopNotify",
"(",
")",
":",
"continue",
"\n",
"default",
":",
"}",
"\n",
"if",
"lead",
"!=",
"0",
"&&",
"lead",
"!=",
"m",
".",
"s",
".",
"Lead",
"(",
")",
"{",
"lead",
"=",
"0",
"\n",
"time",
".",
"Sleep",
"(",
"10",
"*",
"tickDuration",
")",
"\n",
"break",
"\n",
"}",
"\n",
"lead",
"=",
"m",
".",
"s",
".",
"Lead",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"i",
",",
"m",
":=",
"range",
"membs",
"{",
"if",
"uint64",
"(",
"m",
".",
"s",
".",
"ID",
"(",
")",
")",
"==",
"lead",
"{",
"return",
"i",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"-",
"1",
"\n",
"}"
] |
// waitLeader waits until given members agree on the same leader.
|
[
"waitLeader",
"waits",
"until",
"given",
"members",
"agree",
"on",
"the",
"same",
"leader",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L427-L470
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
waitNoLeader
|
func (c *cluster) waitNoLeader(membs []*member) {
noLeader := false
for !noLeader {
noLeader = true
for _, m := range membs {
select {
case <-m.s.StopNotify():
continue
default:
}
if m.s.Lead() != 0 {
noLeader = false
time.Sleep(10 * tickDuration)
break
}
}
}
}
|
go
|
func (c *cluster) waitNoLeader(membs []*member) {
noLeader := false
for !noLeader {
noLeader = true
for _, m := range membs {
select {
case <-m.s.StopNotify():
continue
default:
}
if m.s.Lead() != 0 {
noLeader = false
time.Sleep(10 * tickDuration)
break
}
}
}
}
|
[
"func",
"(",
"c",
"*",
"cluster",
")",
"waitNoLeader",
"(",
"membs",
"[",
"]",
"*",
"member",
")",
"{",
"noLeader",
":=",
"false",
"\n",
"for",
"!",
"noLeader",
"{",
"noLeader",
"=",
"true",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"membs",
"{",
"select",
"{",
"case",
"<-",
"m",
".",
"s",
".",
"StopNotify",
"(",
")",
":",
"continue",
"\n",
"default",
":",
"}",
"\n",
"if",
"m",
".",
"s",
".",
"Lead",
"(",
")",
"!=",
"0",
"{",
"noLeader",
"=",
"false",
"\n",
"time",
".",
"Sleep",
"(",
"10",
"*",
"tickDuration",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// waitNoLeader waits until given members lose leader.
|
[
"waitNoLeader",
"waits",
"until",
"given",
"members",
"lose",
"leader",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L475-L492
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
isMembersEqual
|
func isMembersEqual(membs []client.Member, wmembs []client.Member) bool {
sort.Sort(SortableMemberSliceByPeerURLs(membs))
sort.Sort(SortableMemberSliceByPeerURLs(wmembs))
for i := range membs {
membs[i].ID = ""
}
return reflect.DeepEqual(membs, wmembs)
}
|
go
|
func isMembersEqual(membs []client.Member, wmembs []client.Member) bool {
sort.Sort(SortableMemberSliceByPeerURLs(membs))
sort.Sort(SortableMemberSliceByPeerURLs(wmembs))
for i := range membs {
membs[i].ID = ""
}
return reflect.DeepEqual(membs, wmembs)
}
|
[
"func",
"isMembersEqual",
"(",
"membs",
"[",
"]",
"client",
".",
"Member",
",",
"wmembs",
"[",
"]",
"client",
".",
"Member",
")",
"bool",
"{",
"sort",
".",
"Sort",
"(",
"SortableMemberSliceByPeerURLs",
"(",
"membs",
")",
")",
"\n",
"sort",
".",
"Sort",
"(",
"SortableMemberSliceByPeerURLs",
"(",
"wmembs",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"membs",
"{",
"membs",
"[",
"i",
"]",
".",
"ID",
"=",
"\"\"",
"\n",
"}",
"\n",
"return",
"reflect",
".",
"DeepEqual",
"(",
"membs",
",",
"wmembs",
")",
"\n",
"}"
] |
// isMembersEqual checks whether two members equal except ID field.
// The given wmembs should always set ID field to empty string.
|
[
"isMembersEqual",
"checks",
"whether",
"two",
"members",
"equal",
"except",
"ID",
"field",
".",
"The",
"given",
"wmembs",
"should",
"always",
"set",
"ID",
"field",
"to",
"empty",
"string",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L511-L518
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
listenGRPC
|
func (m *member) listenGRPC() error {
// prefix with localhost so cert has right domain
m.grpcAddr = "localhost:" + m.Name
if m.useIP { // for IP-only TLS certs
m.grpcAddr = "127.0.0.1:" + m.Name
}
l, err := transport.NewUnixListener(m.grpcAddr)
if err != nil {
return fmt.Errorf("listen failed on grpc socket %s (%v)", m.grpcAddr, err)
}
m.grpcBridge, err = newBridge(m.grpcAddr)
if err != nil {
l.Close()
return err
}
m.grpcAddr = schemeFromTLSInfo(m.ClientTLSInfo) + "://" + m.grpcBridge.inaddr
m.grpcListener = l
return nil
}
|
go
|
func (m *member) listenGRPC() error {
// prefix with localhost so cert has right domain
m.grpcAddr = "localhost:" + m.Name
if m.useIP { // for IP-only TLS certs
m.grpcAddr = "127.0.0.1:" + m.Name
}
l, err := transport.NewUnixListener(m.grpcAddr)
if err != nil {
return fmt.Errorf("listen failed on grpc socket %s (%v)", m.grpcAddr, err)
}
m.grpcBridge, err = newBridge(m.grpcAddr)
if err != nil {
l.Close()
return err
}
m.grpcAddr = schemeFromTLSInfo(m.ClientTLSInfo) + "://" + m.grpcBridge.inaddr
m.grpcListener = l
return nil
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"listenGRPC",
"(",
")",
"error",
"{",
"m",
".",
"grpcAddr",
"=",
"\"localhost:\"",
"+",
"m",
".",
"Name",
"\n",
"if",
"m",
".",
"useIP",
"{",
"m",
".",
"grpcAddr",
"=",
"\"127.0.0.1:\"",
"+",
"m",
".",
"Name",
"\n",
"}",
"\n",
"l",
",",
"err",
":=",
"transport",
".",
"NewUnixListener",
"(",
"m",
".",
"grpcAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"listen failed on grpc socket %s (%v)\"",
",",
"m",
".",
"grpcAddr",
",",
"err",
")",
"\n",
"}",
"\n",
"m",
".",
"grpcBridge",
",",
"err",
"=",
"newBridge",
"(",
"m",
".",
"grpcAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"l",
".",
"Close",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"m",
".",
"grpcAddr",
"=",
"schemeFromTLSInfo",
"(",
"m",
".",
"ClientTLSInfo",
")",
"+",
"\"://\"",
"+",
"m",
".",
"grpcBridge",
".",
"inaddr",
"\n",
"m",
".",
"grpcListener",
"=",
"l",
"\n",
"return",
"nil",
"\n",
"}"
] |
// listenGRPC starts a grpc server over a unix domain socket on the member
|
[
"listenGRPC",
"starts",
"a",
"grpc",
"server",
"over",
"a",
"unix",
"domain",
"socket",
"on",
"the",
"member"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L693-L711
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
NewClientV3
|
func NewClientV3(m *member) (*clientv3.Client, error) {
if m.grpcAddr == "" {
return nil, fmt.Errorf("member not configured for grpc")
}
cfg := clientv3.Config{
Endpoints: []string{m.grpcAddr},
DialTimeout: 5 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()},
MaxCallSendMsgSize: m.clientMaxCallSendMsgSize,
MaxCallRecvMsgSize: m.clientMaxCallRecvMsgSize,
}
if m.ClientTLSInfo != nil {
tls, err := m.ClientTLSInfo.ClientConfig()
if err != nil {
return nil, err
}
cfg.TLS = tls
}
if m.DialOptions != nil {
cfg.DialOptions = append(cfg.DialOptions, m.DialOptions...)
}
return newClientV3(cfg)
}
|
go
|
func NewClientV3(m *member) (*clientv3.Client, error) {
if m.grpcAddr == "" {
return nil, fmt.Errorf("member not configured for grpc")
}
cfg := clientv3.Config{
Endpoints: []string{m.grpcAddr},
DialTimeout: 5 * time.Second,
DialOptions: []grpc.DialOption{grpc.WithBlock()},
MaxCallSendMsgSize: m.clientMaxCallSendMsgSize,
MaxCallRecvMsgSize: m.clientMaxCallRecvMsgSize,
}
if m.ClientTLSInfo != nil {
tls, err := m.ClientTLSInfo.ClientConfig()
if err != nil {
return nil, err
}
cfg.TLS = tls
}
if m.DialOptions != nil {
cfg.DialOptions = append(cfg.DialOptions, m.DialOptions...)
}
return newClientV3(cfg)
}
|
[
"func",
"NewClientV3",
"(",
"m",
"*",
"member",
")",
"(",
"*",
"clientv3",
".",
"Client",
",",
"error",
")",
"{",
"if",
"m",
".",
"grpcAddr",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"member not configured for grpc\"",
")",
"\n",
"}",
"\n",
"cfg",
":=",
"clientv3",
".",
"Config",
"{",
"Endpoints",
":",
"[",
"]",
"string",
"{",
"m",
".",
"grpcAddr",
"}",
",",
"DialTimeout",
":",
"5",
"*",
"time",
".",
"Second",
",",
"DialOptions",
":",
"[",
"]",
"grpc",
".",
"DialOption",
"{",
"grpc",
".",
"WithBlock",
"(",
")",
"}",
",",
"MaxCallSendMsgSize",
":",
"m",
".",
"clientMaxCallSendMsgSize",
",",
"MaxCallRecvMsgSize",
":",
"m",
".",
"clientMaxCallRecvMsgSize",
",",
"}",
"\n",
"if",
"m",
".",
"ClientTLSInfo",
"!=",
"nil",
"{",
"tls",
",",
"err",
":=",
"m",
".",
"ClientTLSInfo",
".",
"ClientConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cfg",
".",
"TLS",
"=",
"tls",
"\n",
"}",
"\n",
"if",
"m",
".",
"DialOptions",
"!=",
"nil",
"{",
"cfg",
".",
"DialOptions",
"=",
"append",
"(",
"cfg",
".",
"DialOptions",
",",
"m",
".",
"DialOptions",
"...",
")",
"\n",
"}",
"\n",
"return",
"newClientV3",
"(",
"cfg",
")",
"\n",
"}"
] |
// NewClientV3 creates a new grpc client connection to the member
|
[
"NewClientV3",
"creates",
"a",
"new",
"grpc",
"client",
"connection",
"to",
"the",
"member"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L726-L750
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
Clone
|
func (m *member) Clone(t testing.TB) *member {
mm := &member{}
mm.ServerConfig = m.ServerConfig
var err error
clientURLStrs := m.ClientURLs.StringSlice()
mm.ClientURLs, err = types.NewURLs(clientURLStrs)
if err != nil {
// this should never fail
panic(err)
}
peerURLStrs := m.PeerURLs.StringSlice()
mm.PeerURLs, err = types.NewURLs(peerURLStrs)
if err != nil {
// this should never fail
panic(err)
}
clusterStr := m.InitialPeerURLsMap.String()
mm.InitialPeerURLsMap, err = types.NewURLsMap(clusterStr)
if err != nil {
// this should never fail
panic(err)
}
mm.InitialClusterToken = m.InitialClusterToken
mm.ElectionTicks = m.ElectionTicks
mm.PeerTLSInfo = m.PeerTLSInfo
mm.ClientTLSInfo = m.ClientTLSInfo
return mm
}
|
go
|
func (m *member) Clone(t testing.TB) *member {
mm := &member{}
mm.ServerConfig = m.ServerConfig
var err error
clientURLStrs := m.ClientURLs.StringSlice()
mm.ClientURLs, err = types.NewURLs(clientURLStrs)
if err != nil {
// this should never fail
panic(err)
}
peerURLStrs := m.PeerURLs.StringSlice()
mm.PeerURLs, err = types.NewURLs(peerURLStrs)
if err != nil {
// this should never fail
panic(err)
}
clusterStr := m.InitialPeerURLsMap.String()
mm.InitialPeerURLsMap, err = types.NewURLsMap(clusterStr)
if err != nil {
// this should never fail
panic(err)
}
mm.InitialClusterToken = m.InitialClusterToken
mm.ElectionTicks = m.ElectionTicks
mm.PeerTLSInfo = m.PeerTLSInfo
mm.ClientTLSInfo = m.ClientTLSInfo
return mm
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"Clone",
"(",
"t",
"testing",
".",
"TB",
")",
"*",
"member",
"{",
"mm",
":=",
"&",
"member",
"{",
"}",
"\n",
"mm",
".",
"ServerConfig",
"=",
"m",
".",
"ServerConfig",
"\n",
"var",
"err",
"error",
"\n",
"clientURLStrs",
":=",
"m",
".",
"ClientURLs",
".",
"StringSlice",
"(",
")",
"\n",
"mm",
".",
"ClientURLs",
",",
"err",
"=",
"types",
".",
"NewURLs",
"(",
"clientURLStrs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"peerURLStrs",
":=",
"m",
".",
"PeerURLs",
".",
"StringSlice",
"(",
")",
"\n",
"mm",
".",
"PeerURLs",
",",
"err",
"=",
"types",
".",
"NewURLs",
"(",
"peerURLStrs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"clusterStr",
":=",
"m",
".",
"InitialPeerURLsMap",
".",
"String",
"(",
")",
"\n",
"mm",
".",
"InitialPeerURLsMap",
",",
"err",
"=",
"types",
".",
"NewURLsMap",
"(",
"clusterStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"mm",
".",
"InitialClusterToken",
"=",
"m",
".",
"InitialClusterToken",
"\n",
"mm",
".",
"ElectionTicks",
"=",
"m",
".",
"ElectionTicks",
"\n",
"mm",
".",
"PeerTLSInfo",
"=",
"m",
".",
"PeerTLSInfo",
"\n",
"mm",
".",
"ClientTLSInfo",
"=",
"m",
".",
"ClientTLSInfo",
"\n",
"return",
"mm",
"\n",
"}"
] |
// Clone returns a member with the same server configuration. The returned
// member will not set PeerListeners and ClientListeners.
|
[
"Clone",
"returns",
"a",
"member",
"with",
"the",
"same",
"server",
"configuration",
".",
"The",
"returned",
"member",
"will",
"not",
"set",
"PeerListeners",
"and",
"ClientListeners",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L754-L782
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
Close
|
func (m *member) Close() {
if m.grpcBridge != nil {
m.grpcBridge.Close()
m.grpcBridge = nil
}
if m.serverClient != nil {
m.serverClient.Close()
m.serverClient = nil
}
if m.grpcServer != nil {
m.grpcServer.Stop()
m.grpcServer.GracefulStop()
m.grpcServer = nil
m.grpcServerPeer.Stop()
m.grpcServerPeer.GracefulStop()
m.grpcServerPeer = nil
}
m.s.HardStop()
for _, f := range m.serverClosers {
f()
}
}
|
go
|
func (m *member) Close() {
if m.grpcBridge != nil {
m.grpcBridge.Close()
m.grpcBridge = nil
}
if m.serverClient != nil {
m.serverClient.Close()
m.serverClient = nil
}
if m.grpcServer != nil {
m.grpcServer.Stop()
m.grpcServer.GracefulStop()
m.grpcServer = nil
m.grpcServerPeer.Stop()
m.grpcServerPeer.GracefulStop()
m.grpcServerPeer = nil
}
m.s.HardStop()
for _, f := range m.serverClosers {
f()
}
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"Close",
"(",
")",
"{",
"if",
"m",
".",
"grpcBridge",
"!=",
"nil",
"{",
"m",
".",
"grpcBridge",
".",
"Close",
"(",
")",
"\n",
"m",
".",
"grpcBridge",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"m",
".",
"serverClient",
"!=",
"nil",
"{",
"m",
".",
"serverClient",
".",
"Close",
"(",
")",
"\n",
"m",
".",
"serverClient",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"m",
".",
"grpcServer",
"!=",
"nil",
"{",
"m",
".",
"grpcServer",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"grpcServer",
".",
"GracefulStop",
"(",
")",
"\n",
"m",
".",
"grpcServer",
"=",
"nil",
"\n",
"m",
".",
"grpcServerPeer",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"grpcServerPeer",
".",
"GracefulStop",
"(",
")",
"\n",
"m",
".",
"grpcServerPeer",
"=",
"nil",
"\n",
"}",
"\n",
"m",
".",
"s",
".",
"HardStop",
"(",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"m",
".",
"serverClosers",
"{",
"f",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// Close stops the member's etcdserver and closes its connections
|
[
"Close",
"stops",
"the",
"member",
"s",
"etcdserver",
"and",
"closes",
"its",
"connections"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1006-L1027
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
Stop
|
func (m *member) Stop(t testing.TB) {
lg.Info(
"stopping a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
m.Close()
m.serverClosers = nil
lg.Info(
"stopped a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
}
|
go
|
func (m *member) Stop(t testing.TB) {
lg.Info(
"stopping a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
m.Close()
m.serverClosers = nil
lg.Info(
"stopped a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"Stop",
"(",
"t",
"testing",
".",
"TB",
")",
"{",
"lg",
".",
"Info",
"(",
"\"stopping a member\"",
",",
"zap",
".",
"String",
"(",
"\"name\"",
",",
"m",
".",
"Name",
")",
",",
"zap",
".",
"Strings",
"(",
"\"advertise-peer-urls\"",
",",
"m",
".",
"PeerURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"Strings",
"(",
"\"listen-client-urls\"",
",",
"m",
".",
"ClientURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"grpc-address\"",
",",
"m",
".",
"grpcAddr",
")",
",",
")",
"\n",
"m",
".",
"Close",
"(",
")",
"\n",
"m",
".",
"serverClosers",
"=",
"nil",
"\n",
"lg",
".",
"Info",
"(",
"\"stopped a member\"",
",",
"zap",
".",
"String",
"(",
"\"name\"",
",",
"m",
".",
"Name",
")",
",",
"zap",
".",
"Strings",
"(",
"\"advertise-peer-urls\"",
",",
"m",
".",
"PeerURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"Strings",
"(",
"\"listen-client-urls\"",
",",
"m",
".",
"ClientURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"grpc-address\"",
",",
"m",
".",
"grpcAddr",
")",
",",
")",
"\n",
"}"
] |
// Stop stops the member, but the data dir of the member is preserved.
|
[
"Stop",
"stops",
"the",
"member",
"but",
"the",
"data",
"dir",
"of",
"the",
"member",
"is",
"preserved",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1030-L1047
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
checkLeaderTransition
|
func checkLeaderTransition(m *member, oldLead uint64) uint64 {
interval := time.Duration(m.s.Cfg.TickMs) * time.Millisecond
for m.s.Lead() == 0 || (m.s.Lead() == oldLead) {
time.Sleep(interval)
}
return m.s.Lead()
}
|
go
|
func checkLeaderTransition(m *member, oldLead uint64) uint64 {
interval := time.Duration(m.s.Cfg.TickMs) * time.Millisecond
for m.s.Lead() == 0 || (m.s.Lead() == oldLead) {
time.Sleep(interval)
}
return m.s.Lead()
}
|
[
"func",
"checkLeaderTransition",
"(",
"m",
"*",
"member",
",",
"oldLead",
"uint64",
")",
"uint64",
"{",
"interval",
":=",
"time",
".",
"Duration",
"(",
"m",
".",
"s",
".",
"Cfg",
".",
"TickMs",
")",
"*",
"time",
".",
"Millisecond",
"\n",
"for",
"m",
".",
"s",
".",
"Lead",
"(",
")",
"==",
"0",
"||",
"(",
"m",
".",
"s",
".",
"Lead",
"(",
")",
"==",
"oldLead",
")",
"{",
"time",
".",
"Sleep",
"(",
"interval",
")",
"\n",
"}",
"\n",
"return",
"m",
".",
"s",
".",
"Lead",
"(",
")",
"\n",
"}"
] |
// checkLeaderTransition waits for leader transition, returning the new leader ID.
|
[
"checkLeaderTransition",
"waits",
"for",
"leader",
"transition",
"returning",
"the",
"new",
"leader",
"ID",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1050-L1056
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
Restart
|
func (m *member) Restart(t testing.TB) error {
lg.Info(
"restarting a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
newPeerListeners := make([]net.Listener, 0)
for _, ln := range m.PeerListeners {
newPeerListeners = append(newPeerListeners, NewListenerWithAddr(t, ln.Addr().String()))
}
m.PeerListeners = newPeerListeners
newClientListeners := make([]net.Listener, 0)
for _, ln := range m.ClientListeners {
newClientListeners = append(newClientListeners, NewListenerWithAddr(t, ln.Addr().String()))
}
m.ClientListeners = newClientListeners
if m.grpcListener != nil {
if err := m.listenGRPC(); err != nil {
t.Fatal(err)
}
}
err := m.Launch()
lg.Info(
"restarted a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
zap.Error(err),
)
return err
}
|
go
|
func (m *member) Restart(t testing.TB) error {
lg.Info(
"restarting a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
newPeerListeners := make([]net.Listener, 0)
for _, ln := range m.PeerListeners {
newPeerListeners = append(newPeerListeners, NewListenerWithAddr(t, ln.Addr().String()))
}
m.PeerListeners = newPeerListeners
newClientListeners := make([]net.Listener, 0)
for _, ln := range m.ClientListeners {
newClientListeners = append(newClientListeners, NewListenerWithAddr(t, ln.Addr().String()))
}
m.ClientListeners = newClientListeners
if m.grpcListener != nil {
if err := m.listenGRPC(); err != nil {
t.Fatal(err)
}
}
err := m.Launch()
lg.Info(
"restarted a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
zap.Error(err),
)
return err
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"Restart",
"(",
"t",
"testing",
".",
"TB",
")",
"error",
"{",
"lg",
".",
"Info",
"(",
"\"restarting a member\"",
",",
"zap",
".",
"String",
"(",
"\"name\"",
",",
"m",
".",
"Name",
")",
",",
"zap",
".",
"Strings",
"(",
"\"advertise-peer-urls\"",
",",
"m",
".",
"PeerURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"Strings",
"(",
"\"listen-client-urls\"",
",",
"m",
".",
"ClientURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"grpc-address\"",
",",
"m",
".",
"grpcAddr",
")",
",",
")",
"\n",
"newPeerListeners",
":=",
"make",
"(",
"[",
"]",
"net",
".",
"Listener",
",",
"0",
")",
"\n",
"for",
"_",
",",
"ln",
":=",
"range",
"m",
".",
"PeerListeners",
"{",
"newPeerListeners",
"=",
"append",
"(",
"newPeerListeners",
",",
"NewListenerWithAddr",
"(",
"t",
",",
"ln",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"m",
".",
"PeerListeners",
"=",
"newPeerListeners",
"\n",
"newClientListeners",
":=",
"make",
"(",
"[",
"]",
"net",
".",
"Listener",
",",
"0",
")",
"\n",
"for",
"_",
",",
"ln",
":=",
"range",
"m",
".",
"ClientListeners",
"{",
"newClientListeners",
"=",
"append",
"(",
"newClientListeners",
",",
"NewListenerWithAddr",
"(",
"t",
",",
"ln",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"m",
".",
"ClientListeners",
"=",
"newClientListeners",
"\n",
"if",
"m",
".",
"grpcListener",
"!=",
"nil",
"{",
"if",
"err",
":=",
"m",
".",
"listenGRPC",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"err",
":=",
"m",
".",
"Launch",
"(",
")",
"\n",
"lg",
".",
"Info",
"(",
"\"restarted a member\"",
",",
"zap",
".",
"String",
"(",
"\"name\"",
",",
"m",
".",
"Name",
")",
",",
"zap",
".",
"Strings",
"(",
"\"advertise-peer-urls\"",
",",
"m",
".",
"PeerURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"Strings",
"(",
"\"listen-client-urls\"",
",",
"m",
".",
"ClientURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"grpc-address\"",
",",
"m",
".",
"grpcAddr",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Restart starts the member using the preserved data dir.
|
[
"Restart",
"starts",
"the",
"member",
"using",
"the",
"preserved",
"data",
"dir",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1064-L1099
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
Terminate
|
func (m *member) Terminate(t testing.TB) {
lg.Info(
"terminating a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
m.Close()
if !m.keepDataDirTerminate {
if err := os.RemoveAll(m.ServerConfig.DataDir); err != nil {
t.Fatal(err)
}
}
lg.Info(
"terminated a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
}
|
go
|
func (m *member) Terminate(t testing.TB) {
lg.Info(
"terminating a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
m.Close()
if !m.keepDataDirTerminate {
if err := os.RemoveAll(m.ServerConfig.DataDir); err != nil {
t.Fatal(err)
}
}
lg.Info(
"terminated a member",
zap.String("name", m.Name),
zap.Strings("advertise-peer-urls", m.PeerURLs.StringSlice()),
zap.Strings("listen-client-urls", m.ClientURLs.StringSlice()),
zap.String("grpc-address", m.grpcAddr),
)
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"Terminate",
"(",
"t",
"testing",
".",
"TB",
")",
"{",
"lg",
".",
"Info",
"(",
"\"terminating a member\"",
",",
"zap",
".",
"String",
"(",
"\"name\"",
",",
"m",
".",
"Name",
")",
",",
"zap",
".",
"Strings",
"(",
"\"advertise-peer-urls\"",
",",
"m",
".",
"PeerURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"Strings",
"(",
"\"listen-client-urls\"",
",",
"m",
".",
"ClientURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"grpc-address\"",
",",
"m",
".",
"grpcAddr",
")",
",",
")",
"\n",
"m",
".",
"Close",
"(",
")",
"\n",
"if",
"!",
"m",
".",
"keepDataDirTerminate",
"{",
"if",
"err",
":=",
"os",
".",
"RemoveAll",
"(",
"m",
".",
"ServerConfig",
".",
"DataDir",
")",
";",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"lg",
".",
"Info",
"(",
"\"terminated a member\"",
",",
"zap",
".",
"String",
"(",
"\"name\"",
",",
"m",
".",
"Name",
")",
",",
"zap",
".",
"Strings",
"(",
"\"advertise-peer-urls\"",
",",
"m",
".",
"PeerURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"Strings",
"(",
"\"listen-client-urls\"",
",",
"m",
".",
"ClientURLs",
".",
"StringSlice",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"grpc-address\"",
",",
"m",
".",
"grpcAddr",
")",
",",
")",
"\n",
"}"
] |
// Terminate stops the member and removes the data dir.
|
[
"Terminate",
"stops",
"the",
"member",
"and",
"removes",
"the",
"data",
"dir",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1102-L1123
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
Metric
|
func (m *member) Metric(metricName string) (string, error) {
cfgtls := transport.TLSInfo{}
tr, err := transport.NewTimeoutTransport(cfgtls, time.Second, time.Second, time.Second)
if err != nil {
return "", err
}
cli := &http.Client{Transport: tr}
resp, err := cli.Get(m.ClientURLs[0].String() + "/metrics")
if err != nil {
return "", err
}
defer resp.Body.Close()
b, rerr := ioutil.ReadAll(resp.Body)
if rerr != nil {
return "", rerr
}
lines := strings.Split(string(b), "\n")
for _, l := range lines {
if strings.HasPrefix(l, metricName) {
return strings.Split(l, " ")[1], nil
}
}
return "", nil
}
|
go
|
func (m *member) Metric(metricName string) (string, error) {
cfgtls := transport.TLSInfo{}
tr, err := transport.NewTimeoutTransport(cfgtls, time.Second, time.Second, time.Second)
if err != nil {
return "", err
}
cli := &http.Client{Transport: tr}
resp, err := cli.Get(m.ClientURLs[0].String() + "/metrics")
if err != nil {
return "", err
}
defer resp.Body.Close()
b, rerr := ioutil.ReadAll(resp.Body)
if rerr != nil {
return "", rerr
}
lines := strings.Split(string(b), "\n")
for _, l := range lines {
if strings.HasPrefix(l, metricName) {
return strings.Split(l, " ")[1], nil
}
}
return "", nil
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"Metric",
"(",
"metricName",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"cfgtls",
":=",
"transport",
".",
"TLSInfo",
"{",
"}",
"\n",
"tr",
",",
"err",
":=",
"transport",
".",
"NewTimeoutTransport",
"(",
"cfgtls",
",",
"time",
".",
"Second",
",",
"time",
".",
"Second",
",",
"time",
".",
"Second",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"cli",
":=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"tr",
"}",
"\n",
"resp",
",",
"err",
":=",
"cli",
".",
"Get",
"(",
"m",
".",
"ClientURLs",
"[",
"0",
"]",
".",
"String",
"(",
")",
"+",
"\"/metrics\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"b",
",",
"rerr",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"rerr",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"rerr",
"\n",
"}",
"\n",
"lines",
":=",
"strings",
".",
"Split",
"(",
"string",
"(",
"b",
")",
",",
"\"\\n\"",
")",
"\n",
"\\n",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"lines",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"l",
",",
"metricName",
")",
"{",
"return",
"strings",
".",
"Split",
"(",
"l",
",",
"\" \"",
")",
"[",
"1",
"]",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Metric gets the metric value for a member
|
[
"Metric",
"gets",
"the",
"metric",
"value",
"for",
"a",
"member"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1126-L1149
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
InjectPartition
|
func (m *member) InjectPartition(t testing.TB, others ...*member) {
for _, other := range others {
m.s.CutPeer(other.s.ID())
other.s.CutPeer(m.s.ID())
}
}
|
go
|
func (m *member) InjectPartition(t testing.TB, others ...*member) {
for _, other := range others {
m.s.CutPeer(other.s.ID())
other.s.CutPeer(m.s.ID())
}
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"InjectPartition",
"(",
"t",
"testing",
".",
"TB",
",",
"others",
"...",
"*",
"member",
")",
"{",
"for",
"_",
",",
"other",
":=",
"range",
"others",
"{",
"m",
".",
"s",
".",
"CutPeer",
"(",
"other",
".",
"s",
".",
"ID",
"(",
")",
")",
"\n",
"other",
".",
"s",
".",
"CutPeer",
"(",
"m",
".",
"s",
".",
"ID",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// InjectPartition drops connections from m to others, vice versa.
|
[
"InjectPartition",
"drops",
"connections",
"from",
"m",
"to",
"others",
"vice",
"versa",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1152-L1157
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
RecoverPartition
|
func (m *member) RecoverPartition(t testing.TB, others ...*member) {
for _, other := range others {
m.s.MendPeer(other.s.ID())
other.s.MendPeer(m.s.ID())
}
}
|
go
|
func (m *member) RecoverPartition(t testing.TB, others ...*member) {
for _, other := range others {
m.s.MendPeer(other.s.ID())
other.s.MendPeer(m.s.ID())
}
}
|
[
"func",
"(",
"m",
"*",
"member",
")",
"RecoverPartition",
"(",
"t",
"testing",
".",
"TB",
",",
"others",
"...",
"*",
"member",
")",
"{",
"for",
"_",
",",
"other",
":=",
"range",
"others",
"{",
"m",
".",
"s",
".",
"MendPeer",
"(",
"other",
".",
"s",
".",
"ID",
"(",
")",
")",
"\n",
"other",
".",
"s",
".",
"MendPeer",
"(",
"m",
".",
"s",
".",
"ID",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// RecoverPartition recovers connections from m to others, vice versa.
|
[
"RecoverPartition",
"recovers",
"connections",
"from",
"m",
"to",
"others",
"vice",
"versa",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1160-L1165
|
test
|
etcd-io/etcd
|
integration/cluster.go
|
NewClusterV3
|
func NewClusterV3(t testing.TB, cfg *ClusterConfig) *ClusterV3 {
cfg.UseGRPC = true
if os.Getenv("CLIENT_DEBUG") != "" {
clientv3.SetLogger(grpclog.NewLoggerV2WithVerbosity(os.Stderr, os.Stderr, os.Stderr, 4))
}
clus := &ClusterV3{
cluster: NewClusterByConfig(t, cfg),
}
clus.Launch(t)
if !cfg.SkipCreatingClient {
for _, m := range clus.Members {
client, err := NewClientV3(m)
if err != nil {
t.Fatalf("cannot create client: %v", err)
}
clus.clients = append(clus.clients, client)
}
}
return clus
}
|
go
|
func NewClusterV3(t testing.TB, cfg *ClusterConfig) *ClusterV3 {
cfg.UseGRPC = true
if os.Getenv("CLIENT_DEBUG") != "" {
clientv3.SetLogger(grpclog.NewLoggerV2WithVerbosity(os.Stderr, os.Stderr, os.Stderr, 4))
}
clus := &ClusterV3{
cluster: NewClusterByConfig(t, cfg),
}
clus.Launch(t)
if !cfg.SkipCreatingClient {
for _, m := range clus.Members {
client, err := NewClientV3(m)
if err != nil {
t.Fatalf("cannot create client: %v", err)
}
clus.clients = append(clus.clients, client)
}
}
return clus
}
|
[
"func",
"NewClusterV3",
"(",
"t",
"testing",
".",
"TB",
",",
"cfg",
"*",
"ClusterConfig",
")",
"*",
"ClusterV3",
"{",
"cfg",
".",
"UseGRPC",
"=",
"true",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"CLIENT_DEBUG\"",
")",
"!=",
"\"\"",
"{",
"clientv3",
".",
"SetLogger",
"(",
"grpclog",
".",
"NewLoggerV2WithVerbosity",
"(",
"os",
".",
"Stderr",
",",
"os",
".",
"Stderr",
",",
"os",
".",
"Stderr",
",",
"4",
")",
")",
"\n",
"}",
"\n",
"clus",
":=",
"&",
"ClusterV3",
"{",
"cluster",
":",
"NewClusterByConfig",
"(",
"t",
",",
"cfg",
")",
",",
"}",
"\n",
"clus",
".",
"Launch",
"(",
"t",
")",
"\n",
"if",
"!",
"cfg",
".",
"SkipCreatingClient",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"clus",
".",
"Members",
"{",
"client",
",",
"err",
":=",
"NewClientV3",
"(",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Fatalf",
"(",
"\"cannot create client: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"clus",
".",
"clients",
"=",
"append",
"(",
"clus",
".",
"clients",
",",
"client",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"clus",
"\n",
"}"
] |
// NewClusterV3 returns a launched cluster with a grpc client connection
// for each cluster member.
|
[
"NewClusterV3",
"returns",
"a",
"launched",
"cluster",
"with",
"a",
"grpc",
"client",
"connection",
"for",
"each",
"cluster",
"member",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1206-L1227
|
test
|
etcd-io/etcd
|
auth/options.go
|
ParseWithDefaults
|
func (opts *jwtOptions) ParseWithDefaults(optMap map[string]string) error {
if opts.TTL == 0 && optMap[optTTL] == "" {
opts.TTL = DefaultTTL
}
return opts.Parse(optMap)
}
|
go
|
func (opts *jwtOptions) ParseWithDefaults(optMap map[string]string) error {
if opts.TTL == 0 && optMap[optTTL] == "" {
opts.TTL = DefaultTTL
}
return opts.Parse(optMap)
}
|
[
"func",
"(",
"opts",
"*",
"jwtOptions",
")",
"ParseWithDefaults",
"(",
"optMap",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"if",
"opts",
".",
"TTL",
"==",
"0",
"&&",
"optMap",
"[",
"optTTL",
"]",
"==",
"\"\"",
"{",
"opts",
".",
"TTL",
"=",
"DefaultTTL",
"\n",
"}",
"\n",
"return",
"opts",
".",
"Parse",
"(",
"optMap",
")",
"\n",
"}"
] |
// ParseWithDefaults will load options from the specified map or set defaults where appropriate
|
[
"ParseWithDefaults",
"will",
"load",
"options",
"from",
"the",
"specified",
"map",
"or",
"set",
"defaults",
"where",
"appropriate"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/auth/options.go#L54-L60
|
test
|
etcd-io/etcd
|
auth/options.go
|
Parse
|
func (opts *jwtOptions) Parse(optMap map[string]string) error {
var err error
if ttl := optMap[optTTL]; ttl != "" {
opts.TTL, err = time.ParseDuration(ttl)
if err != nil {
return err
}
}
if file := optMap[optPublicKey]; file != "" {
opts.PublicKey, err = ioutil.ReadFile(file)
if err != nil {
return err
}
}
if file := optMap[optPrivateKey]; file != "" {
opts.PrivateKey, err = ioutil.ReadFile(file)
if err != nil {
return err
}
}
// signing method is a required field
method := optMap[optSignMethod]
opts.SignMethod = jwt.GetSigningMethod(method)
if opts.SignMethod == nil {
return ErrInvalidAuthMethod
}
return nil
}
|
go
|
func (opts *jwtOptions) Parse(optMap map[string]string) error {
var err error
if ttl := optMap[optTTL]; ttl != "" {
opts.TTL, err = time.ParseDuration(ttl)
if err != nil {
return err
}
}
if file := optMap[optPublicKey]; file != "" {
opts.PublicKey, err = ioutil.ReadFile(file)
if err != nil {
return err
}
}
if file := optMap[optPrivateKey]; file != "" {
opts.PrivateKey, err = ioutil.ReadFile(file)
if err != nil {
return err
}
}
// signing method is a required field
method := optMap[optSignMethod]
opts.SignMethod = jwt.GetSigningMethod(method)
if opts.SignMethod == nil {
return ErrInvalidAuthMethod
}
return nil
}
|
[
"func",
"(",
"opts",
"*",
"jwtOptions",
")",
"Parse",
"(",
"optMap",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"ttl",
":=",
"optMap",
"[",
"optTTL",
"]",
";",
"ttl",
"!=",
"\"\"",
"{",
"opts",
".",
"TTL",
",",
"err",
"=",
"time",
".",
"ParseDuration",
"(",
"ttl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"file",
":=",
"optMap",
"[",
"optPublicKey",
"]",
";",
"file",
"!=",
"\"\"",
"{",
"opts",
".",
"PublicKey",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"file",
":=",
"optMap",
"[",
"optPrivateKey",
"]",
";",
"file",
"!=",
"\"\"",
"{",
"opts",
".",
"PrivateKey",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"method",
":=",
"optMap",
"[",
"optSignMethod",
"]",
"\n",
"opts",
".",
"SignMethod",
"=",
"jwt",
".",
"GetSigningMethod",
"(",
"method",
")",
"\n",
"if",
"opts",
".",
"SignMethod",
"==",
"nil",
"{",
"return",
"ErrInvalidAuthMethod",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Parse will load options from the specified map
|
[
"Parse",
"will",
"load",
"options",
"from",
"the",
"specified",
"map"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/auth/options.go#L63-L94
|
test
|
etcd-io/etcd
|
auth/options.go
|
Key
|
func (opts *jwtOptions) Key() (interface{}, error) {
switch opts.SignMethod.(type) {
case *jwt.SigningMethodRSA, *jwt.SigningMethodRSAPSS:
return opts.rsaKey()
case *jwt.SigningMethodECDSA:
return opts.ecKey()
case *jwt.SigningMethodHMAC:
return opts.hmacKey()
default:
return nil, fmt.Errorf("unsupported signing method: %T", opts.SignMethod)
}
}
|
go
|
func (opts *jwtOptions) Key() (interface{}, error) {
switch opts.SignMethod.(type) {
case *jwt.SigningMethodRSA, *jwt.SigningMethodRSAPSS:
return opts.rsaKey()
case *jwt.SigningMethodECDSA:
return opts.ecKey()
case *jwt.SigningMethodHMAC:
return opts.hmacKey()
default:
return nil, fmt.Errorf("unsupported signing method: %T", opts.SignMethod)
}
}
|
[
"func",
"(",
"opts",
"*",
"jwtOptions",
")",
"Key",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"switch",
"opts",
".",
"SignMethod",
".",
"(",
"type",
")",
"{",
"case",
"*",
"jwt",
".",
"SigningMethodRSA",
",",
"*",
"jwt",
".",
"SigningMethodRSAPSS",
":",
"return",
"opts",
".",
"rsaKey",
"(",
")",
"\n",
"case",
"*",
"jwt",
".",
"SigningMethodECDSA",
":",
"return",
"opts",
".",
"ecKey",
"(",
")",
"\n",
"case",
"*",
"jwt",
".",
"SigningMethodHMAC",
":",
"return",
"opts",
".",
"hmacKey",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"unsupported signing method: %T\"",
",",
"opts",
".",
"SignMethod",
")",
"\n",
"}",
"\n",
"}"
] |
// Key will parse and return the appropriately typed key for the selected signature method
|
[
"Key",
"will",
"parse",
"and",
"return",
"the",
"appropriately",
"typed",
"key",
"for",
"the",
"selected",
"signature",
"method"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/auth/options.go#L97-L108
|
test
|
etcd-io/etcd
|
etcdserver/api/v3rpc/header.go
|
fill
|
func (h *header) fill(rh *pb.ResponseHeader) {
if rh == nil {
plog.Panic("unexpected nil resp.Header")
}
rh.ClusterId = uint64(h.clusterID)
rh.MemberId = uint64(h.memberID)
rh.RaftTerm = h.sg.Term()
if rh.Revision == 0 {
rh.Revision = h.rev()
}
}
|
go
|
func (h *header) fill(rh *pb.ResponseHeader) {
if rh == nil {
plog.Panic("unexpected nil resp.Header")
}
rh.ClusterId = uint64(h.clusterID)
rh.MemberId = uint64(h.memberID)
rh.RaftTerm = h.sg.Term()
if rh.Revision == 0 {
rh.Revision = h.rev()
}
}
|
[
"func",
"(",
"h",
"*",
"header",
")",
"fill",
"(",
"rh",
"*",
"pb",
".",
"ResponseHeader",
")",
"{",
"if",
"rh",
"==",
"nil",
"{",
"plog",
".",
"Panic",
"(",
"\"unexpected nil resp.Header\"",
")",
"\n",
"}",
"\n",
"rh",
".",
"ClusterId",
"=",
"uint64",
"(",
"h",
".",
"clusterID",
")",
"\n",
"rh",
".",
"MemberId",
"=",
"uint64",
"(",
"h",
".",
"memberID",
")",
"\n",
"rh",
".",
"RaftTerm",
"=",
"h",
".",
"sg",
".",
"Term",
"(",
")",
"\n",
"if",
"rh",
".",
"Revision",
"==",
"0",
"{",
"rh",
".",
"Revision",
"=",
"h",
".",
"rev",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// fill populates pb.ResponseHeader using etcdserver information
|
[
"fill",
"populates",
"pb",
".",
"ResponseHeader",
"using",
"etcdserver",
"information"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v3rpc/header.go#L39-L49
|
test
|
etcd-io/etcd
|
proxy/grpcproxy/watch_broadcast.go
|
add
|
func (wb *watchBroadcast) add(w *watcher) bool {
wb.mu.Lock()
defer wb.mu.Unlock()
if wb.nextrev > w.nextrev || (wb.nextrev == 0 && w.nextrev != 0) {
// wb is too far ahead, w will miss events
// or wb is being established with a current watcher
return false
}
if wb.responses == 0 {
// Newly created; create event will be sent by etcd.
wb.receivers[w] = struct{}{}
return true
}
// already sent by etcd; emulate create event
ok := w.post(&pb.WatchResponse{
Header: &pb.ResponseHeader{
// todo: fill in ClusterId
// todo: fill in MemberId:
Revision: w.nextrev,
// todo: fill in RaftTerm:
},
WatchId: w.id,
Created: true,
})
if !ok {
return false
}
wb.receivers[w] = struct{}{}
watchersCoalescing.Inc()
return true
}
|
go
|
func (wb *watchBroadcast) add(w *watcher) bool {
wb.mu.Lock()
defer wb.mu.Unlock()
if wb.nextrev > w.nextrev || (wb.nextrev == 0 && w.nextrev != 0) {
// wb is too far ahead, w will miss events
// or wb is being established with a current watcher
return false
}
if wb.responses == 0 {
// Newly created; create event will be sent by etcd.
wb.receivers[w] = struct{}{}
return true
}
// already sent by etcd; emulate create event
ok := w.post(&pb.WatchResponse{
Header: &pb.ResponseHeader{
// todo: fill in ClusterId
// todo: fill in MemberId:
Revision: w.nextrev,
// todo: fill in RaftTerm:
},
WatchId: w.id,
Created: true,
})
if !ok {
return false
}
wb.receivers[w] = struct{}{}
watchersCoalescing.Inc()
return true
}
|
[
"func",
"(",
"wb",
"*",
"watchBroadcast",
")",
"add",
"(",
"w",
"*",
"watcher",
")",
"bool",
"{",
"wb",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"wb",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"wb",
".",
"nextrev",
">",
"w",
".",
"nextrev",
"||",
"(",
"wb",
".",
"nextrev",
"==",
"0",
"&&",
"w",
".",
"nextrev",
"!=",
"0",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"wb",
".",
"responses",
"==",
"0",
"{",
"wb",
".",
"receivers",
"[",
"w",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"ok",
":=",
"w",
".",
"post",
"(",
"&",
"pb",
".",
"WatchResponse",
"{",
"Header",
":",
"&",
"pb",
".",
"ResponseHeader",
"{",
"Revision",
":",
"w",
".",
"nextrev",
",",
"}",
",",
"WatchId",
":",
"w",
".",
"id",
",",
"Created",
":",
"true",
",",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"wb",
".",
"receivers",
"[",
"w",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"watchersCoalescing",
".",
"Inc",
"(",
")",
"\n",
"return",
"true",
"\n",
"}"
] |
// add puts a watcher into receiving a broadcast if its revision at least
// meets the broadcast revision. Returns true if added.
|
[
"add",
"puts",
"a",
"watcher",
"into",
"receiving",
"a",
"broadcast",
"if",
"its",
"revision",
"at",
"least",
"meets",
"the",
"broadcast",
"revision",
".",
"Returns",
"true",
"if",
"added",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/proxy/grpcproxy/watch_broadcast.go#L91-L122
|
test
|
etcd-io/etcd
|
mvcc/watcher.go
|
Watch
|
func (ws *watchStream) Watch(id WatchID, key, end []byte, startRev int64, fcs ...FilterFunc) (WatchID, error) {
// prevent wrong range where key >= end lexicographically
// watch request with 'WithFromKey' has empty-byte range end
if len(end) != 0 && bytes.Compare(key, end) != -1 {
return -1, ErrEmptyWatcherRange
}
ws.mu.Lock()
defer ws.mu.Unlock()
if ws.closed {
return -1, ErrEmptyWatcherRange
}
if id == AutoWatchID {
for ws.watchers[ws.nextID] != nil {
ws.nextID++
}
id = ws.nextID
ws.nextID++
} else if _, ok := ws.watchers[id]; ok {
return -1, ErrWatcherDuplicateID
}
w, c := ws.watchable.watch(key, end, startRev, id, ws.ch, fcs...)
ws.cancels[id] = c
ws.watchers[id] = w
return id, nil
}
|
go
|
func (ws *watchStream) Watch(id WatchID, key, end []byte, startRev int64, fcs ...FilterFunc) (WatchID, error) {
// prevent wrong range where key >= end lexicographically
// watch request with 'WithFromKey' has empty-byte range end
if len(end) != 0 && bytes.Compare(key, end) != -1 {
return -1, ErrEmptyWatcherRange
}
ws.mu.Lock()
defer ws.mu.Unlock()
if ws.closed {
return -1, ErrEmptyWatcherRange
}
if id == AutoWatchID {
for ws.watchers[ws.nextID] != nil {
ws.nextID++
}
id = ws.nextID
ws.nextID++
} else if _, ok := ws.watchers[id]; ok {
return -1, ErrWatcherDuplicateID
}
w, c := ws.watchable.watch(key, end, startRev, id, ws.ch, fcs...)
ws.cancels[id] = c
ws.watchers[id] = w
return id, nil
}
|
[
"func",
"(",
"ws",
"*",
"watchStream",
")",
"Watch",
"(",
"id",
"WatchID",
",",
"key",
",",
"end",
"[",
"]",
"byte",
",",
"startRev",
"int64",
",",
"fcs",
"...",
"FilterFunc",
")",
"(",
"WatchID",
",",
"error",
")",
"{",
"if",
"len",
"(",
"end",
")",
"!=",
"0",
"&&",
"bytes",
".",
"Compare",
"(",
"key",
",",
"end",
")",
"!=",
"-",
"1",
"{",
"return",
"-",
"1",
",",
"ErrEmptyWatcherRange",
"\n",
"}",
"\n",
"ws",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"ws",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"ws",
".",
"closed",
"{",
"return",
"-",
"1",
",",
"ErrEmptyWatcherRange",
"\n",
"}",
"\n",
"if",
"id",
"==",
"AutoWatchID",
"{",
"for",
"ws",
".",
"watchers",
"[",
"ws",
".",
"nextID",
"]",
"!=",
"nil",
"{",
"ws",
".",
"nextID",
"++",
"\n",
"}",
"\n",
"id",
"=",
"ws",
".",
"nextID",
"\n",
"ws",
".",
"nextID",
"++",
"\n",
"}",
"else",
"if",
"_",
",",
"ok",
":=",
"ws",
".",
"watchers",
"[",
"id",
"]",
";",
"ok",
"{",
"return",
"-",
"1",
",",
"ErrWatcherDuplicateID",
"\n",
"}",
"\n",
"w",
",",
"c",
":=",
"ws",
".",
"watchable",
".",
"watch",
"(",
"key",
",",
"end",
",",
"startRev",
",",
"id",
",",
"ws",
".",
"ch",
",",
"fcs",
"...",
")",
"\n",
"ws",
".",
"cancels",
"[",
"id",
"]",
"=",
"c",
"\n",
"ws",
".",
"watchers",
"[",
"id",
"]",
"=",
"w",
"\n",
"return",
"id",
",",
"nil",
"\n",
"}"
] |
// Watch creates a new watcher in the stream and returns its WatchID.
|
[
"Watch",
"creates",
"a",
"new",
"watcher",
"in",
"the",
"stream",
"and",
"returns",
"its",
"WatchID",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/watcher.go#L108-L136
|
test
|
etcd-io/etcd
|
wal/encoder.go
|
newFileEncoder
|
func newFileEncoder(f *os.File, prevCrc uint32) (*encoder, error) {
offset, err := f.Seek(0, io.SeekCurrent)
if err != nil {
return nil, err
}
return newEncoder(f, prevCrc, int(offset)), nil
}
|
go
|
func newFileEncoder(f *os.File, prevCrc uint32) (*encoder, error) {
offset, err := f.Seek(0, io.SeekCurrent)
if err != nil {
return nil, err
}
return newEncoder(f, prevCrc, int(offset)), nil
}
|
[
"func",
"newFileEncoder",
"(",
"f",
"*",
"os",
".",
"File",
",",
"prevCrc",
"uint32",
")",
"(",
"*",
"encoder",
",",
"error",
")",
"{",
"offset",
",",
"err",
":=",
"f",
".",
"Seek",
"(",
"0",
",",
"io",
".",
"SeekCurrent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"newEncoder",
"(",
"f",
",",
"prevCrc",
",",
"int",
"(",
"offset",
")",
")",
",",
"nil",
"\n",
"}"
] |
// newFileEncoder creates a new encoder with current file offset for the page writer.
|
[
"newFileEncoder",
"creates",
"a",
"new",
"encoder",
"with",
"current",
"file",
"offset",
"for",
"the",
"page",
"writer",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/wal/encoder.go#L54-L60
|
test
|
etcd-io/etcd
|
pkg/fileutil/purge.go
|
purgeFile
|
func purgeFile(lg *zap.Logger, dirname string, suffix string, max uint, interval time.Duration, stop <-chan struct{}, purgec chan<- string) <-chan error {
errC := make(chan error, 1)
go func() {
for {
fnames, err := ReadDir(dirname)
if err != nil {
errC <- err
return
}
newfnames := make([]string, 0)
for _, fname := range fnames {
if strings.HasSuffix(fname, suffix) {
newfnames = append(newfnames, fname)
}
}
sort.Strings(newfnames)
fnames = newfnames
for len(newfnames) > int(max) {
f := filepath.Join(dirname, newfnames[0])
l, err := TryLockFile(f, os.O_WRONLY, PrivateFileMode)
if err != nil {
break
}
if err = os.Remove(f); err != nil {
errC <- err
return
}
if err = l.Close(); err != nil {
if lg != nil {
lg.Warn("failed to unlock/close", zap.String("path", l.Name()), zap.Error(err))
} else {
plog.Errorf("error unlocking %s when purging file (%v)", l.Name(), err)
}
errC <- err
return
}
if lg != nil {
lg.Info("purged", zap.String("path", f))
} else {
plog.Infof("purged file %s successfully", f)
}
newfnames = newfnames[1:]
}
if purgec != nil {
for i := 0; i < len(fnames)-len(newfnames); i++ {
purgec <- fnames[i]
}
}
select {
case <-time.After(interval):
case <-stop:
return
}
}
}()
return errC
}
|
go
|
func purgeFile(lg *zap.Logger, dirname string, suffix string, max uint, interval time.Duration, stop <-chan struct{}, purgec chan<- string) <-chan error {
errC := make(chan error, 1)
go func() {
for {
fnames, err := ReadDir(dirname)
if err != nil {
errC <- err
return
}
newfnames := make([]string, 0)
for _, fname := range fnames {
if strings.HasSuffix(fname, suffix) {
newfnames = append(newfnames, fname)
}
}
sort.Strings(newfnames)
fnames = newfnames
for len(newfnames) > int(max) {
f := filepath.Join(dirname, newfnames[0])
l, err := TryLockFile(f, os.O_WRONLY, PrivateFileMode)
if err != nil {
break
}
if err = os.Remove(f); err != nil {
errC <- err
return
}
if err = l.Close(); err != nil {
if lg != nil {
lg.Warn("failed to unlock/close", zap.String("path", l.Name()), zap.Error(err))
} else {
plog.Errorf("error unlocking %s when purging file (%v)", l.Name(), err)
}
errC <- err
return
}
if lg != nil {
lg.Info("purged", zap.String("path", f))
} else {
plog.Infof("purged file %s successfully", f)
}
newfnames = newfnames[1:]
}
if purgec != nil {
for i := 0; i < len(fnames)-len(newfnames); i++ {
purgec <- fnames[i]
}
}
select {
case <-time.After(interval):
case <-stop:
return
}
}
}()
return errC
}
|
[
"func",
"purgeFile",
"(",
"lg",
"*",
"zap",
".",
"Logger",
",",
"dirname",
"string",
",",
"suffix",
"string",
",",
"max",
"uint",
",",
"interval",
"time",
".",
"Duration",
",",
"stop",
"<-",
"chan",
"struct",
"{",
"}",
",",
"purgec",
"chan",
"<-",
"string",
")",
"<-",
"chan",
"error",
"{",
"errC",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"fnames",
",",
"err",
":=",
"ReadDir",
"(",
"dirname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errC",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"newfnames",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"_",
",",
"fname",
":=",
"range",
"fnames",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"fname",
",",
"suffix",
")",
"{",
"newfnames",
"=",
"append",
"(",
"newfnames",
",",
"fname",
")",
"\n",
"}",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"newfnames",
")",
"\n",
"fnames",
"=",
"newfnames",
"\n",
"for",
"len",
"(",
"newfnames",
")",
">",
"int",
"(",
"max",
")",
"{",
"f",
":=",
"filepath",
".",
"Join",
"(",
"dirname",
",",
"newfnames",
"[",
"0",
"]",
")",
"\n",
"l",
",",
"err",
":=",
"TryLockFile",
"(",
"f",
",",
"os",
".",
"O_WRONLY",
",",
"PrivateFileMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"if",
"err",
"=",
"os",
".",
"Remove",
"(",
"f",
")",
";",
"err",
"!=",
"nil",
"{",
"errC",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"err",
"=",
"l",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"failed to unlock/close\"",
",",
"zap",
".",
"String",
"(",
"\"path\"",
",",
"l",
".",
"Name",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Errorf",
"(",
"\"error unlocking %s when purging file (%v)\"",
",",
"l",
".",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"errC",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Info",
"(",
"\"purged\"",
",",
"zap",
".",
"String",
"(",
"\"path\"",
",",
"f",
")",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Infof",
"(",
"\"purged file %s successfully\"",
",",
"f",
")",
"\n",
"}",
"\n",
"newfnames",
"=",
"newfnames",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"if",
"purgec",
"!=",
"nil",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"fnames",
")",
"-",
"len",
"(",
"newfnames",
")",
";",
"i",
"++",
"{",
"purgec",
"<-",
"fnames",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"interval",
")",
":",
"case",
"<-",
"stop",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"errC",
"\n",
"}"
] |
// purgeFile is the internal implementation for PurgeFile which can post purged files to purgec if non-nil.
|
[
"purgeFile",
"is",
"the",
"internal",
"implementation",
"for",
"PurgeFile",
"which",
"can",
"post",
"purged",
"files",
"to",
"purgec",
"if",
"non",
"-",
"nil",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/fileutil/purge.go#L32-L88
|
test
|
etcd-io/etcd
|
pkg/flags/strings.go
|
Set
|
func (ss *StringsValue) Set(s string) error {
*ss = strings.Split(s, ",")
return nil
}
|
go
|
func (ss *StringsValue) Set(s string) error {
*ss = strings.Split(s, ",")
return nil
}
|
[
"func",
"(",
"ss",
"*",
"StringsValue",
")",
"Set",
"(",
"s",
"string",
")",
"error",
"{",
"*",
"ss",
"=",
"strings",
".",
"Split",
"(",
"s",
",",
"\",\"",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Set parses a command line set of strings, separated by comma.
// Implements "flag.Value" interface.
|
[
"Set",
"parses",
"a",
"command",
"line",
"set",
"of",
"strings",
"separated",
"by",
"comma",
".",
"Implements",
"flag",
".",
"Value",
"interface",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/flags/strings.go#L28-L31
|
test
|
etcd-io/etcd
|
pkg/flags/strings.go
|
NewStringsValue
|
func NewStringsValue(s string) (ss *StringsValue) {
if s == "" {
return &StringsValue{}
}
ss = new(StringsValue)
if err := ss.Set(s); err != nil {
plog.Panicf("new StringsValue should never fail: %v", err)
}
return ss
}
|
go
|
func NewStringsValue(s string) (ss *StringsValue) {
if s == "" {
return &StringsValue{}
}
ss = new(StringsValue)
if err := ss.Set(s); err != nil {
plog.Panicf("new StringsValue should never fail: %v", err)
}
return ss
}
|
[
"func",
"NewStringsValue",
"(",
"s",
"string",
")",
"(",
"ss",
"*",
"StringsValue",
")",
"{",
"if",
"s",
"==",
"\"\"",
"{",
"return",
"&",
"StringsValue",
"{",
"}",
"\n",
"}",
"\n",
"ss",
"=",
"new",
"(",
"StringsValue",
")",
"\n",
"if",
"err",
":=",
"ss",
".",
"Set",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"plog",
".",
"Panicf",
"(",
"\"new StringsValue should never fail: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"ss",
"\n",
"}"
] |
// NewStringsValue implements string slice as "flag.Value" interface.
// Given value is to be separated by comma.
|
[
"NewStringsValue",
"implements",
"string",
"slice",
"as",
"flag",
".",
"Value",
"interface",
".",
"Given",
"value",
"is",
"to",
"be",
"separated",
"by",
"comma",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/flags/strings.go#L38-L47
|
test
|
etcd-io/etcd
|
pkg/flags/strings.go
|
StringsFromFlag
|
func StringsFromFlag(fs *flag.FlagSet, flagName string) []string {
return []string(*fs.Lookup(flagName).Value.(*StringsValue))
}
|
go
|
func StringsFromFlag(fs *flag.FlagSet, flagName string) []string {
return []string(*fs.Lookup(flagName).Value.(*StringsValue))
}
|
[
"func",
"StringsFromFlag",
"(",
"fs",
"*",
"flag",
".",
"FlagSet",
",",
"flagName",
"string",
")",
"[",
"]",
"string",
"{",
"return",
"[",
"]",
"string",
"(",
"*",
"fs",
".",
"Lookup",
"(",
"flagName",
")",
".",
"Value",
".",
"(",
"*",
"StringsValue",
")",
")",
"\n",
"}"
] |
// StringsFromFlag returns a string slice from the flag.
|
[
"StringsFromFlag",
"returns",
"a",
"string",
"slice",
"from",
"the",
"flag",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/flags/strings.go#L50-L52
|
test
|
etcd-io/etcd
|
version/version.go
|
Cluster
|
func Cluster(v string) string {
vs := strings.Split(v, ".")
if len(vs) <= 2 {
return v
}
return fmt.Sprintf("%s.%s", vs[0], vs[1])
}
|
go
|
func Cluster(v string) string {
vs := strings.Split(v, ".")
if len(vs) <= 2 {
return v
}
return fmt.Sprintf("%s.%s", vs[0], vs[1])
}
|
[
"func",
"Cluster",
"(",
"v",
"string",
")",
"string",
"{",
"vs",
":=",
"strings",
".",
"Split",
"(",
"v",
",",
"\".\"",
")",
"\n",
"if",
"len",
"(",
"vs",
")",
"<=",
"2",
"{",
"return",
"v",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%s.%s\"",
",",
"vs",
"[",
"0",
"]",
",",
"vs",
"[",
"1",
"]",
")",
"\n",
"}"
] |
// Cluster only keeps the major.minor.
|
[
"Cluster",
"only",
"keeps",
"the",
"major",
".",
"minor",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/version/version.go#L50-L56
|
test
|
etcd-io/etcd
|
pkg/ioutil/pagewriter.go
|
NewPageWriter
|
func NewPageWriter(w io.Writer, pageBytes, pageOffset int) *PageWriter {
return &PageWriter{
w: w,
pageOffset: pageOffset,
pageBytes: pageBytes,
buf: make([]byte, defaultBufferBytes+pageBytes),
bufWatermarkBytes: defaultBufferBytes,
}
}
|
go
|
func NewPageWriter(w io.Writer, pageBytes, pageOffset int) *PageWriter {
return &PageWriter{
w: w,
pageOffset: pageOffset,
pageBytes: pageBytes,
buf: make([]byte, defaultBufferBytes+pageBytes),
bufWatermarkBytes: defaultBufferBytes,
}
}
|
[
"func",
"NewPageWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"pageBytes",
",",
"pageOffset",
"int",
")",
"*",
"PageWriter",
"{",
"return",
"&",
"PageWriter",
"{",
"w",
":",
"w",
",",
"pageOffset",
":",
"pageOffset",
",",
"pageBytes",
":",
"pageBytes",
",",
"buf",
":",
"make",
"(",
"[",
"]",
"byte",
",",
"defaultBufferBytes",
"+",
"pageBytes",
")",
",",
"bufWatermarkBytes",
":",
"defaultBufferBytes",
",",
"}",
"\n",
"}"
] |
// NewPageWriter creates a new PageWriter. pageBytes is the number of bytes
// to write per page. pageOffset is the starting offset of io.Writer.
|
[
"NewPageWriter",
"creates",
"a",
"new",
"PageWriter",
".",
"pageBytes",
"is",
"the",
"number",
"of",
"bytes",
"to",
"write",
"per",
"page",
".",
"pageOffset",
"is",
"the",
"starting",
"offset",
"of",
"io",
".",
"Writer",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/ioutil/pagewriter.go#L43-L51
|
test
|
etcd-io/etcd
|
etcdserver/api/v2store/watcher_hub.go
|
watch
|
func (wh *watcherHub) watch(key string, recursive, stream bool, index, storeIndex uint64) (Watcher, *v2error.Error) {
reportWatchRequest()
event, err := wh.EventHistory.scan(key, recursive, index)
if err != nil {
err.Index = storeIndex
return nil, err
}
w := &watcher{
eventChan: make(chan *Event, 100), // use a buffered channel
recursive: recursive,
stream: stream,
sinceIndex: index,
startIndex: storeIndex,
hub: wh,
}
wh.mutex.Lock()
defer wh.mutex.Unlock()
// If the event exists in the known history, append the EtcdIndex and return immediately
if event != nil {
ne := event.Clone()
ne.EtcdIndex = storeIndex
w.eventChan <- ne
return w, nil
}
l, ok := wh.watchers[key]
var elem *list.Element
if ok { // add the new watcher to the back of the list
elem = l.PushBack(w)
} else { // create a new list and add the new watcher
l = list.New()
elem = l.PushBack(w)
wh.watchers[key] = l
}
w.remove = func() {
if w.removed { // avoid removing it twice
return
}
w.removed = true
l.Remove(elem)
atomic.AddInt64(&wh.count, -1)
reportWatcherRemoved()
if l.Len() == 0 {
delete(wh.watchers, key)
}
}
atomic.AddInt64(&wh.count, 1)
reportWatcherAdded()
return w, nil
}
|
go
|
func (wh *watcherHub) watch(key string, recursive, stream bool, index, storeIndex uint64) (Watcher, *v2error.Error) {
reportWatchRequest()
event, err := wh.EventHistory.scan(key, recursive, index)
if err != nil {
err.Index = storeIndex
return nil, err
}
w := &watcher{
eventChan: make(chan *Event, 100), // use a buffered channel
recursive: recursive,
stream: stream,
sinceIndex: index,
startIndex: storeIndex,
hub: wh,
}
wh.mutex.Lock()
defer wh.mutex.Unlock()
// If the event exists in the known history, append the EtcdIndex and return immediately
if event != nil {
ne := event.Clone()
ne.EtcdIndex = storeIndex
w.eventChan <- ne
return w, nil
}
l, ok := wh.watchers[key]
var elem *list.Element
if ok { // add the new watcher to the back of the list
elem = l.PushBack(w)
} else { // create a new list and add the new watcher
l = list.New()
elem = l.PushBack(w)
wh.watchers[key] = l
}
w.remove = func() {
if w.removed { // avoid removing it twice
return
}
w.removed = true
l.Remove(elem)
atomic.AddInt64(&wh.count, -1)
reportWatcherRemoved()
if l.Len() == 0 {
delete(wh.watchers, key)
}
}
atomic.AddInt64(&wh.count, 1)
reportWatcherAdded()
return w, nil
}
|
[
"func",
"(",
"wh",
"*",
"watcherHub",
")",
"watch",
"(",
"key",
"string",
",",
"recursive",
",",
"stream",
"bool",
",",
"index",
",",
"storeIndex",
"uint64",
")",
"(",
"Watcher",
",",
"*",
"v2error",
".",
"Error",
")",
"{",
"reportWatchRequest",
"(",
")",
"\n",
"event",
",",
"err",
":=",
"wh",
".",
"EventHistory",
".",
"scan",
"(",
"key",
",",
"recursive",
",",
"index",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
".",
"Index",
"=",
"storeIndex",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"w",
":=",
"&",
"watcher",
"{",
"eventChan",
":",
"make",
"(",
"chan",
"*",
"Event",
",",
"100",
")",
",",
"recursive",
":",
"recursive",
",",
"stream",
":",
"stream",
",",
"sinceIndex",
":",
"index",
",",
"startIndex",
":",
"storeIndex",
",",
"hub",
":",
"wh",
",",
"}",
"\n",
"wh",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"wh",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"event",
"!=",
"nil",
"{",
"ne",
":=",
"event",
".",
"Clone",
"(",
")",
"\n",
"ne",
".",
"EtcdIndex",
"=",
"storeIndex",
"\n",
"w",
".",
"eventChan",
"<-",
"ne",
"\n",
"return",
"w",
",",
"nil",
"\n",
"}",
"\n",
"l",
",",
"ok",
":=",
"wh",
".",
"watchers",
"[",
"key",
"]",
"\n",
"var",
"elem",
"*",
"list",
".",
"Element",
"\n",
"if",
"ok",
"{",
"elem",
"=",
"l",
".",
"PushBack",
"(",
"w",
")",
"\n",
"}",
"else",
"{",
"l",
"=",
"list",
".",
"New",
"(",
")",
"\n",
"elem",
"=",
"l",
".",
"PushBack",
"(",
"w",
")",
"\n",
"wh",
".",
"watchers",
"[",
"key",
"]",
"=",
"l",
"\n",
"}",
"\n",
"w",
".",
"remove",
"=",
"func",
"(",
")",
"{",
"if",
"w",
".",
"removed",
"{",
"return",
"\n",
"}",
"\n",
"w",
".",
"removed",
"=",
"true",
"\n",
"l",
".",
"Remove",
"(",
"elem",
")",
"\n",
"atomic",
".",
"AddInt64",
"(",
"&",
"wh",
".",
"count",
",",
"-",
"1",
")",
"\n",
"reportWatcherRemoved",
"(",
")",
"\n",
"if",
"l",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"delete",
"(",
"wh",
".",
"watchers",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"\n",
"atomic",
".",
"AddInt64",
"(",
"&",
"wh",
".",
"count",
",",
"1",
")",
"\n",
"reportWatcherAdded",
"(",
")",
"\n",
"return",
"w",
",",
"nil",
"\n",
"}"
] |
// Watch function returns a Watcher.
// If recursive is true, the first change after index under key will be sent to the event channel of the watcher.
// If recursive is false, the first change after index at key will be sent to the event channel of the watcher.
// If index is zero, watch will start from the current index + 1.
|
[
"Watch",
"function",
"returns",
"a",
"Watcher",
".",
"If",
"recursive",
"is",
"true",
"the",
"first",
"change",
"after",
"index",
"under",
"key",
"will",
"be",
"sent",
"to",
"the",
"event",
"channel",
"of",
"the",
"watcher",
".",
"If",
"recursive",
"is",
"false",
"the",
"first",
"change",
"after",
"index",
"at",
"key",
"will",
"be",
"sent",
"to",
"the",
"event",
"channel",
"of",
"the",
"watcher",
".",
"If",
"index",
"is",
"zero",
"watch",
"will",
"start",
"from",
"the",
"current",
"index",
"+",
"1",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v2store/watcher_hub.go#L59-L116
|
test
|
etcd-io/etcd
|
etcdserver/api/v2store/watcher_hub.go
|
notify
|
func (wh *watcherHub) notify(e *Event) {
e = wh.EventHistory.addEvent(e) // add event into the eventHistory
segments := strings.Split(e.Node.Key, "/")
currPath := "/"
// walk through all the segments of the path and notify the watchers
// if the path is "/foo/bar", it will notify watchers with path "/",
// "/foo" and "/foo/bar"
for _, segment := range segments {
currPath = path.Join(currPath, segment)
// notify the watchers who interests in the changes of current path
wh.notifyWatchers(e, currPath, false)
}
}
|
go
|
func (wh *watcherHub) notify(e *Event) {
e = wh.EventHistory.addEvent(e) // add event into the eventHistory
segments := strings.Split(e.Node.Key, "/")
currPath := "/"
// walk through all the segments of the path and notify the watchers
// if the path is "/foo/bar", it will notify watchers with path "/",
// "/foo" and "/foo/bar"
for _, segment := range segments {
currPath = path.Join(currPath, segment)
// notify the watchers who interests in the changes of current path
wh.notifyWatchers(e, currPath, false)
}
}
|
[
"func",
"(",
"wh",
"*",
"watcherHub",
")",
"notify",
"(",
"e",
"*",
"Event",
")",
"{",
"e",
"=",
"wh",
".",
"EventHistory",
".",
"addEvent",
"(",
"e",
")",
"\n",
"segments",
":=",
"strings",
".",
"Split",
"(",
"e",
".",
"Node",
".",
"Key",
",",
"\"/\"",
")",
"\n",
"currPath",
":=",
"\"/\"",
"\n",
"for",
"_",
",",
"segment",
":=",
"range",
"segments",
"{",
"currPath",
"=",
"path",
".",
"Join",
"(",
"currPath",
",",
"segment",
")",
"\n",
"wh",
".",
"notifyWatchers",
"(",
"e",
",",
"currPath",
",",
"false",
")",
"\n",
"}",
"\n",
"}"
] |
// notify function accepts an event and notify to the watchers.
|
[
"notify",
"function",
"accepts",
"an",
"event",
"and",
"notify",
"to",
"the",
"watchers",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v2store/watcher_hub.go#L123-L139
|
test
|
etcd-io/etcd
|
etcdserver/api/v2store/watcher_hub.go
|
clone
|
func (wh *watcherHub) clone() *watcherHub {
clonedHistory := wh.EventHistory.clone()
return &watcherHub{
EventHistory: clonedHistory,
}
}
|
go
|
func (wh *watcherHub) clone() *watcherHub {
clonedHistory := wh.EventHistory.clone()
return &watcherHub{
EventHistory: clonedHistory,
}
}
|
[
"func",
"(",
"wh",
"*",
"watcherHub",
")",
"clone",
"(",
")",
"*",
"watcherHub",
"{",
"clonedHistory",
":=",
"wh",
".",
"EventHistory",
".",
"clone",
"(",
")",
"\n",
"return",
"&",
"watcherHub",
"{",
"EventHistory",
":",
"clonedHistory",
",",
"}",
"\n",
"}"
] |
// clone function clones the watcherHub and return the cloned one.
// only clone the static content. do not clone the current watchers.
|
[
"clone",
"function",
"clones",
"the",
"watcherHub",
"and",
"return",
"the",
"cloned",
"one",
".",
"only",
"clone",
"the",
"static",
"content",
".",
"do",
"not",
"clone",
"the",
"current",
"watchers",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v2store/watcher_hub.go#L180-L186
|
test
|
etcd-io/etcd
|
etcdserver/api/v2store/watcher_hub.go
|
isHidden
|
func isHidden(watchPath, keyPath string) bool {
// When deleting a directory, watchPath might be deeper than the actual keyPath
// For example, when deleting /foo we also need to notify watchers on /foo/bar.
if len(watchPath) > len(keyPath) {
return false
}
// if watch path is just a "/", after path will start without "/"
// add a "/" to deal with the special case when watchPath is "/"
afterPath := path.Clean("/" + keyPath[len(watchPath):])
return strings.Contains(afterPath, "/_")
}
|
go
|
func isHidden(watchPath, keyPath string) bool {
// When deleting a directory, watchPath might be deeper than the actual keyPath
// For example, when deleting /foo we also need to notify watchers on /foo/bar.
if len(watchPath) > len(keyPath) {
return false
}
// if watch path is just a "/", after path will start without "/"
// add a "/" to deal with the special case when watchPath is "/"
afterPath := path.Clean("/" + keyPath[len(watchPath):])
return strings.Contains(afterPath, "/_")
}
|
[
"func",
"isHidden",
"(",
"watchPath",
",",
"keyPath",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"watchPath",
")",
">",
"len",
"(",
"keyPath",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"afterPath",
":=",
"path",
".",
"Clean",
"(",
"\"/\"",
"+",
"keyPath",
"[",
"len",
"(",
"watchPath",
")",
":",
"]",
")",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"afterPath",
",",
"\"/_\"",
")",
"\n",
"}"
] |
// isHidden checks to see if key path is considered hidden to watch path i.e. the
// last element is hidden or it's within a hidden directory
|
[
"isHidden",
"checks",
"to",
"see",
"if",
"key",
"path",
"is",
"considered",
"hidden",
"to",
"watch",
"path",
"i",
".",
"e",
".",
"the",
"last",
"element",
"is",
"hidden",
"or",
"it",
"s",
"within",
"a",
"hidden",
"directory"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v2store/watcher_hub.go#L190-L200
|
test
|
etcd-io/etcd
|
functional/agent/handler.go
|
createEtcdLogFile
|
func (srv *Server) createEtcdLogFile() error {
var err error
srv.etcdLogFile, err = os.Create(srv.Member.Etcd.LogOutputs[0])
if err != nil {
return err
}
srv.lg.Info("created etcd log file", zap.String("path", srv.Member.Etcd.LogOutputs[0]))
return nil
}
|
go
|
func (srv *Server) createEtcdLogFile() error {
var err error
srv.etcdLogFile, err = os.Create(srv.Member.Etcd.LogOutputs[0])
if err != nil {
return err
}
srv.lg.Info("created etcd log file", zap.String("path", srv.Member.Etcd.LogOutputs[0]))
return nil
}
|
[
"func",
"(",
"srv",
"*",
"Server",
")",
"createEtcdLogFile",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"srv",
".",
"etcdLogFile",
",",
"err",
"=",
"os",
".",
"Create",
"(",
"srv",
".",
"Member",
".",
"Etcd",
".",
"LogOutputs",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"created etcd log file\"",
",",
"zap",
".",
"String",
"(",
"\"path\"",
",",
"srv",
".",
"Member",
".",
"Etcd",
".",
"LogOutputs",
"[",
"0",
"]",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// just archive the first file
|
[
"just",
"archive",
"the",
"first",
"file"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/functional/agent/handler.go#L89-L97
|
test
|
etcd-io/etcd
|
functional/agent/handler.go
|
runEtcd
|
func (srv *Server) runEtcd() error {
errc := make(chan error)
go func() {
time.Sleep(5 * time.Second)
// server advertise client/peer listener had to start first
// before setting up proxy listener
errc <- srv.startProxy()
}()
if srv.etcdCmd != nil {
srv.lg.Info(
"starting etcd command",
zap.String("command-path", srv.etcdCmd.Path),
)
err := srv.etcdCmd.Start()
perr := <-errc
srv.lg.Info(
"started etcd command",
zap.String("command-path", srv.etcdCmd.Path),
zap.Errors("errors", []error{err, perr}),
)
if err != nil {
return err
}
return perr
}
select {
case <-srv.etcdServer.Server.ReadyNotify():
srv.lg.Info("embedded etcd is ready")
case <-time.After(time.Minute):
srv.etcdServer.Close()
return fmt.Errorf("took too long to start %v", <-srv.etcdServer.Err())
}
return <-errc
}
|
go
|
func (srv *Server) runEtcd() error {
errc := make(chan error)
go func() {
time.Sleep(5 * time.Second)
// server advertise client/peer listener had to start first
// before setting up proxy listener
errc <- srv.startProxy()
}()
if srv.etcdCmd != nil {
srv.lg.Info(
"starting etcd command",
zap.String("command-path", srv.etcdCmd.Path),
)
err := srv.etcdCmd.Start()
perr := <-errc
srv.lg.Info(
"started etcd command",
zap.String("command-path", srv.etcdCmd.Path),
zap.Errors("errors", []error{err, perr}),
)
if err != nil {
return err
}
return perr
}
select {
case <-srv.etcdServer.Server.ReadyNotify():
srv.lg.Info("embedded etcd is ready")
case <-time.After(time.Minute):
srv.etcdServer.Close()
return fmt.Errorf("took too long to start %v", <-srv.etcdServer.Err())
}
return <-errc
}
|
[
"func",
"(",
"srv",
"*",
"Server",
")",
"runEtcd",
"(",
")",
"error",
"{",
"errc",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"time",
".",
"Sleep",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"errc",
"<-",
"srv",
".",
"startProxy",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"if",
"srv",
".",
"etcdCmd",
"!=",
"nil",
"{",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"starting etcd command\"",
",",
"zap",
".",
"String",
"(",
"\"command-path\"",
",",
"srv",
".",
"etcdCmd",
".",
"Path",
")",
",",
")",
"\n",
"err",
":=",
"srv",
".",
"etcdCmd",
".",
"Start",
"(",
")",
"\n",
"perr",
":=",
"<-",
"errc",
"\n",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"started etcd command\"",
",",
"zap",
".",
"String",
"(",
"\"command-path\"",
",",
"srv",
".",
"etcdCmd",
".",
"Path",
")",
",",
"zap",
".",
"Errors",
"(",
"\"errors\"",
",",
"[",
"]",
"error",
"{",
"err",
",",
"perr",
"}",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"perr",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"srv",
".",
"etcdServer",
".",
"Server",
".",
"ReadyNotify",
"(",
")",
":",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"embedded etcd is ready\"",
")",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"time",
".",
"Minute",
")",
":",
"srv",
".",
"etcdServer",
".",
"Close",
"(",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"took too long to start %v\"",
",",
"<-",
"srv",
".",
"etcdServer",
".",
"Err",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"<-",
"errc",
"\n",
"}"
] |
// start but do not wait for it to complete
|
[
"start",
"but",
"do",
"not",
"wait",
"for",
"it",
"to",
"complete"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/functional/agent/handler.go#L140-L175
|
test
|
etcd-io/etcd
|
functional/agent/handler.go
|
stopEtcd
|
func (srv *Server) stopEtcd(sig os.Signal) error {
srv.stopProxy()
if srv.etcdCmd != nil {
srv.lg.Info(
"stopping etcd command",
zap.String("command-path", srv.etcdCmd.Path),
zap.String("signal", sig.String()),
)
err := srv.etcdCmd.Process.Signal(sig)
if err != nil {
return err
}
errc := make(chan error)
go func() {
_, ew := srv.etcdCmd.Process.Wait()
errc <- ew
close(errc)
}()
select {
case <-time.After(5 * time.Second):
srv.etcdCmd.Process.Kill()
case e := <-errc:
return e
}
err = <-errc
srv.lg.Info(
"stopped etcd command",
zap.String("command-path", srv.etcdCmd.Path),
zap.String("signal", sig.String()),
zap.Error(err),
)
return err
}
srv.lg.Info("stopping embedded etcd")
srv.etcdServer.Server.HardStop()
srv.etcdServer.Close()
srv.lg.Info("stopped embedded etcd")
return nil
}
|
go
|
func (srv *Server) stopEtcd(sig os.Signal) error {
srv.stopProxy()
if srv.etcdCmd != nil {
srv.lg.Info(
"stopping etcd command",
zap.String("command-path", srv.etcdCmd.Path),
zap.String("signal", sig.String()),
)
err := srv.etcdCmd.Process.Signal(sig)
if err != nil {
return err
}
errc := make(chan error)
go func() {
_, ew := srv.etcdCmd.Process.Wait()
errc <- ew
close(errc)
}()
select {
case <-time.After(5 * time.Second):
srv.etcdCmd.Process.Kill()
case e := <-errc:
return e
}
err = <-errc
srv.lg.Info(
"stopped etcd command",
zap.String("command-path", srv.etcdCmd.Path),
zap.String("signal", sig.String()),
zap.Error(err),
)
return err
}
srv.lg.Info("stopping embedded etcd")
srv.etcdServer.Server.HardStop()
srv.etcdServer.Close()
srv.lg.Info("stopped embedded etcd")
return nil
}
|
[
"func",
"(",
"srv",
"*",
"Server",
")",
"stopEtcd",
"(",
"sig",
"os",
".",
"Signal",
")",
"error",
"{",
"srv",
".",
"stopProxy",
"(",
")",
"\n",
"if",
"srv",
".",
"etcdCmd",
"!=",
"nil",
"{",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"stopping etcd command\"",
",",
"zap",
".",
"String",
"(",
"\"command-path\"",
",",
"srv",
".",
"etcdCmd",
".",
"Path",
")",
",",
"zap",
".",
"String",
"(",
"\"signal\"",
",",
"sig",
".",
"String",
"(",
")",
")",
",",
")",
"\n",
"err",
":=",
"srv",
".",
"etcdCmd",
".",
"Process",
".",
"Signal",
"(",
"sig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"errc",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"_",
",",
"ew",
":=",
"srv",
".",
"etcdCmd",
".",
"Process",
".",
"Wait",
"(",
")",
"\n",
"errc",
"<-",
"ew",
"\n",
"close",
"(",
"errc",
")",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"5",
"*",
"time",
".",
"Second",
")",
":",
"srv",
".",
"etcdCmd",
".",
"Process",
".",
"Kill",
"(",
")",
"\n",
"case",
"e",
":=",
"<-",
"errc",
":",
"return",
"e",
"\n",
"}",
"\n",
"err",
"=",
"<-",
"errc",
"\n",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"stopped etcd command\"",
",",
"zap",
".",
"String",
"(",
"\"command-path\"",
",",
"srv",
".",
"etcdCmd",
".",
"Path",
")",
",",
"zap",
".",
"String",
"(",
"\"signal\"",
",",
"sig",
".",
"String",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"stopping embedded etcd\"",
")",
"\n",
"srv",
".",
"etcdServer",
".",
"Server",
".",
"HardStop",
"(",
")",
"\n",
"srv",
".",
"etcdServer",
".",
"Close",
"(",
")",
"\n",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"stopped embedded etcd\"",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SIGQUIT to exit with stackstrace
|
[
"SIGQUIT",
"to",
"exit",
"with",
"stackstrace"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/functional/agent/handler.go#L178-L223
|
test
|
etcd-io/etcd
|
functional/agent/handler.go
|
handle_SIGQUIT_ETCD_AND_REMOVE_DATA_AND_STOP_AGENT
|
func (srv *Server) handle_SIGQUIT_ETCD_AND_REMOVE_DATA_AND_STOP_AGENT() (*rpcpb.Response, error) {
err := srv.stopEtcd(syscall.SIGQUIT)
if err != nil {
return nil, err
}
if srv.etcdServer != nil {
srv.etcdServer.GetLogger().Sync()
} else {
srv.etcdLogFile.Sync()
srv.etcdLogFile.Close()
}
err = os.RemoveAll(srv.Member.BaseDir)
if err != nil {
return nil, err
}
srv.lg.Info("removed base directory", zap.String("dir", srv.Member.BaseDir))
// stop agent server
srv.Stop()
return &rpcpb.Response{
Success: true,
Status: "destroyed etcd and agent",
}, nil
}
|
go
|
func (srv *Server) handle_SIGQUIT_ETCD_AND_REMOVE_DATA_AND_STOP_AGENT() (*rpcpb.Response, error) {
err := srv.stopEtcd(syscall.SIGQUIT)
if err != nil {
return nil, err
}
if srv.etcdServer != nil {
srv.etcdServer.GetLogger().Sync()
} else {
srv.etcdLogFile.Sync()
srv.etcdLogFile.Close()
}
err = os.RemoveAll(srv.Member.BaseDir)
if err != nil {
return nil, err
}
srv.lg.Info("removed base directory", zap.String("dir", srv.Member.BaseDir))
// stop agent server
srv.Stop()
return &rpcpb.Response{
Success: true,
Status: "destroyed etcd and agent",
}, nil
}
|
[
"func",
"(",
"srv",
"*",
"Server",
")",
"handle_SIGQUIT_ETCD_AND_REMOVE_DATA_AND_STOP_AGENT",
"(",
")",
"(",
"*",
"rpcpb",
".",
"Response",
",",
"error",
")",
"{",
"err",
":=",
"srv",
".",
"stopEtcd",
"(",
"syscall",
".",
"SIGQUIT",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"srv",
".",
"etcdServer",
"!=",
"nil",
"{",
"srv",
".",
"etcdServer",
".",
"GetLogger",
"(",
")",
".",
"Sync",
"(",
")",
"\n",
"}",
"else",
"{",
"srv",
".",
"etcdLogFile",
".",
"Sync",
"(",
")",
"\n",
"srv",
".",
"etcdLogFile",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"RemoveAll",
"(",
"srv",
".",
"Member",
".",
"BaseDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"srv",
".",
"lg",
".",
"Info",
"(",
"\"removed base directory\"",
",",
"zap",
".",
"String",
"(",
"\"dir\"",
",",
"srv",
".",
"Member",
".",
"BaseDir",
")",
")",
"\n",
"srv",
".",
"Stop",
"(",
")",
"\n",
"return",
"&",
"rpcpb",
".",
"Response",
"{",
"Success",
":",
"true",
",",
"Status",
":",
"\"destroyed etcd and agent\"",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// stop proxy, etcd, delete data directory
|
[
"stop",
"proxy",
"etcd",
"delete",
"data",
"directory"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/functional/agent/handler.go#L694-L720
|
test
|
etcd-io/etcd
|
pkg/transport/limit_listen.go
|
LimitListener
|
func LimitListener(l net.Listener, n int) net.Listener {
return &limitListener{l, make(chan struct{}, n)}
}
|
go
|
func LimitListener(l net.Listener, n int) net.Listener {
return &limitListener{l, make(chan struct{}, n)}
}
|
[
"func",
"LimitListener",
"(",
"l",
"net",
".",
"Listener",
",",
"n",
"int",
")",
"net",
".",
"Listener",
"{",
"return",
"&",
"limitListener",
"{",
"l",
",",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"n",
")",
"}",
"\n",
"}"
] |
// LimitListener returns a Listener that accepts at most n simultaneous
// connections from the provided Listener.
|
[
"LimitListener",
"returns",
"a",
"Listener",
"that",
"accepts",
"at",
"most",
"n",
"simultaneous",
"connections",
"from",
"the",
"provided",
"Listener",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/transport/limit_listen.go#L32-L34
|
test
|
etcd-io/etcd
|
etcdserver/api/v2http/http.go
|
allowMethod
|
func allowMethod(w http.ResponseWriter, m string, ms ...string) bool {
for _, meth := range ms {
if m == meth {
return true
}
}
w.Header().Set("Allow", strings.Join(ms, ","))
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
return false
}
|
go
|
func allowMethod(w http.ResponseWriter, m string, ms ...string) bool {
for _, meth := range ms {
if m == meth {
return true
}
}
w.Header().Set("Allow", strings.Join(ms, ","))
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
return false
}
|
[
"func",
"allowMethod",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"m",
"string",
",",
"ms",
"...",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"meth",
":=",
"range",
"ms",
"{",
"if",
"m",
"==",
"meth",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"Allow\"",
",",
"strings",
".",
"Join",
"(",
"ms",
",",
"\",\"",
")",
")",
"\n",
"http",
".",
"Error",
"(",
"w",
",",
"\"Method Not Allowed\"",
",",
"http",
".",
"StatusMethodNotAllowed",
")",
"\n",
"return",
"false",
"\n",
"}"
] |
// allowMethod verifies that the given method is one of the allowed methods,
// and if not, it writes an error to w. A boolean is returned indicating
// whether or not the method is allowed.
|
[
"allowMethod",
"verifies",
"that",
"the",
"given",
"method",
"is",
"one",
"of",
"the",
"allowed",
"methods",
"and",
"if",
"not",
"it",
"writes",
"an",
"error",
"to",
"w",
".",
"A",
"boolean",
"is",
"returned",
"indicating",
"whether",
"or",
"not",
"the",
"method",
"is",
"allowed",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v2http/http.go#L68-L77
|
test
|
etcd-io/etcd
|
etcdserver/api/v3rpc/watch.go
|
NewWatchServer
|
func NewWatchServer(s *etcdserver.EtcdServer) pb.WatchServer {
return &watchServer{
lg: s.Cfg.Logger,
clusterID: int64(s.Cluster().ID()),
memberID: int64(s.ID()),
maxRequestBytes: int(s.Cfg.MaxRequestBytes + grpcOverheadBytes),
sg: s,
watchable: s.Watchable(),
ag: s,
}
}
|
go
|
func NewWatchServer(s *etcdserver.EtcdServer) pb.WatchServer {
return &watchServer{
lg: s.Cfg.Logger,
clusterID: int64(s.Cluster().ID()),
memberID: int64(s.ID()),
maxRequestBytes: int(s.Cfg.MaxRequestBytes + grpcOverheadBytes),
sg: s,
watchable: s.Watchable(),
ag: s,
}
}
|
[
"func",
"NewWatchServer",
"(",
"s",
"*",
"etcdserver",
".",
"EtcdServer",
")",
"pb",
".",
"WatchServer",
"{",
"return",
"&",
"watchServer",
"{",
"lg",
":",
"s",
".",
"Cfg",
".",
"Logger",
",",
"clusterID",
":",
"int64",
"(",
"s",
".",
"Cluster",
"(",
")",
".",
"ID",
"(",
")",
")",
",",
"memberID",
":",
"int64",
"(",
"s",
".",
"ID",
"(",
")",
")",
",",
"maxRequestBytes",
":",
"int",
"(",
"s",
".",
"Cfg",
".",
"MaxRequestBytes",
"+",
"grpcOverheadBytes",
")",
",",
"sg",
":",
"s",
",",
"watchable",
":",
"s",
".",
"Watchable",
"(",
")",
",",
"ag",
":",
"s",
",",
"}",
"\n",
"}"
] |
// NewWatchServer returns a new watch server.
|
[
"NewWatchServer",
"returns",
"a",
"new",
"watch",
"server",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v3rpc/watch.go#L48-L61
|
test
|
etcd-io/etcd
|
etcdserver/api/v3rpc/watch.go
|
FiltersFromRequest
|
func FiltersFromRequest(creq *pb.WatchCreateRequest) []mvcc.FilterFunc {
filters := make([]mvcc.FilterFunc, 0, len(creq.Filters))
for _, ft := range creq.Filters {
switch ft {
case pb.WatchCreateRequest_NOPUT:
filters = append(filters, filterNoPut)
case pb.WatchCreateRequest_NODELETE:
filters = append(filters, filterNoDelete)
default:
}
}
return filters
}
|
go
|
func FiltersFromRequest(creq *pb.WatchCreateRequest) []mvcc.FilterFunc {
filters := make([]mvcc.FilterFunc, 0, len(creq.Filters))
for _, ft := range creq.Filters {
switch ft {
case pb.WatchCreateRequest_NOPUT:
filters = append(filters, filterNoPut)
case pb.WatchCreateRequest_NODELETE:
filters = append(filters, filterNoDelete)
default:
}
}
return filters
}
|
[
"func",
"FiltersFromRequest",
"(",
"creq",
"*",
"pb",
".",
"WatchCreateRequest",
")",
"[",
"]",
"mvcc",
".",
"FilterFunc",
"{",
"filters",
":=",
"make",
"(",
"[",
"]",
"mvcc",
".",
"FilterFunc",
",",
"0",
",",
"len",
"(",
"creq",
".",
"Filters",
")",
")",
"\n",
"for",
"_",
",",
"ft",
":=",
"range",
"creq",
".",
"Filters",
"{",
"switch",
"ft",
"{",
"case",
"pb",
".",
"WatchCreateRequest_NOPUT",
":",
"filters",
"=",
"append",
"(",
"filters",
",",
"filterNoPut",
")",
"\n",
"case",
"pb",
".",
"WatchCreateRequest_NODELETE",
":",
"filters",
"=",
"append",
"(",
"filters",
",",
"filterNoDelete",
")",
"\n",
"default",
":",
"}",
"\n",
"}",
"\n",
"return",
"filters",
"\n",
"}"
] |
// FiltersFromRequest returns "mvcc.FilterFunc" from a given watch create request.
|
[
"FiltersFromRequest",
"returns",
"mvcc",
".",
"FilterFunc",
"from",
"a",
"given",
"watch",
"create",
"request",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/v3rpc/watch.go#L572-L584
|
test
|
etcd-io/etcd
|
etcdserver/api/rafthttp/http.go
|
newPipelineHandler
|
func newPipelineHandler(t *Transport, r Raft, cid types.ID) http.Handler {
return &pipelineHandler{
lg: t.Logger,
localID: t.ID,
tr: t,
r: r,
cid: cid,
}
}
|
go
|
func newPipelineHandler(t *Transport, r Raft, cid types.ID) http.Handler {
return &pipelineHandler{
lg: t.Logger,
localID: t.ID,
tr: t,
r: r,
cid: cid,
}
}
|
[
"func",
"newPipelineHandler",
"(",
"t",
"*",
"Transport",
",",
"r",
"Raft",
",",
"cid",
"types",
".",
"ID",
")",
"http",
".",
"Handler",
"{",
"return",
"&",
"pipelineHandler",
"{",
"lg",
":",
"t",
".",
"Logger",
",",
"localID",
":",
"t",
".",
"ID",
",",
"tr",
":",
"t",
",",
"r",
":",
"r",
",",
"cid",
":",
"cid",
",",
"}",
"\n",
"}"
] |
// newPipelineHandler returns a handler for handling raft messages
// from pipeline for RaftPrefix.
//
// The handler reads out the raft message from request body,
// and forwards it to the given raft state machine for processing.
|
[
"newPipelineHandler",
"returns",
"a",
"handler",
"for",
"handling",
"raft",
"messages",
"from",
"pipeline",
"for",
"RaftPrefix",
".",
"The",
"handler",
"reads",
"out",
"the",
"raft",
"message",
"from",
"request",
"body",
"and",
"forwards",
"it",
"to",
"the",
"given",
"raft",
"state",
"machine",
"for",
"processing",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/rafthttp/http.go#L78-L86
|
test
|
etcd-io/etcd
|
etcdserver/api/rafthttp/http.go
|
checkClusterCompatibilityFromHeader
|
func checkClusterCompatibilityFromHeader(lg *zap.Logger, localID types.ID, header http.Header, cid types.ID) error {
remoteName := header.Get("X-Server-From")
remoteServer := serverVersion(header)
remoteVs := ""
if remoteServer != nil {
remoteVs = remoteServer.String()
}
remoteMinClusterVer := minClusterVersion(header)
remoteMinClusterVs := ""
if remoteMinClusterVer != nil {
remoteMinClusterVs = remoteMinClusterVer.String()
}
localServer, localMinCluster, err := checkVersionCompatibility(remoteName, remoteServer, remoteMinClusterVer)
localVs := ""
if localServer != nil {
localVs = localServer.String()
}
localMinClusterVs := ""
if localMinCluster != nil {
localMinClusterVs = localMinCluster.String()
}
if err != nil {
if lg != nil {
lg.Warn(
"failed to check version compatibility",
zap.String("local-member-id", localID.String()),
zap.String("local-member-cluster-id", cid.String()),
zap.String("local-member-server-version", localVs),
zap.String("local-member-server-minimum-cluster-version", localMinClusterVs),
zap.String("remote-peer-server-name", remoteName),
zap.String("remote-peer-server-version", remoteVs),
zap.String("remote-peer-server-minimum-cluster-version", remoteMinClusterVs),
zap.Error(err),
)
} else {
plog.Errorf("request version incompatibility (%v)", err)
}
return errIncompatibleVersion
}
if gcid := header.Get("X-Etcd-Cluster-ID"); gcid != cid.String() {
if lg != nil {
lg.Warn(
"request cluster ID mismatch",
zap.String("local-member-id", localID.String()),
zap.String("local-member-cluster-id", cid.String()),
zap.String("local-member-server-version", localVs),
zap.String("local-member-server-minimum-cluster-version", localMinClusterVs),
zap.String("remote-peer-server-name", remoteName),
zap.String("remote-peer-server-version", remoteVs),
zap.String("remote-peer-server-minimum-cluster-version", remoteMinClusterVs),
zap.String("remote-peer-cluster-id", gcid),
)
} else {
plog.Errorf("request cluster ID mismatch (got %s want %s)", gcid, cid)
}
return errClusterIDMismatch
}
return nil
}
|
go
|
func checkClusterCompatibilityFromHeader(lg *zap.Logger, localID types.ID, header http.Header, cid types.ID) error {
remoteName := header.Get("X-Server-From")
remoteServer := serverVersion(header)
remoteVs := ""
if remoteServer != nil {
remoteVs = remoteServer.String()
}
remoteMinClusterVer := minClusterVersion(header)
remoteMinClusterVs := ""
if remoteMinClusterVer != nil {
remoteMinClusterVs = remoteMinClusterVer.String()
}
localServer, localMinCluster, err := checkVersionCompatibility(remoteName, remoteServer, remoteMinClusterVer)
localVs := ""
if localServer != nil {
localVs = localServer.String()
}
localMinClusterVs := ""
if localMinCluster != nil {
localMinClusterVs = localMinCluster.String()
}
if err != nil {
if lg != nil {
lg.Warn(
"failed to check version compatibility",
zap.String("local-member-id", localID.String()),
zap.String("local-member-cluster-id", cid.String()),
zap.String("local-member-server-version", localVs),
zap.String("local-member-server-minimum-cluster-version", localMinClusterVs),
zap.String("remote-peer-server-name", remoteName),
zap.String("remote-peer-server-version", remoteVs),
zap.String("remote-peer-server-minimum-cluster-version", remoteMinClusterVs),
zap.Error(err),
)
} else {
plog.Errorf("request version incompatibility (%v)", err)
}
return errIncompatibleVersion
}
if gcid := header.Get("X-Etcd-Cluster-ID"); gcid != cid.String() {
if lg != nil {
lg.Warn(
"request cluster ID mismatch",
zap.String("local-member-id", localID.String()),
zap.String("local-member-cluster-id", cid.String()),
zap.String("local-member-server-version", localVs),
zap.String("local-member-server-minimum-cluster-version", localMinClusterVs),
zap.String("remote-peer-server-name", remoteName),
zap.String("remote-peer-server-version", remoteVs),
zap.String("remote-peer-server-minimum-cluster-version", remoteMinClusterVs),
zap.String("remote-peer-cluster-id", gcid),
)
} else {
plog.Errorf("request cluster ID mismatch (got %s want %s)", gcid, cid)
}
return errClusterIDMismatch
}
return nil
}
|
[
"func",
"checkClusterCompatibilityFromHeader",
"(",
"lg",
"*",
"zap",
".",
"Logger",
",",
"localID",
"types",
".",
"ID",
",",
"header",
"http",
".",
"Header",
",",
"cid",
"types",
".",
"ID",
")",
"error",
"{",
"remoteName",
":=",
"header",
".",
"Get",
"(",
"\"X-Server-From\"",
")",
"\n",
"remoteServer",
":=",
"serverVersion",
"(",
"header",
")",
"\n",
"remoteVs",
":=",
"\"\"",
"\n",
"if",
"remoteServer",
"!=",
"nil",
"{",
"remoteVs",
"=",
"remoteServer",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"remoteMinClusterVer",
":=",
"minClusterVersion",
"(",
"header",
")",
"\n",
"remoteMinClusterVs",
":=",
"\"\"",
"\n",
"if",
"remoteMinClusterVer",
"!=",
"nil",
"{",
"remoteMinClusterVs",
"=",
"remoteMinClusterVer",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"localServer",
",",
"localMinCluster",
",",
"err",
":=",
"checkVersionCompatibility",
"(",
"remoteName",
",",
"remoteServer",
",",
"remoteMinClusterVer",
")",
"\n",
"localVs",
":=",
"\"\"",
"\n",
"if",
"localServer",
"!=",
"nil",
"{",
"localVs",
"=",
"localServer",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"localMinClusterVs",
":=",
"\"\"",
"\n",
"if",
"localMinCluster",
"!=",
"nil",
"{",
"localMinClusterVs",
"=",
"localMinCluster",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"failed to check version compatibility\"",
",",
"zap",
".",
"String",
"(",
"\"local-member-id\"",
",",
"localID",
".",
"String",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"local-member-cluster-id\"",
",",
"cid",
".",
"String",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"local-member-server-version\"",
",",
"localVs",
")",
",",
"zap",
".",
"String",
"(",
"\"local-member-server-minimum-cluster-version\"",
",",
"localMinClusterVs",
")",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-server-name\"",
",",
"remoteName",
")",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-server-version\"",
",",
"remoteVs",
")",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-server-minimum-cluster-version\"",
",",
"remoteMinClusterVs",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Errorf",
"(",
"\"request version incompatibility (%v)\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"errIncompatibleVersion",
"\n",
"}",
"\n",
"if",
"gcid",
":=",
"header",
".",
"Get",
"(",
"\"X-Etcd-Cluster-ID\"",
")",
";",
"gcid",
"!=",
"cid",
".",
"String",
"(",
")",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"request cluster ID mismatch\"",
",",
"zap",
".",
"String",
"(",
"\"local-member-id\"",
",",
"localID",
".",
"String",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"local-member-cluster-id\"",
",",
"cid",
".",
"String",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"local-member-server-version\"",
",",
"localVs",
")",
",",
"zap",
".",
"String",
"(",
"\"local-member-server-minimum-cluster-version\"",
",",
"localMinClusterVs",
")",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-server-name\"",
",",
"remoteName",
")",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-server-version\"",
",",
"remoteVs",
")",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-server-minimum-cluster-version\"",
",",
"remoteMinClusterVs",
")",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-cluster-id\"",
",",
"gcid",
")",
",",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Errorf",
"(",
"\"request cluster ID mismatch (got %s want %s)\"",
",",
"gcid",
",",
"cid",
")",
"\n",
"}",
"\n",
"return",
"errClusterIDMismatch",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// checkClusterCompatibilityFromHeader checks the cluster compatibility of
// the local member from the given header.
// It checks whether the version of local member is compatible with
// the versions in the header, and whether the cluster ID of local member
// matches the one in the header.
|
[
"checkClusterCompatibilityFromHeader",
"checks",
"the",
"cluster",
"compatibility",
"of",
"the",
"local",
"member",
"from",
"the",
"given",
"header",
".",
"It",
"checks",
"whether",
"the",
"version",
"of",
"local",
"member",
"is",
"compatible",
"with",
"the",
"versions",
"in",
"the",
"header",
"and",
"whether",
"the",
"cluster",
"ID",
"of",
"local",
"member",
"matches",
"the",
"one",
"in",
"the",
"header",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/rafthttp/http.go#L492-L555
|
test
|
etcd-io/etcd
|
clientv3/clientv3util/util.go
|
KeyExists
|
func KeyExists(key string) clientv3.Cmp {
return clientv3.Compare(clientv3.Version(key), ">", 0)
}
|
go
|
func KeyExists(key string) clientv3.Cmp {
return clientv3.Compare(clientv3.Version(key), ">", 0)
}
|
[
"func",
"KeyExists",
"(",
"key",
"string",
")",
"clientv3",
".",
"Cmp",
"{",
"return",
"clientv3",
".",
"Compare",
"(",
"clientv3",
".",
"Version",
"(",
"key",
")",
",",
"\">\"",
",",
"0",
")",
"\n",
"}"
] |
// KeyExists returns a comparison operation that evaluates to true iff the given
// key exists. It does this by checking if the key `Version` is greater than 0.
// It is a useful guard in transaction delete operations.
|
[
"KeyExists",
"returns",
"a",
"comparison",
"operation",
"that",
"evaluates",
"to",
"true",
"iff",
"the",
"given",
"key",
"exists",
".",
"It",
"does",
"this",
"by",
"checking",
"if",
"the",
"key",
"Version",
"is",
"greater",
"than",
"0",
".",
"It",
"is",
"a",
"useful",
"guard",
"in",
"transaction",
"delete",
"operations",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/clientv3/clientv3util/util.go#L25-L27
|
test
|
etcd-io/etcd
|
clientv3/clientv3util/util.go
|
KeyMissing
|
func KeyMissing(key string) clientv3.Cmp {
return clientv3.Compare(clientv3.Version(key), "=", 0)
}
|
go
|
func KeyMissing(key string) clientv3.Cmp {
return clientv3.Compare(clientv3.Version(key), "=", 0)
}
|
[
"func",
"KeyMissing",
"(",
"key",
"string",
")",
"clientv3",
".",
"Cmp",
"{",
"return",
"clientv3",
".",
"Compare",
"(",
"clientv3",
".",
"Version",
"(",
"key",
")",
",",
"\"=\"",
",",
"0",
")",
"\n",
"}"
] |
// KeyMissing returns a comparison operation that evaluates to true iff the
// given key does not exist.
|
[
"KeyMissing",
"returns",
"a",
"comparison",
"operation",
"that",
"evaluates",
"to",
"true",
"iff",
"the",
"given",
"key",
"does",
"not",
"exist",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/clientv3/clientv3util/util.go#L31-L33
|
test
|
etcd-io/etcd
|
pkg/transport/tls.go
|
ValidateSecureEndpoints
|
func ValidateSecureEndpoints(tlsInfo TLSInfo, eps []string) ([]string, error) {
t, err := NewTransport(tlsInfo, 5*time.Second)
if err != nil {
return nil, err
}
var errs []string
var endpoints []string
for _, ep := range eps {
if !strings.HasPrefix(ep, "https://") {
errs = append(errs, fmt.Sprintf("%q is insecure", ep))
continue
}
conn, cerr := t.Dial("tcp", ep[len("https://"):])
if cerr != nil {
errs = append(errs, fmt.Sprintf("%q failed to dial (%v)", ep, cerr))
continue
}
conn.Close()
endpoints = append(endpoints, ep)
}
if len(errs) != 0 {
err = fmt.Errorf("%s", strings.Join(errs, ","))
}
return endpoints, err
}
|
go
|
func ValidateSecureEndpoints(tlsInfo TLSInfo, eps []string) ([]string, error) {
t, err := NewTransport(tlsInfo, 5*time.Second)
if err != nil {
return nil, err
}
var errs []string
var endpoints []string
for _, ep := range eps {
if !strings.HasPrefix(ep, "https://") {
errs = append(errs, fmt.Sprintf("%q is insecure", ep))
continue
}
conn, cerr := t.Dial("tcp", ep[len("https://"):])
if cerr != nil {
errs = append(errs, fmt.Sprintf("%q failed to dial (%v)", ep, cerr))
continue
}
conn.Close()
endpoints = append(endpoints, ep)
}
if len(errs) != 0 {
err = fmt.Errorf("%s", strings.Join(errs, ","))
}
return endpoints, err
}
|
[
"func",
"ValidateSecureEndpoints",
"(",
"tlsInfo",
"TLSInfo",
",",
"eps",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"t",
",",
"err",
":=",
"NewTransport",
"(",
"tlsInfo",
",",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"errs",
"[",
"]",
"string",
"\n",
"var",
"endpoints",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"ep",
":=",
"range",
"eps",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"ep",
",",
"\"https://\"",
")",
"{",
"errs",
"=",
"append",
"(",
"errs",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%q is insecure\"",
",",
"ep",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"conn",
",",
"cerr",
":=",
"t",
".",
"Dial",
"(",
"\"tcp\"",
",",
"ep",
"[",
"len",
"(",
"\"https://\"",
")",
":",
"]",
")",
"\n",
"if",
"cerr",
"!=",
"nil",
"{",
"errs",
"=",
"append",
"(",
"errs",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%q failed to dial (%v)\"",
",",
"ep",
",",
"cerr",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"conn",
".",
"Close",
"(",
")",
"\n",
"endpoints",
"=",
"append",
"(",
"endpoints",
",",
"ep",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"errs",
")",
"!=",
"0",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"%s\"",
",",
"strings",
".",
"Join",
"(",
"errs",
",",
"\",\"",
")",
")",
"\n",
"}",
"\n",
"return",
"endpoints",
",",
"err",
"\n",
"}"
] |
// ValidateSecureEndpoints scans the given endpoints against tls info, returning only those
// endpoints that could be validated as secure.
|
[
"ValidateSecureEndpoints",
"scans",
"the",
"given",
"endpoints",
"against",
"tls",
"info",
"returning",
"only",
"those",
"endpoints",
"that",
"could",
"be",
"validated",
"as",
"secure",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/transport/tls.go#L25-L49
|
test
|
etcd-io/etcd
|
contrib/recipes/key.go
|
putNewKV
|
func putNewKV(kv v3.KV, key, val string, leaseID v3.LeaseID) (int64, error) {
cmp := v3.Compare(v3.Version(key), "=", 0)
req := v3.OpPut(key, val, v3.WithLease(leaseID))
txnresp, err := kv.Txn(context.TODO()).If(cmp).Then(req).Commit()
if err != nil {
return 0, err
}
if !txnresp.Succeeded {
return 0, ErrKeyExists
}
return txnresp.Header.Revision, nil
}
|
go
|
func putNewKV(kv v3.KV, key, val string, leaseID v3.LeaseID) (int64, error) {
cmp := v3.Compare(v3.Version(key), "=", 0)
req := v3.OpPut(key, val, v3.WithLease(leaseID))
txnresp, err := kv.Txn(context.TODO()).If(cmp).Then(req).Commit()
if err != nil {
return 0, err
}
if !txnresp.Succeeded {
return 0, ErrKeyExists
}
return txnresp.Header.Revision, nil
}
|
[
"func",
"putNewKV",
"(",
"kv",
"v3",
".",
"KV",
",",
"key",
",",
"val",
"string",
",",
"leaseID",
"v3",
".",
"LeaseID",
")",
"(",
"int64",
",",
"error",
")",
"{",
"cmp",
":=",
"v3",
".",
"Compare",
"(",
"v3",
".",
"Version",
"(",
"key",
")",
",",
"\"=\"",
",",
"0",
")",
"\n",
"req",
":=",
"v3",
".",
"OpPut",
"(",
"key",
",",
"val",
",",
"v3",
".",
"WithLease",
"(",
"leaseID",
")",
")",
"\n",
"txnresp",
",",
"err",
":=",
"kv",
".",
"Txn",
"(",
"context",
".",
"TODO",
"(",
")",
")",
".",
"If",
"(",
"cmp",
")",
".",
"Then",
"(",
"req",
")",
".",
"Commit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"txnresp",
".",
"Succeeded",
"{",
"return",
"0",
",",
"ErrKeyExists",
"\n",
"}",
"\n",
"return",
"txnresp",
".",
"Header",
".",
"Revision",
",",
"nil",
"\n",
"}"
] |
// putNewKV attempts to create the given key, only succeeding if the key did
// not yet exist.
|
[
"putNewKV",
"attempts",
"to",
"create",
"the",
"given",
"key",
"only",
"succeeding",
"if",
"the",
"key",
"did",
"not",
"yet",
"exist",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/contrib/recipes/key.go#L62-L73
|
test
|
etcd-io/etcd
|
contrib/recipes/key.go
|
newUniqueEphemeralKey
|
func newUniqueEphemeralKey(s *concurrency.Session, prefix string) (*EphemeralKV, error) {
return newUniqueEphemeralKV(s, prefix, "")
}
|
go
|
func newUniqueEphemeralKey(s *concurrency.Session, prefix string) (*EphemeralKV, error) {
return newUniqueEphemeralKV(s, prefix, "")
}
|
[
"func",
"newUniqueEphemeralKey",
"(",
"s",
"*",
"concurrency",
".",
"Session",
",",
"prefix",
"string",
")",
"(",
"*",
"EphemeralKV",
",",
"error",
")",
"{",
"return",
"newUniqueEphemeralKV",
"(",
"s",
",",
"prefix",
",",
"\"\"",
")",
"\n",
"}"
] |
// newUniqueEphemeralKey creates a new unique valueless key associated with a session lease
|
[
"newUniqueEphemeralKey",
"creates",
"a",
"new",
"unique",
"valueless",
"key",
"associated",
"with",
"a",
"session",
"lease"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/contrib/recipes/key.go#L149-L151
|
test
|
etcd-io/etcd
|
etcdctl/ctlv2/command/update_dir_command.go
|
NewUpdateDirCommand
|
func NewUpdateDirCommand() cli.Command {
return cli.Command{
Name: "updatedir",
Usage: "update an existing directory",
ArgsUsage: "<key> <value>",
Flags: []cli.Flag{
cli.IntFlag{Name: "ttl", Value: 0, Usage: "key time-to-live in seconds"},
},
Action: func(c *cli.Context) error {
updatedirCommandFunc(c, mustNewKeyAPI(c))
return nil
},
}
}
|
go
|
func NewUpdateDirCommand() cli.Command {
return cli.Command{
Name: "updatedir",
Usage: "update an existing directory",
ArgsUsage: "<key> <value>",
Flags: []cli.Flag{
cli.IntFlag{Name: "ttl", Value: 0, Usage: "key time-to-live in seconds"},
},
Action: func(c *cli.Context) error {
updatedirCommandFunc(c, mustNewKeyAPI(c))
return nil
},
}
}
|
[
"func",
"NewUpdateDirCommand",
"(",
")",
"cli",
".",
"Command",
"{",
"return",
"cli",
".",
"Command",
"{",
"Name",
":",
"\"updatedir\"",
",",
"Usage",
":",
"\"update an existing directory\"",
",",
"ArgsUsage",
":",
"\"<key> <value>\"",
",",
"Flags",
":",
"[",
"]",
"cli",
".",
"Flag",
"{",
"cli",
".",
"IntFlag",
"{",
"Name",
":",
"\"ttl\"",
",",
"Value",
":",
"0",
",",
"Usage",
":",
"\"key time-to-live in seconds\"",
"}",
",",
"}",
",",
"Action",
":",
"func",
"(",
"c",
"*",
"cli",
".",
"Context",
")",
"error",
"{",
"updatedirCommandFunc",
"(",
"c",
",",
"mustNewKeyAPI",
"(",
"c",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
",",
"}",
"\n",
"}"
] |
// NewUpdateDirCommand returns the CLI command for "updatedir".
|
[
"NewUpdateDirCommand",
"returns",
"the",
"CLI",
"command",
"for",
"updatedir",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv2/command/update_dir_command.go#L26-L39
|
test
|
etcd-io/etcd
|
etcdctl/ctlv2/command/update_dir_command.go
|
updatedirCommandFunc
|
func updatedirCommandFunc(c *cli.Context, ki client.KeysAPI) {
if len(c.Args()) == 0 {
handleError(c, ExitBadArgs, errors.New("key required"))
}
key := c.Args()[0]
ttl := c.Int("ttl")
ctx, cancel := contextWithTotalTimeout(c)
resp, err := ki.Set(ctx, key, "", &client.SetOptions{TTL: time.Duration(ttl) * time.Second, Dir: true, PrevExist: client.PrevExist})
cancel()
if err != nil {
handleError(c, ExitServerError, err)
}
if c.GlobalString("output") != "simple" {
printResponseKey(resp, c.GlobalString("output"))
}
}
|
go
|
func updatedirCommandFunc(c *cli.Context, ki client.KeysAPI) {
if len(c.Args()) == 0 {
handleError(c, ExitBadArgs, errors.New("key required"))
}
key := c.Args()[0]
ttl := c.Int("ttl")
ctx, cancel := contextWithTotalTimeout(c)
resp, err := ki.Set(ctx, key, "", &client.SetOptions{TTL: time.Duration(ttl) * time.Second, Dir: true, PrevExist: client.PrevExist})
cancel()
if err != nil {
handleError(c, ExitServerError, err)
}
if c.GlobalString("output") != "simple" {
printResponseKey(resp, c.GlobalString("output"))
}
}
|
[
"func",
"updatedirCommandFunc",
"(",
"c",
"*",
"cli",
".",
"Context",
",",
"ki",
"client",
".",
"KeysAPI",
")",
"{",
"if",
"len",
"(",
"c",
".",
"Args",
"(",
")",
")",
"==",
"0",
"{",
"handleError",
"(",
"c",
",",
"ExitBadArgs",
",",
"errors",
".",
"New",
"(",
"\"key required\"",
")",
")",
"\n",
"}",
"\n",
"key",
":=",
"c",
".",
"Args",
"(",
")",
"[",
"0",
"]",
"\n",
"ttl",
":=",
"c",
".",
"Int",
"(",
"\"ttl\"",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"contextWithTotalTimeout",
"(",
"c",
")",
"\n",
"resp",
",",
"err",
":=",
"ki",
".",
"Set",
"(",
"ctx",
",",
"key",
",",
"\"\"",
",",
"&",
"client",
".",
"SetOptions",
"{",
"TTL",
":",
"time",
".",
"Duration",
"(",
"ttl",
")",
"*",
"time",
".",
"Second",
",",
"Dir",
":",
"true",
",",
"PrevExist",
":",
"client",
".",
"PrevExist",
"}",
")",
"\n",
"cancel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"handleError",
"(",
"c",
",",
"ExitServerError",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"GlobalString",
"(",
"\"output\"",
")",
"!=",
"\"simple\"",
"{",
"printResponseKey",
"(",
"resp",
",",
"c",
".",
"GlobalString",
"(",
"\"output\"",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// updatedirCommandFunc executes the "updatedir" command.
|
[
"updatedirCommandFunc",
"executes",
"the",
"updatedir",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv2/command/update_dir_command.go#L42-L57
|
test
|
etcd-io/etcd
|
etcdctl/ctlv2/command/backup_command.go
|
handleBackup
|
func handleBackup(c *cli.Context) error {
var srcWAL string
var destWAL string
withV3 := c.Bool("with-v3")
srcSnap := filepath.Join(c.String("data-dir"), "member", "snap")
destSnap := filepath.Join(c.String("backup-dir"), "member", "snap")
if c.String("wal-dir") != "" {
srcWAL = c.String("wal-dir")
} else {
srcWAL = filepath.Join(c.String("data-dir"), "member", "wal")
}
if c.String("backup-wal-dir") != "" {
destWAL = c.String("backup-wal-dir")
} else {
destWAL = filepath.Join(c.String("backup-dir"), "member", "wal")
}
if err := fileutil.CreateDirAll(destSnap); err != nil {
log.Fatalf("failed creating backup snapshot dir %v: %v", destSnap, err)
}
walsnap := saveSnap(destSnap, srcSnap)
metadata, state, ents := loadWAL(srcWAL, walsnap, withV3)
saveDB(filepath.Join(destSnap, "db"), filepath.Join(srcSnap, "db"), state.Commit, withV3)
idgen := idutil.NewGenerator(0, time.Now())
metadata.NodeID = idgen.Next()
metadata.ClusterID = idgen.Next()
neww, err := wal.Create(zap.NewExample(), destWAL, pbutil.MustMarshal(&metadata))
if err != nil {
log.Fatal(err)
}
defer neww.Close()
if err := neww.Save(state, ents); err != nil {
log.Fatal(err)
}
if err := neww.SaveSnapshot(walsnap); err != nil {
log.Fatal(err)
}
return nil
}
|
go
|
func handleBackup(c *cli.Context) error {
var srcWAL string
var destWAL string
withV3 := c.Bool("with-v3")
srcSnap := filepath.Join(c.String("data-dir"), "member", "snap")
destSnap := filepath.Join(c.String("backup-dir"), "member", "snap")
if c.String("wal-dir") != "" {
srcWAL = c.String("wal-dir")
} else {
srcWAL = filepath.Join(c.String("data-dir"), "member", "wal")
}
if c.String("backup-wal-dir") != "" {
destWAL = c.String("backup-wal-dir")
} else {
destWAL = filepath.Join(c.String("backup-dir"), "member", "wal")
}
if err := fileutil.CreateDirAll(destSnap); err != nil {
log.Fatalf("failed creating backup snapshot dir %v: %v", destSnap, err)
}
walsnap := saveSnap(destSnap, srcSnap)
metadata, state, ents := loadWAL(srcWAL, walsnap, withV3)
saveDB(filepath.Join(destSnap, "db"), filepath.Join(srcSnap, "db"), state.Commit, withV3)
idgen := idutil.NewGenerator(0, time.Now())
metadata.NodeID = idgen.Next()
metadata.ClusterID = idgen.Next()
neww, err := wal.Create(zap.NewExample(), destWAL, pbutil.MustMarshal(&metadata))
if err != nil {
log.Fatal(err)
}
defer neww.Close()
if err := neww.Save(state, ents); err != nil {
log.Fatal(err)
}
if err := neww.SaveSnapshot(walsnap); err != nil {
log.Fatal(err)
}
return nil
}
|
[
"func",
"handleBackup",
"(",
"c",
"*",
"cli",
".",
"Context",
")",
"error",
"{",
"var",
"srcWAL",
"string",
"\n",
"var",
"destWAL",
"string",
"\n",
"withV3",
":=",
"c",
".",
"Bool",
"(",
"\"with-v3\"",
")",
"\n",
"srcSnap",
":=",
"filepath",
".",
"Join",
"(",
"c",
".",
"String",
"(",
"\"data-dir\"",
")",
",",
"\"member\"",
",",
"\"snap\"",
")",
"\n",
"destSnap",
":=",
"filepath",
".",
"Join",
"(",
"c",
".",
"String",
"(",
"\"backup-dir\"",
")",
",",
"\"member\"",
",",
"\"snap\"",
")",
"\n",
"if",
"c",
".",
"String",
"(",
"\"wal-dir\"",
")",
"!=",
"\"\"",
"{",
"srcWAL",
"=",
"c",
".",
"String",
"(",
"\"wal-dir\"",
")",
"\n",
"}",
"else",
"{",
"srcWAL",
"=",
"filepath",
".",
"Join",
"(",
"c",
".",
"String",
"(",
"\"data-dir\"",
")",
",",
"\"member\"",
",",
"\"wal\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"String",
"(",
"\"backup-wal-dir\"",
")",
"!=",
"\"\"",
"{",
"destWAL",
"=",
"c",
".",
"String",
"(",
"\"backup-wal-dir\"",
")",
"\n",
"}",
"else",
"{",
"destWAL",
"=",
"filepath",
".",
"Join",
"(",
"c",
".",
"String",
"(",
"\"backup-dir\"",
")",
",",
"\"member\"",
",",
"\"wal\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"fileutil",
".",
"CreateDirAll",
"(",
"destSnap",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"failed creating backup snapshot dir %v: %v\"",
",",
"destSnap",
",",
"err",
")",
"\n",
"}",
"\n",
"walsnap",
":=",
"saveSnap",
"(",
"destSnap",
",",
"srcSnap",
")",
"\n",
"metadata",
",",
"state",
",",
"ents",
":=",
"loadWAL",
"(",
"srcWAL",
",",
"walsnap",
",",
"withV3",
")",
"\n",
"saveDB",
"(",
"filepath",
".",
"Join",
"(",
"destSnap",
",",
"\"db\"",
")",
",",
"filepath",
".",
"Join",
"(",
"srcSnap",
",",
"\"db\"",
")",
",",
"state",
".",
"Commit",
",",
"withV3",
")",
"\n",
"idgen",
":=",
"idutil",
".",
"NewGenerator",
"(",
"0",
",",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"metadata",
".",
"NodeID",
"=",
"idgen",
".",
"Next",
"(",
")",
"\n",
"metadata",
".",
"ClusterID",
"=",
"idgen",
".",
"Next",
"(",
")",
"\n",
"neww",
",",
"err",
":=",
"wal",
".",
"Create",
"(",
"zap",
".",
"NewExample",
"(",
")",
",",
"destWAL",
",",
"pbutil",
".",
"MustMarshal",
"(",
"&",
"metadata",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"neww",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
":=",
"neww",
".",
"Save",
"(",
"state",
",",
"ents",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"neww",
".",
"SaveSnapshot",
"(",
"walsnap",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// handleBackup handles a request that intends to do a backup.
|
[
"handleBackup",
"handles",
"a",
"request",
"that",
"intends",
"to",
"do",
"a",
"backup",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv2/command/backup_command.go#L58-L103
|
test
|
etcd-io/etcd
|
etcdctl/ctlv2/command/backup_command.go
|
saveDB
|
func saveDB(destDB, srcDB string, idx uint64, v3 bool) {
// open src db to safely copy db state
if v3 {
var src *bolt.DB
ch := make(chan *bolt.DB, 1)
go func() {
db, err := bolt.Open(srcDB, 0444, &bolt.Options{ReadOnly: true})
if err != nil {
log.Fatal(err)
}
ch <- db
}()
select {
case src = <-ch:
case <-time.After(time.Second):
log.Println("waiting to acquire lock on", srcDB)
src = <-ch
}
defer src.Close()
tx, err := src.Begin(false)
if err != nil {
log.Fatal(err)
}
// copy srcDB to destDB
dest, err := os.Create(destDB)
if err != nil {
log.Fatal(err)
}
if _, err := tx.WriteTo(dest); err != nil {
log.Fatal(err)
}
dest.Close()
if err := tx.Rollback(); err != nil {
log.Fatal(err)
}
}
db, err := bolt.Open(destDB, 0644, &bolt.Options{})
if err != nil {
log.Fatal(err)
}
tx, err := db.Begin(true)
if err != nil {
log.Fatal(err)
}
// remove membership information; should be clobbered by --force-new-cluster
for _, bucket := range []string{"members", "members_removed", "cluster"} {
tx.DeleteBucket([]byte(bucket))
}
// update consistent index to match hard state
if !v3 {
idxBytes := make([]byte, 8)
binary.BigEndian.PutUint64(idxBytes, idx)
b, err := tx.CreateBucketIfNotExists([]byte("meta"))
if err != nil {
log.Fatal(err)
}
b.Put([]byte("consistent_index"), idxBytes)
}
if err := tx.Commit(); err != nil {
log.Fatal(err)
}
if err := db.Close(); err != nil {
log.Fatal(err)
}
}
|
go
|
func saveDB(destDB, srcDB string, idx uint64, v3 bool) {
// open src db to safely copy db state
if v3 {
var src *bolt.DB
ch := make(chan *bolt.DB, 1)
go func() {
db, err := bolt.Open(srcDB, 0444, &bolt.Options{ReadOnly: true})
if err != nil {
log.Fatal(err)
}
ch <- db
}()
select {
case src = <-ch:
case <-time.After(time.Second):
log.Println("waiting to acquire lock on", srcDB)
src = <-ch
}
defer src.Close()
tx, err := src.Begin(false)
if err != nil {
log.Fatal(err)
}
// copy srcDB to destDB
dest, err := os.Create(destDB)
if err != nil {
log.Fatal(err)
}
if _, err := tx.WriteTo(dest); err != nil {
log.Fatal(err)
}
dest.Close()
if err := tx.Rollback(); err != nil {
log.Fatal(err)
}
}
db, err := bolt.Open(destDB, 0644, &bolt.Options{})
if err != nil {
log.Fatal(err)
}
tx, err := db.Begin(true)
if err != nil {
log.Fatal(err)
}
// remove membership information; should be clobbered by --force-new-cluster
for _, bucket := range []string{"members", "members_removed", "cluster"} {
tx.DeleteBucket([]byte(bucket))
}
// update consistent index to match hard state
if !v3 {
idxBytes := make([]byte, 8)
binary.BigEndian.PutUint64(idxBytes, idx)
b, err := tx.CreateBucketIfNotExists([]byte("meta"))
if err != nil {
log.Fatal(err)
}
b.Put([]byte("consistent_index"), idxBytes)
}
if err := tx.Commit(); err != nil {
log.Fatal(err)
}
if err := db.Close(); err != nil {
log.Fatal(err)
}
}
|
[
"func",
"saveDB",
"(",
"destDB",
",",
"srcDB",
"string",
",",
"idx",
"uint64",
",",
"v3",
"bool",
")",
"{",
"if",
"v3",
"{",
"var",
"src",
"*",
"bolt",
".",
"DB",
"\n",
"ch",
":=",
"make",
"(",
"chan",
"*",
"bolt",
".",
"DB",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"db",
",",
"err",
":=",
"bolt",
".",
"Open",
"(",
"srcDB",
",",
"0444",
",",
"&",
"bolt",
".",
"Options",
"{",
"ReadOnly",
":",
"true",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"ch",
"<-",
"db",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"src",
"=",
"<-",
"ch",
":",
"case",
"<-",
"time",
".",
"After",
"(",
"time",
".",
"Second",
")",
":",
"log",
".",
"Println",
"(",
"\"waiting to acquire lock on\"",
",",
"srcDB",
")",
"\n",
"src",
"=",
"<-",
"ch",
"\n",
"}",
"\n",
"defer",
"src",
".",
"Close",
"(",
")",
"\n",
"tx",
",",
"err",
":=",
"src",
".",
"Begin",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"dest",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"destDB",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"tx",
".",
"WriteTo",
"(",
"dest",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"dest",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
":=",
"tx",
".",
"Rollback",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"db",
",",
"err",
":=",
"bolt",
".",
"Open",
"(",
"destDB",
",",
"0644",
",",
"&",
"bolt",
".",
"Options",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"tx",
",",
"err",
":=",
"db",
".",
"Begin",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"bucket",
":=",
"range",
"[",
"]",
"string",
"{",
"\"members\"",
",",
"\"members_removed\"",
",",
"\"cluster\"",
"}",
"{",
"tx",
".",
"DeleteBucket",
"(",
"[",
"]",
"byte",
"(",
"bucket",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"v3",
"{",
"idxBytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"idxBytes",
",",
"idx",
")",
"\n",
"b",
",",
"err",
":=",
"tx",
".",
"CreateBucketIfNotExists",
"(",
"[",
"]",
"byte",
"(",
"\"meta\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"b",
".",
"Put",
"(",
"[",
"]",
"byte",
"(",
"\"consistent_index\"",
")",
",",
"idxBytes",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"tx",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"db",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// saveDB copies the v3 backend and strips cluster information.
|
[
"saveDB",
"copies",
"the",
"v3",
"backend",
"and",
"strips",
"cluster",
"information",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv2/command/backup_command.go#L187-L257
|
test
|
etcd-io/etcd
|
functional/runner/watch_command.go
|
NewWatchCommand
|
func NewWatchCommand() *cobra.Command {
cmd := &cobra.Command{
Use: "watcher",
Short: "Performs watch operation",
Run: runWatcherFunc,
}
cmd.Flags().DurationVar(&runningTime, "running-time", 60, "number of seconds to run")
cmd.Flags().StringVar(&watchPrefix, "prefix", "", "the prefix to append on all keys")
cmd.Flags().IntVar(&noOfPrefixes, "total-prefixes", 10, "total no of prefixes to use")
cmd.Flags().IntVar(&watchPerPrefix, "watch-per-prefix", 10, "number of watchers per prefix")
cmd.Flags().IntVar(&totalKeys, "total-keys", 1000, "total number of keys to watch")
return cmd
}
|
go
|
func NewWatchCommand() *cobra.Command {
cmd := &cobra.Command{
Use: "watcher",
Short: "Performs watch operation",
Run: runWatcherFunc,
}
cmd.Flags().DurationVar(&runningTime, "running-time", 60, "number of seconds to run")
cmd.Flags().StringVar(&watchPrefix, "prefix", "", "the prefix to append on all keys")
cmd.Flags().IntVar(&noOfPrefixes, "total-prefixes", 10, "total no of prefixes to use")
cmd.Flags().IntVar(&watchPerPrefix, "watch-per-prefix", 10, "number of watchers per prefix")
cmd.Flags().IntVar(&totalKeys, "total-keys", 1000, "total number of keys to watch")
return cmd
}
|
[
"func",
"NewWatchCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"watcher\"",
",",
"Short",
":",
"\"Performs watch operation\"",
",",
"Run",
":",
"runWatcherFunc",
",",
"}",
"\n",
"cmd",
".",
"Flags",
"(",
")",
".",
"DurationVar",
"(",
"&",
"runningTime",
",",
"\"running-time\"",
",",
"60",
",",
"\"number of seconds to run\"",
")",
"\n",
"cmd",
".",
"Flags",
"(",
")",
".",
"StringVar",
"(",
"&",
"watchPrefix",
",",
"\"prefix\"",
",",
"\"\"",
",",
"\"the prefix to append on all keys\"",
")",
"\n",
"cmd",
".",
"Flags",
"(",
")",
".",
"IntVar",
"(",
"&",
"noOfPrefixes",
",",
"\"total-prefixes\"",
",",
"10",
",",
"\"total no of prefixes to use\"",
")",
"\n",
"cmd",
".",
"Flags",
"(",
")",
".",
"IntVar",
"(",
"&",
"watchPerPrefix",
",",
"\"watch-per-prefix\"",
",",
"10",
",",
"\"number of watchers per prefix\"",
")",
"\n",
"cmd",
".",
"Flags",
"(",
")",
".",
"IntVar",
"(",
"&",
"totalKeys",
",",
"\"total-keys\"",
",",
"1000",
",",
"\"total number of keys to watch\"",
")",
"\n",
"return",
"cmd",
"\n",
"}"
] |
// NewWatchCommand returns the cobra command for "watcher runner".
|
[
"NewWatchCommand",
"returns",
"the",
"cobra",
"command",
"for",
"watcher",
"runner",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/functional/runner/watch_command.go#L41-L54
|
test
|
etcd-io/etcd
|
clientv3/snapshot/v3_snapshot.go
|
NewV3
|
func NewV3(lg *zap.Logger) Manager {
if lg == nil {
lg = zap.NewExample()
}
return &v3Manager{lg: lg}
}
|
go
|
func NewV3(lg *zap.Logger) Manager {
if lg == nil {
lg = zap.NewExample()
}
return &v3Manager{lg: lg}
}
|
[
"func",
"NewV3",
"(",
"lg",
"*",
"zap",
".",
"Logger",
")",
"Manager",
"{",
"if",
"lg",
"==",
"nil",
"{",
"lg",
"=",
"zap",
".",
"NewExample",
"(",
")",
"\n",
"}",
"\n",
"return",
"&",
"v3Manager",
"{",
"lg",
":",
"lg",
"}",
"\n",
"}"
] |
// NewV3 returns a new snapshot Manager for v3.x snapshot.
|
[
"NewV3",
"returns",
"a",
"new",
"snapshot",
"Manager",
"for",
"v3",
".",
"x",
"snapshot",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/clientv3/snapshot/v3_snapshot.go#L72-L77
|
test
|
etcd-io/etcd
|
clientv3/snapshot/v3_snapshot.go
|
Save
|
func (s *v3Manager) Save(ctx context.Context, cfg clientv3.Config, dbPath string) error {
if len(cfg.Endpoints) != 1 {
return fmt.Errorf("snapshot must be requested to one selected node, not multiple %v", cfg.Endpoints)
}
cli, err := clientv3.New(cfg)
if err != nil {
return err
}
defer cli.Close()
partpath := dbPath + ".part"
defer os.RemoveAll(partpath)
var f *os.File
f, err = os.OpenFile(partpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fileutil.PrivateFileMode)
if err != nil {
return fmt.Errorf("could not open %s (%v)", partpath, err)
}
s.lg.Info(
"created temporary db file",
zap.String("path", partpath),
)
now := time.Now()
var rd io.ReadCloser
rd, err = cli.Snapshot(ctx)
if err != nil {
return err
}
s.lg.Info(
"fetching snapshot",
zap.String("endpoint", cfg.Endpoints[0]),
)
if _, err = io.Copy(f, rd); err != nil {
return err
}
if err = fileutil.Fsync(f); err != nil {
return err
}
if err = f.Close(); err != nil {
return err
}
s.lg.Info(
"fetched snapshot",
zap.String("endpoint", cfg.Endpoints[0]),
zap.Duration("took", time.Since(now)),
)
if err = os.Rename(partpath, dbPath); err != nil {
return fmt.Errorf("could not rename %s to %s (%v)", partpath, dbPath, err)
}
s.lg.Info("saved", zap.String("path", dbPath))
return nil
}
|
go
|
func (s *v3Manager) Save(ctx context.Context, cfg clientv3.Config, dbPath string) error {
if len(cfg.Endpoints) != 1 {
return fmt.Errorf("snapshot must be requested to one selected node, not multiple %v", cfg.Endpoints)
}
cli, err := clientv3.New(cfg)
if err != nil {
return err
}
defer cli.Close()
partpath := dbPath + ".part"
defer os.RemoveAll(partpath)
var f *os.File
f, err = os.OpenFile(partpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fileutil.PrivateFileMode)
if err != nil {
return fmt.Errorf("could not open %s (%v)", partpath, err)
}
s.lg.Info(
"created temporary db file",
zap.String("path", partpath),
)
now := time.Now()
var rd io.ReadCloser
rd, err = cli.Snapshot(ctx)
if err != nil {
return err
}
s.lg.Info(
"fetching snapshot",
zap.String("endpoint", cfg.Endpoints[0]),
)
if _, err = io.Copy(f, rd); err != nil {
return err
}
if err = fileutil.Fsync(f); err != nil {
return err
}
if err = f.Close(); err != nil {
return err
}
s.lg.Info(
"fetched snapshot",
zap.String("endpoint", cfg.Endpoints[0]),
zap.Duration("took", time.Since(now)),
)
if err = os.Rename(partpath, dbPath); err != nil {
return fmt.Errorf("could not rename %s to %s (%v)", partpath, dbPath, err)
}
s.lg.Info("saved", zap.String("path", dbPath))
return nil
}
|
[
"func",
"(",
"s",
"*",
"v3Manager",
")",
"Save",
"(",
"ctx",
"context",
".",
"Context",
",",
"cfg",
"clientv3",
".",
"Config",
",",
"dbPath",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"cfg",
".",
"Endpoints",
")",
"!=",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"snapshot must be requested to one selected node, not multiple %v\"",
",",
"cfg",
".",
"Endpoints",
")",
"\n",
"}",
"\n",
"cli",
",",
"err",
":=",
"clientv3",
".",
"New",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"cli",
".",
"Close",
"(",
")",
"\n",
"partpath",
":=",
"dbPath",
"+",
"\".part\"",
"\n",
"defer",
"os",
".",
"RemoveAll",
"(",
"partpath",
")",
"\n",
"var",
"f",
"*",
"os",
".",
"File",
"\n",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"partpath",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_TRUNC",
",",
"fileutil",
".",
"PrivateFileMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not open %s (%v)\"",
",",
"partpath",
",",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"lg",
".",
"Info",
"(",
"\"created temporary db file\"",
",",
"zap",
".",
"String",
"(",
"\"path\"",
",",
"partpath",
")",
",",
")",
"\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"var",
"rd",
"io",
".",
"ReadCloser",
"\n",
"rd",
",",
"err",
"=",
"cli",
".",
"Snapshot",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"lg",
".",
"Info",
"(",
"\"fetching snapshot\"",
",",
"zap",
".",
"String",
"(",
"\"endpoint\"",
",",
"cfg",
".",
"Endpoints",
"[",
"0",
"]",
")",
",",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"f",
",",
"rd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"fileutil",
".",
"Fsync",
"(",
"f",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"f",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"lg",
".",
"Info",
"(",
"\"fetched snapshot\"",
",",
"zap",
".",
"String",
"(",
"\"endpoint\"",
",",
"cfg",
".",
"Endpoints",
"[",
"0",
"]",
")",
",",
"zap",
".",
"Duration",
"(",
"\"took\"",
",",
"time",
".",
"Since",
"(",
"now",
")",
")",
",",
")",
"\n",
"if",
"err",
"=",
"os",
".",
"Rename",
"(",
"partpath",
",",
"dbPath",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"could not rename %s to %s (%v)\"",
",",
"partpath",
",",
"dbPath",
",",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"lg",
".",
"Info",
"(",
"\"saved\"",
",",
"zap",
".",
"String",
"(",
"\"path\"",
",",
"dbPath",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Save fetches snapshot from remote etcd server and saves data to target path.
|
[
"Save",
"fetches",
"snapshot",
"from",
"remote",
"etcd",
"server",
"and",
"saves",
"data",
"to",
"target",
"path",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/clientv3/snapshot/v3_snapshot.go#L92-L145
|
test
|
etcd-io/etcd
|
clientv3/snapshot/v3_snapshot.go
|
Status
|
func (s *v3Manager) Status(dbPath string) (ds Status, err error) {
if _, err = os.Stat(dbPath); err != nil {
return ds, err
}
db, err := bolt.Open(dbPath, 0400, &bolt.Options{ReadOnly: true})
if err != nil {
return ds, err
}
defer db.Close()
h := crc32.New(crc32.MakeTable(crc32.Castagnoli))
if err = db.View(func(tx *bolt.Tx) error {
// check snapshot file integrity first
var dbErrStrings []string
for dbErr := range tx.Check() {
dbErrStrings = append(dbErrStrings, dbErr.Error())
}
if len(dbErrStrings) > 0 {
return fmt.Errorf("snapshot file integrity check failed. %d errors found.\n"+strings.Join(dbErrStrings, "\n"), len(dbErrStrings))
}
ds.TotalSize = tx.Size()
c := tx.Cursor()
for next, _ := c.First(); next != nil; next, _ = c.Next() {
b := tx.Bucket(next)
if b == nil {
return fmt.Errorf("cannot get hash of bucket %s", string(next))
}
h.Write(next)
iskeyb := (string(next) == "key")
b.ForEach(func(k, v []byte) error {
h.Write(k)
h.Write(v)
if iskeyb {
rev := bytesToRev(k)
ds.Revision = rev.main
}
ds.TotalKey++
return nil
})
}
return nil
}); err != nil {
return ds, err
}
ds.Hash = h.Sum32()
return ds, nil
}
|
go
|
func (s *v3Manager) Status(dbPath string) (ds Status, err error) {
if _, err = os.Stat(dbPath); err != nil {
return ds, err
}
db, err := bolt.Open(dbPath, 0400, &bolt.Options{ReadOnly: true})
if err != nil {
return ds, err
}
defer db.Close()
h := crc32.New(crc32.MakeTable(crc32.Castagnoli))
if err = db.View(func(tx *bolt.Tx) error {
// check snapshot file integrity first
var dbErrStrings []string
for dbErr := range tx.Check() {
dbErrStrings = append(dbErrStrings, dbErr.Error())
}
if len(dbErrStrings) > 0 {
return fmt.Errorf("snapshot file integrity check failed. %d errors found.\n"+strings.Join(dbErrStrings, "\n"), len(dbErrStrings))
}
ds.TotalSize = tx.Size()
c := tx.Cursor()
for next, _ := c.First(); next != nil; next, _ = c.Next() {
b := tx.Bucket(next)
if b == nil {
return fmt.Errorf("cannot get hash of bucket %s", string(next))
}
h.Write(next)
iskeyb := (string(next) == "key")
b.ForEach(func(k, v []byte) error {
h.Write(k)
h.Write(v)
if iskeyb {
rev := bytesToRev(k)
ds.Revision = rev.main
}
ds.TotalKey++
return nil
})
}
return nil
}); err != nil {
return ds, err
}
ds.Hash = h.Sum32()
return ds, nil
}
|
[
"func",
"(",
"s",
"*",
"v3Manager",
")",
"Status",
"(",
"dbPath",
"string",
")",
"(",
"ds",
"Status",
",",
"err",
"error",
")",
"{",
"if",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"dbPath",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ds",
",",
"err",
"\n",
"}",
"\n",
"db",
",",
"err",
":=",
"bolt",
".",
"Open",
"(",
"dbPath",
",",
"0400",
",",
"&",
"bolt",
".",
"Options",
"{",
"ReadOnly",
":",
"true",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ds",
",",
"err",
"\n",
"}",
"\n",
"defer",
"db",
".",
"Close",
"(",
")",
"\n",
"h",
":=",
"crc32",
".",
"New",
"(",
"crc32",
".",
"MakeTable",
"(",
"crc32",
".",
"Castagnoli",
")",
")",
"\n",
"if",
"err",
"=",
"db",
".",
"View",
"(",
"func",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
")",
"error",
"{",
"var",
"dbErrStrings",
"[",
"]",
"string",
"\n",
"for",
"dbErr",
":=",
"range",
"tx",
".",
"Check",
"(",
")",
"{",
"dbErrStrings",
"=",
"append",
"(",
"dbErrStrings",
",",
"dbErr",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"dbErrStrings",
")",
">",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"snapshot file integrity check failed. %d errors found.\\n\"",
"+",
"\\n",
",",
"strings",
".",
"Join",
"(",
"dbErrStrings",
",",
"\"\\n\"",
")",
")",
"\n",
"}",
"\n",
"\\n",
"\n",
"len",
"(",
"dbErrStrings",
")",
"\n",
"ds",
".",
"TotalSize",
"=",
"tx",
".",
"Size",
"(",
")",
"\n",
"c",
":=",
"tx",
".",
"Cursor",
"(",
")",
"\n",
"}",
")",
";",
"for",
"next",
",",
"_",
":=",
"c",
".",
"First",
"(",
")",
";",
"next",
"!=",
"nil",
";",
"next",
",",
"_",
"=",
"c",
".",
"Next",
"(",
")",
"{",
"b",
":=",
"tx",
".",
"Bucket",
"(",
"next",
")",
"\n",
"if",
"b",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"cannot get hash of bucket %s\"",
",",
"string",
"(",
"next",
")",
")",
"\n",
"}",
"\n",
"h",
".",
"Write",
"(",
"next",
")",
"\n",
"iskeyb",
":=",
"(",
"string",
"(",
"next",
")",
"==",
"\"key\"",
")",
"\n",
"b",
".",
"ForEach",
"(",
"func",
"(",
"k",
",",
"v",
"[",
"]",
"byte",
")",
"error",
"{",
"h",
".",
"Write",
"(",
"k",
")",
"\n",
"h",
".",
"Write",
"(",
"v",
")",
"\n",
"if",
"iskeyb",
"{",
"rev",
":=",
"bytesToRev",
"(",
"k",
")",
"\n",
"ds",
".",
"Revision",
"=",
"rev",
".",
"main",
"\n",
"}",
"\n",
"ds",
".",
"TotalKey",
"++",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"}",
"return",
"nil",
"\n",
"err",
"!=",
"nil",
"\n",
"{",
"return",
"ds",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// Status returns the snapshot file information.
|
[
"Status",
"returns",
"the",
"snapshot",
"file",
"information",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/clientv3/snapshot/v3_snapshot.go#L156-L205
|
test
|
etcd-io/etcd
|
clientv3/snapshot/v3_snapshot.go
|
Restore
|
func (s *v3Manager) Restore(cfg RestoreConfig) error {
pURLs, err := types.NewURLs(cfg.PeerURLs)
if err != nil {
return err
}
var ics types.URLsMap
ics, err = types.NewURLsMap(cfg.InitialCluster)
if err != nil {
return err
}
srv := etcdserver.ServerConfig{
Logger: s.lg,
Name: cfg.Name,
PeerURLs: pURLs,
InitialPeerURLsMap: ics,
InitialClusterToken: cfg.InitialClusterToken,
}
if err = srv.VerifyBootstrap(); err != nil {
return err
}
s.cl, err = membership.NewClusterFromURLsMap(s.lg, cfg.InitialClusterToken, ics)
if err != nil {
return err
}
dataDir := cfg.OutputDataDir
if dataDir == "" {
dataDir = cfg.Name + ".etcd"
}
if fileutil.Exist(dataDir) {
return fmt.Errorf("data-dir %q exists", dataDir)
}
walDir := cfg.OutputWALDir
if walDir == "" {
walDir = filepath.Join(dataDir, "member", "wal")
} else if fileutil.Exist(walDir) {
return fmt.Errorf("wal-dir %q exists", walDir)
}
s.name = cfg.Name
s.dbPath = cfg.SnapshotPath
s.walDir = walDir
s.snapDir = filepath.Join(dataDir, "member", "snap")
s.skipHashCheck = cfg.SkipHashCheck
s.lg.Info(
"restoring snapshot",
zap.String("path", s.dbPath),
zap.String("wal-dir", s.walDir),
zap.String("data-dir", dataDir),
zap.String("snap-dir", s.snapDir),
)
if err = s.saveDB(); err != nil {
return err
}
if err = s.saveWALAndSnap(); err != nil {
return err
}
s.lg.Info(
"restored snapshot",
zap.String("path", s.dbPath),
zap.String("wal-dir", s.walDir),
zap.String("data-dir", dataDir),
zap.String("snap-dir", s.snapDir),
)
return nil
}
|
go
|
func (s *v3Manager) Restore(cfg RestoreConfig) error {
pURLs, err := types.NewURLs(cfg.PeerURLs)
if err != nil {
return err
}
var ics types.URLsMap
ics, err = types.NewURLsMap(cfg.InitialCluster)
if err != nil {
return err
}
srv := etcdserver.ServerConfig{
Logger: s.lg,
Name: cfg.Name,
PeerURLs: pURLs,
InitialPeerURLsMap: ics,
InitialClusterToken: cfg.InitialClusterToken,
}
if err = srv.VerifyBootstrap(); err != nil {
return err
}
s.cl, err = membership.NewClusterFromURLsMap(s.lg, cfg.InitialClusterToken, ics)
if err != nil {
return err
}
dataDir := cfg.OutputDataDir
if dataDir == "" {
dataDir = cfg.Name + ".etcd"
}
if fileutil.Exist(dataDir) {
return fmt.Errorf("data-dir %q exists", dataDir)
}
walDir := cfg.OutputWALDir
if walDir == "" {
walDir = filepath.Join(dataDir, "member", "wal")
} else if fileutil.Exist(walDir) {
return fmt.Errorf("wal-dir %q exists", walDir)
}
s.name = cfg.Name
s.dbPath = cfg.SnapshotPath
s.walDir = walDir
s.snapDir = filepath.Join(dataDir, "member", "snap")
s.skipHashCheck = cfg.SkipHashCheck
s.lg.Info(
"restoring snapshot",
zap.String("path", s.dbPath),
zap.String("wal-dir", s.walDir),
zap.String("data-dir", dataDir),
zap.String("snap-dir", s.snapDir),
)
if err = s.saveDB(); err != nil {
return err
}
if err = s.saveWALAndSnap(); err != nil {
return err
}
s.lg.Info(
"restored snapshot",
zap.String("path", s.dbPath),
zap.String("wal-dir", s.walDir),
zap.String("data-dir", dataDir),
zap.String("snap-dir", s.snapDir),
)
return nil
}
|
[
"func",
"(",
"s",
"*",
"v3Manager",
")",
"Restore",
"(",
"cfg",
"RestoreConfig",
")",
"error",
"{",
"pURLs",
",",
"err",
":=",
"types",
".",
"NewURLs",
"(",
"cfg",
".",
"PeerURLs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"var",
"ics",
"types",
".",
"URLsMap",
"\n",
"ics",
",",
"err",
"=",
"types",
".",
"NewURLsMap",
"(",
"cfg",
".",
"InitialCluster",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"srv",
":=",
"etcdserver",
".",
"ServerConfig",
"{",
"Logger",
":",
"s",
".",
"lg",
",",
"Name",
":",
"cfg",
".",
"Name",
",",
"PeerURLs",
":",
"pURLs",
",",
"InitialPeerURLsMap",
":",
"ics",
",",
"InitialClusterToken",
":",
"cfg",
".",
"InitialClusterToken",
",",
"}",
"\n",
"if",
"err",
"=",
"srv",
".",
"VerifyBootstrap",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"cl",
",",
"err",
"=",
"membership",
".",
"NewClusterFromURLsMap",
"(",
"s",
".",
"lg",
",",
"cfg",
".",
"InitialClusterToken",
",",
"ics",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"dataDir",
":=",
"cfg",
".",
"OutputDataDir",
"\n",
"if",
"dataDir",
"==",
"\"\"",
"{",
"dataDir",
"=",
"cfg",
".",
"Name",
"+",
"\".etcd\"",
"\n",
"}",
"\n",
"if",
"fileutil",
".",
"Exist",
"(",
"dataDir",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"data-dir %q exists\"",
",",
"dataDir",
")",
"\n",
"}",
"\n",
"walDir",
":=",
"cfg",
".",
"OutputWALDir",
"\n",
"if",
"walDir",
"==",
"\"\"",
"{",
"walDir",
"=",
"filepath",
".",
"Join",
"(",
"dataDir",
",",
"\"member\"",
",",
"\"wal\"",
")",
"\n",
"}",
"else",
"if",
"fileutil",
".",
"Exist",
"(",
"walDir",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"wal-dir %q exists\"",
",",
"walDir",
")",
"\n",
"}",
"\n",
"s",
".",
"name",
"=",
"cfg",
".",
"Name",
"\n",
"s",
".",
"dbPath",
"=",
"cfg",
".",
"SnapshotPath",
"\n",
"s",
".",
"walDir",
"=",
"walDir",
"\n",
"s",
".",
"snapDir",
"=",
"filepath",
".",
"Join",
"(",
"dataDir",
",",
"\"member\"",
",",
"\"snap\"",
")",
"\n",
"s",
".",
"skipHashCheck",
"=",
"cfg",
".",
"SkipHashCheck",
"\n",
"s",
".",
"lg",
".",
"Info",
"(",
"\"restoring snapshot\"",
",",
"zap",
".",
"String",
"(",
"\"path\"",
",",
"s",
".",
"dbPath",
")",
",",
"zap",
".",
"String",
"(",
"\"wal-dir\"",
",",
"s",
".",
"walDir",
")",
",",
"zap",
".",
"String",
"(",
"\"data-dir\"",
",",
"dataDir",
")",
",",
"zap",
".",
"String",
"(",
"\"snap-dir\"",
",",
"s",
".",
"snapDir",
")",
",",
")",
"\n",
"if",
"err",
"=",
"s",
".",
"saveDB",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"s",
".",
"saveWALAndSnap",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"lg",
".",
"Info",
"(",
"\"restored snapshot\"",
",",
"zap",
".",
"String",
"(",
"\"path\"",
",",
"s",
".",
"dbPath",
")",
",",
"zap",
".",
"String",
"(",
"\"wal-dir\"",
",",
"s",
".",
"walDir",
")",
",",
"zap",
".",
"String",
"(",
"\"data-dir\"",
",",
"dataDir",
")",
",",
"zap",
".",
"String",
"(",
"\"snap-dir\"",
",",
"s",
".",
"snapDir",
")",
",",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Restore restores a new etcd data directory from given snapshot file.
|
[
"Restore",
"restores",
"a",
"new",
"etcd",
"data",
"directory",
"from",
"given",
"snapshot",
"file",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/clientv3/snapshot/v3_snapshot.go#L239-L309
|
test
|
etcd-io/etcd
|
auth/store.go
|
NewAuthStore
|
func NewAuthStore(lg *zap.Logger, be backend.Backend, tp TokenProvider, bcryptCost int) *authStore {
if bcryptCost < bcrypt.MinCost || bcryptCost > bcrypt.MaxCost {
if lg != nil {
lg.Warn(
"use default bcrypt cost instead of the invalid given cost",
zap.Int("min-cost", bcrypt.MinCost),
zap.Int("max-cost", bcrypt.MaxCost),
zap.Int("default-cost", bcrypt.DefaultCost),
zap.Int("given-cost", bcryptCost))
} else {
plog.Warningf("Use default bcrypt-cost %d instead of the invalid value %d",
bcrypt.DefaultCost, bcryptCost)
}
bcryptCost = bcrypt.DefaultCost
}
tx := be.BatchTx()
tx.Lock()
tx.UnsafeCreateBucket(authBucketName)
tx.UnsafeCreateBucket(authUsersBucketName)
tx.UnsafeCreateBucket(authRolesBucketName)
enabled := false
_, vs := tx.UnsafeRange(authBucketName, enableFlagKey, nil, 0)
if len(vs) == 1 {
if bytes.Equal(vs[0], authEnabled) {
enabled = true
}
}
as := &authStore{
revision: getRevision(tx),
lg: lg,
be: be,
enabled: enabled,
rangePermCache: make(map[string]*unifiedRangePermissions),
tokenProvider: tp,
bcryptCost: bcryptCost,
}
if enabled {
as.tokenProvider.enable()
}
if as.Revision() == 0 {
as.commitRevision(tx)
}
tx.Unlock()
be.ForceCommit()
return as
}
|
go
|
func NewAuthStore(lg *zap.Logger, be backend.Backend, tp TokenProvider, bcryptCost int) *authStore {
if bcryptCost < bcrypt.MinCost || bcryptCost > bcrypt.MaxCost {
if lg != nil {
lg.Warn(
"use default bcrypt cost instead of the invalid given cost",
zap.Int("min-cost", bcrypt.MinCost),
zap.Int("max-cost", bcrypt.MaxCost),
zap.Int("default-cost", bcrypt.DefaultCost),
zap.Int("given-cost", bcryptCost))
} else {
plog.Warningf("Use default bcrypt-cost %d instead of the invalid value %d",
bcrypt.DefaultCost, bcryptCost)
}
bcryptCost = bcrypt.DefaultCost
}
tx := be.BatchTx()
tx.Lock()
tx.UnsafeCreateBucket(authBucketName)
tx.UnsafeCreateBucket(authUsersBucketName)
tx.UnsafeCreateBucket(authRolesBucketName)
enabled := false
_, vs := tx.UnsafeRange(authBucketName, enableFlagKey, nil, 0)
if len(vs) == 1 {
if bytes.Equal(vs[0], authEnabled) {
enabled = true
}
}
as := &authStore{
revision: getRevision(tx),
lg: lg,
be: be,
enabled: enabled,
rangePermCache: make(map[string]*unifiedRangePermissions),
tokenProvider: tp,
bcryptCost: bcryptCost,
}
if enabled {
as.tokenProvider.enable()
}
if as.Revision() == 0 {
as.commitRevision(tx)
}
tx.Unlock()
be.ForceCommit()
return as
}
|
[
"func",
"NewAuthStore",
"(",
"lg",
"*",
"zap",
".",
"Logger",
",",
"be",
"backend",
".",
"Backend",
",",
"tp",
"TokenProvider",
",",
"bcryptCost",
"int",
")",
"*",
"authStore",
"{",
"if",
"bcryptCost",
"<",
"bcrypt",
".",
"MinCost",
"||",
"bcryptCost",
">",
"bcrypt",
".",
"MaxCost",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"use default bcrypt cost instead of the invalid given cost\"",
",",
"zap",
".",
"Int",
"(",
"\"min-cost\"",
",",
"bcrypt",
".",
"MinCost",
")",
",",
"zap",
".",
"Int",
"(",
"\"max-cost\"",
",",
"bcrypt",
".",
"MaxCost",
")",
",",
"zap",
".",
"Int",
"(",
"\"default-cost\"",
",",
"bcrypt",
".",
"DefaultCost",
")",
",",
"zap",
".",
"Int",
"(",
"\"given-cost\"",
",",
"bcryptCost",
")",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Warningf",
"(",
"\"Use default bcrypt-cost %d instead of the invalid value %d\"",
",",
"bcrypt",
".",
"DefaultCost",
",",
"bcryptCost",
")",
"\n",
"}",
"\n",
"bcryptCost",
"=",
"bcrypt",
".",
"DefaultCost",
"\n",
"}",
"\n",
"tx",
":=",
"be",
".",
"BatchTx",
"(",
")",
"\n",
"tx",
".",
"Lock",
"(",
")",
"\n",
"tx",
".",
"UnsafeCreateBucket",
"(",
"authBucketName",
")",
"\n",
"tx",
".",
"UnsafeCreateBucket",
"(",
"authUsersBucketName",
")",
"\n",
"tx",
".",
"UnsafeCreateBucket",
"(",
"authRolesBucketName",
")",
"\n",
"enabled",
":=",
"false",
"\n",
"_",
",",
"vs",
":=",
"tx",
".",
"UnsafeRange",
"(",
"authBucketName",
",",
"enableFlagKey",
",",
"nil",
",",
"0",
")",
"\n",
"if",
"len",
"(",
"vs",
")",
"==",
"1",
"{",
"if",
"bytes",
".",
"Equal",
"(",
"vs",
"[",
"0",
"]",
",",
"authEnabled",
")",
"{",
"enabled",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"as",
":=",
"&",
"authStore",
"{",
"revision",
":",
"getRevision",
"(",
"tx",
")",
",",
"lg",
":",
"lg",
",",
"be",
":",
"be",
",",
"enabled",
":",
"enabled",
",",
"rangePermCache",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"unifiedRangePermissions",
")",
",",
"tokenProvider",
":",
"tp",
",",
"bcryptCost",
":",
"bcryptCost",
",",
"}",
"\n",
"if",
"enabled",
"{",
"as",
".",
"tokenProvider",
".",
"enable",
"(",
")",
"\n",
"}",
"\n",
"if",
"as",
".",
"Revision",
"(",
")",
"==",
"0",
"{",
"as",
".",
"commitRevision",
"(",
"tx",
")",
"\n",
"}",
"\n",
"tx",
".",
"Unlock",
"(",
")",
"\n",
"be",
".",
"ForceCommit",
"(",
")",
"\n",
"return",
"as",
"\n",
"}"
] |
// NewAuthStore creates a new AuthStore.
|
[
"NewAuthStore",
"creates",
"a",
"new",
"AuthStore",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/auth/store.go#L1068-L1122
|
test
|
etcd-io/etcd
|
auth/store.go
|
NewTokenProvider
|
func NewTokenProvider(
lg *zap.Logger,
tokenOpts string,
indexWaiter func(uint64) <-chan struct{}) (TokenProvider, error) {
tokenType, typeSpecificOpts, err := decomposeOpts(lg, tokenOpts)
if err != nil {
return nil, ErrInvalidAuthOpts
}
switch tokenType {
case tokenTypeSimple:
if lg != nil {
lg.Warn("simple token is not cryptographically signed")
} else {
plog.Warningf("simple token is not cryptographically signed")
}
return newTokenProviderSimple(lg, indexWaiter), nil
case tokenTypeJWT:
return newTokenProviderJWT(lg, typeSpecificOpts)
case "":
return newTokenProviderNop()
default:
if lg != nil {
lg.Warn(
"unknown token type",
zap.String("type", tokenType),
zap.Error(ErrInvalidAuthOpts),
)
} else {
plog.Errorf("unknown token type: %s", tokenType)
}
return nil, ErrInvalidAuthOpts
}
}
|
go
|
func NewTokenProvider(
lg *zap.Logger,
tokenOpts string,
indexWaiter func(uint64) <-chan struct{}) (TokenProvider, error) {
tokenType, typeSpecificOpts, err := decomposeOpts(lg, tokenOpts)
if err != nil {
return nil, ErrInvalidAuthOpts
}
switch tokenType {
case tokenTypeSimple:
if lg != nil {
lg.Warn("simple token is not cryptographically signed")
} else {
plog.Warningf("simple token is not cryptographically signed")
}
return newTokenProviderSimple(lg, indexWaiter), nil
case tokenTypeJWT:
return newTokenProviderJWT(lg, typeSpecificOpts)
case "":
return newTokenProviderNop()
default:
if lg != nil {
lg.Warn(
"unknown token type",
zap.String("type", tokenType),
zap.Error(ErrInvalidAuthOpts),
)
} else {
plog.Errorf("unknown token type: %s", tokenType)
}
return nil, ErrInvalidAuthOpts
}
}
|
[
"func",
"NewTokenProvider",
"(",
"lg",
"*",
"zap",
".",
"Logger",
",",
"tokenOpts",
"string",
",",
"indexWaiter",
"func",
"(",
"uint64",
")",
"<-",
"chan",
"struct",
"{",
"}",
")",
"(",
"TokenProvider",
",",
"error",
")",
"{",
"tokenType",
",",
"typeSpecificOpts",
",",
"err",
":=",
"decomposeOpts",
"(",
"lg",
",",
"tokenOpts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrInvalidAuthOpts",
"\n",
"}",
"\n",
"switch",
"tokenType",
"{",
"case",
"tokenTypeSimple",
":",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"simple token is not cryptographically signed\"",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Warningf",
"(",
"\"simple token is not cryptographically signed\"",
")",
"\n",
"}",
"\n",
"return",
"newTokenProviderSimple",
"(",
"lg",
",",
"indexWaiter",
")",
",",
"nil",
"\n",
"case",
"tokenTypeJWT",
":",
"return",
"newTokenProviderJWT",
"(",
"lg",
",",
"typeSpecificOpts",
")",
"\n",
"case",
"\"\"",
":",
"return",
"newTokenProviderNop",
"(",
")",
"\n",
"default",
":",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"unknown token type\"",
",",
"zap",
".",
"String",
"(",
"\"type\"",
",",
"tokenType",
")",
",",
"zap",
".",
"Error",
"(",
"ErrInvalidAuthOpts",
")",
",",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Errorf",
"(",
"\"unknown token type: %s\"",
",",
"tokenType",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrInvalidAuthOpts",
"\n",
"}",
"\n",
"}"
] |
// NewTokenProvider creates a new token provider.
|
[
"NewTokenProvider",
"creates",
"a",
"new",
"token",
"provider",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/auth/store.go#L1276-L1312
|
test
|
etcd-io/etcd
|
etcdserver/api/rafthttp/transport.go
|
MendPeer
|
func (t *Transport) MendPeer(id types.ID) {
t.mu.RLock()
p, pok := t.peers[id]
g, gok := t.remotes[id]
t.mu.RUnlock()
if pok {
p.(Pausable).Resume()
}
if gok {
g.Resume()
}
}
|
go
|
func (t *Transport) MendPeer(id types.ID) {
t.mu.RLock()
p, pok := t.peers[id]
g, gok := t.remotes[id]
t.mu.RUnlock()
if pok {
p.(Pausable).Resume()
}
if gok {
g.Resume()
}
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"MendPeer",
"(",
"id",
"types",
".",
"ID",
")",
"{",
"t",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"p",
",",
"pok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"g",
",",
"gok",
":=",
"t",
".",
"remotes",
"[",
"id",
"]",
"\n",
"t",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"pok",
"{",
"p",
".",
"(",
"Pausable",
")",
".",
"Resume",
"(",
")",
"\n",
"}",
"\n",
"if",
"gok",
"{",
"g",
".",
"Resume",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// MendPeer recovers the message dropping behavior of the given peer.
|
[
"MendPeer",
"recovers",
"the",
"message",
"dropping",
"behavior",
"of",
"the",
"given",
"peer",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/rafthttp/transport.go#L254-L266
|
test
|
etcd-io/etcd
|
etcdserver/api/rafthttp/transport.go
|
removePeer
|
func (t *Transport) removePeer(id types.ID) {
if peer, ok := t.peers[id]; ok {
peer.stop()
} else {
if t.Logger != nil {
t.Logger.Panic("unexpected removal of unknown remote peer", zap.String("remote-peer-id", id.String()))
} else {
plog.Panicf("unexpected removal of unknown peer '%d'", id)
}
}
delete(t.peers, id)
delete(t.LeaderStats.Followers, id.String())
t.pipelineProber.Remove(id.String())
t.streamProber.Remove(id.String())
if t.Logger != nil {
t.Logger.Info(
"removed remote peer",
zap.String("local-member-id", t.ID.String()),
zap.String("removed-remote-peer-id", id.String()),
)
} else {
plog.Infof("removed peer %s", id)
}
}
|
go
|
func (t *Transport) removePeer(id types.ID) {
if peer, ok := t.peers[id]; ok {
peer.stop()
} else {
if t.Logger != nil {
t.Logger.Panic("unexpected removal of unknown remote peer", zap.String("remote-peer-id", id.String()))
} else {
plog.Panicf("unexpected removal of unknown peer '%d'", id)
}
}
delete(t.peers, id)
delete(t.LeaderStats.Followers, id.String())
t.pipelineProber.Remove(id.String())
t.streamProber.Remove(id.String())
if t.Logger != nil {
t.Logger.Info(
"removed remote peer",
zap.String("local-member-id", t.ID.String()),
zap.String("removed-remote-peer-id", id.String()),
)
} else {
plog.Infof("removed peer %s", id)
}
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"removePeer",
"(",
"id",
"types",
".",
"ID",
")",
"{",
"if",
"peer",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
";",
"ok",
"{",
"peer",
".",
"stop",
"(",
")",
"\n",
"}",
"else",
"{",
"if",
"t",
".",
"Logger",
"!=",
"nil",
"{",
"t",
".",
"Logger",
".",
"Panic",
"(",
"\"unexpected removal of unknown remote peer\"",
",",
"zap",
".",
"String",
"(",
"\"remote-peer-id\"",
",",
"id",
".",
"String",
"(",
")",
")",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Panicf",
"(",
"\"unexpected removal of unknown peer '%d'\"",
",",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"delete",
"(",
"t",
".",
"peers",
",",
"id",
")",
"\n",
"delete",
"(",
"t",
".",
"LeaderStats",
".",
"Followers",
",",
"id",
".",
"String",
"(",
")",
")",
"\n",
"t",
".",
"pipelineProber",
".",
"Remove",
"(",
"id",
".",
"String",
"(",
")",
")",
"\n",
"t",
".",
"streamProber",
".",
"Remove",
"(",
"id",
".",
"String",
"(",
")",
")",
"\n",
"if",
"t",
".",
"Logger",
"!=",
"nil",
"{",
"t",
".",
"Logger",
".",
"Info",
"(",
"\"removed remote peer\"",
",",
"zap",
".",
"String",
"(",
"\"local-member-id\"",
",",
"t",
".",
"ID",
".",
"String",
"(",
")",
")",
",",
"zap",
".",
"String",
"(",
"\"removed-remote-peer-id\"",
",",
"id",
".",
"String",
"(",
")",
")",
",",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Infof",
"(",
"\"removed peer %s\"",
",",
"id",
")",
"\n",
"}",
"\n",
"}"
] |
// the caller of this function must have the peers mutex.
|
[
"the",
"caller",
"of",
"this",
"function",
"must",
"have",
"the",
"peers",
"mutex",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/rafthttp/transport.go#L353-L377
|
test
|
etcd-io/etcd
|
etcdserver/api/rafthttp/transport.go
|
ActivePeers
|
func (t *Transport) ActivePeers() (cnt int) {
t.mu.RLock()
defer t.mu.RUnlock()
for _, p := range t.peers {
if !p.activeSince().IsZero() {
cnt++
}
}
return cnt
}
|
go
|
func (t *Transport) ActivePeers() (cnt int) {
t.mu.RLock()
defer t.mu.RUnlock()
for _, p := range t.peers {
if !p.activeSince().IsZero() {
cnt++
}
}
return cnt
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"ActivePeers",
"(",
")",
"(",
"cnt",
"int",
")",
"{",
"t",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"t",
".",
"peers",
"{",
"if",
"!",
"p",
".",
"activeSince",
"(",
")",
".",
"IsZero",
"(",
")",
"{",
"cnt",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"cnt",
"\n",
"}"
] |
// ActivePeers returns a channel that closes when an initial
// peer connection has been established. Use this to wait until the
// first peer connection becomes active.
|
[
"ActivePeers",
"returns",
"a",
"channel",
"that",
"closes",
"when",
"an",
"initial",
"peer",
"connection",
"has",
"been",
"established",
".",
"Use",
"this",
"to",
"wait",
"until",
"the",
"first",
"peer",
"connection",
"becomes",
"active",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/api/rafthttp/transport.go#L454-L463
|
test
|
etcd-io/etcd
|
pkg/netutil/netutil.go
|
resolveTCPAddrDefault
|
func resolveTCPAddrDefault(ctx context.Context, addr string) (*net.TCPAddr, error) {
host, port, serr := net.SplitHostPort(addr)
if serr != nil {
return nil, serr
}
portnum, perr := net.DefaultResolver.LookupPort(ctx, "tcp", port)
if perr != nil {
return nil, perr
}
var ips []net.IPAddr
if ip := net.ParseIP(host); ip != nil {
ips = []net.IPAddr{{IP: ip}}
} else {
// Try as a DNS name.
ipss, err := net.DefaultResolver.LookupIPAddr(ctx, host)
if err != nil {
return nil, err
}
ips = ipss
}
// randomize?
ip := ips[0]
return &net.TCPAddr{IP: ip.IP, Port: portnum, Zone: ip.Zone}, nil
}
|
go
|
func resolveTCPAddrDefault(ctx context.Context, addr string) (*net.TCPAddr, error) {
host, port, serr := net.SplitHostPort(addr)
if serr != nil {
return nil, serr
}
portnum, perr := net.DefaultResolver.LookupPort(ctx, "tcp", port)
if perr != nil {
return nil, perr
}
var ips []net.IPAddr
if ip := net.ParseIP(host); ip != nil {
ips = []net.IPAddr{{IP: ip}}
} else {
// Try as a DNS name.
ipss, err := net.DefaultResolver.LookupIPAddr(ctx, host)
if err != nil {
return nil, err
}
ips = ipss
}
// randomize?
ip := ips[0]
return &net.TCPAddr{IP: ip.IP, Port: portnum, Zone: ip.Zone}, nil
}
|
[
"func",
"resolveTCPAddrDefault",
"(",
"ctx",
"context",
".",
"Context",
",",
"addr",
"string",
")",
"(",
"*",
"net",
".",
"TCPAddr",
",",
"error",
")",
"{",
"host",
",",
"port",
",",
"serr",
":=",
"net",
".",
"SplitHostPort",
"(",
"addr",
")",
"\n",
"if",
"serr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"serr",
"\n",
"}",
"\n",
"portnum",
",",
"perr",
":=",
"net",
".",
"DefaultResolver",
".",
"LookupPort",
"(",
"ctx",
",",
"\"tcp\"",
",",
"port",
")",
"\n",
"if",
"perr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"perr",
"\n",
"}",
"\n",
"var",
"ips",
"[",
"]",
"net",
".",
"IPAddr",
"\n",
"if",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"host",
")",
";",
"ip",
"!=",
"nil",
"{",
"ips",
"=",
"[",
"]",
"net",
".",
"IPAddr",
"{",
"{",
"IP",
":",
"ip",
"}",
"}",
"\n",
"}",
"else",
"{",
"ipss",
",",
"err",
":=",
"net",
".",
"DefaultResolver",
".",
"LookupIPAddr",
"(",
"ctx",
",",
"host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ips",
"=",
"ipss",
"\n",
"}",
"\n",
"ip",
":=",
"ips",
"[",
"0",
"]",
"\n",
"return",
"&",
"net",
".",
"TCPAddr",
"{",
"IP",
":",
"ip",
".",
"IP",
",",
"Port",
":",
"portnum",
",",
"Zone",
":",
"ip",
".",
"Zone",
"}",
",",
"nil",
"\n",
"}"
] |
// taken from go's ResolveTCP code but uses configurable ctx
|
[
"taken",
"from",
"go",
"s",
"ResolveTCP",
"code",
"but",
"uses",
"configurable",
"ctx"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/netutil/netutil.go#L37-L61
|
test
|
etcd-io/etcd
|
pkg/netutil/netutil.go
|
resolveTCPAddrs
|
func resolveTCPAddrs(ctx context.Context, lg *zap.Logger, urls [][]url.URL) ([][]url.URL, error) {
newurls := make([][]url.URL, 0)
for _, us := range urls {
nus := make([]url.URL, len(us))
for i, u := range us {
nu, err := url.Parse(u.String())
if err != nil {
return nil, fmt.Errorf("failed to parse %q (%v)", u.String(), err)
}
nus[i] = *nu
}
for i, u := range nus {
h, err := resolveURL(ctx, lg, u)
if err != nil {
return nil, fmt.Errorf("failed to resolve %q (%v)", u.String(), err)
}
if h != "" {
nus[i].Host = h
}
}
newurls = append(newurls, nus)
}
return newurls, nil
}
|
go
|
func resolveTCPAddrs(ctx context.Context, lg *zap.Logger, urls [][]url.URL) ([][]url.URL, error) {
newurls := make([][]url.URL, 0)
for _, us := range urls {
nus := make([]url.URL, len(us))
for i, u := range us {
nu, err := url.Parse(u.String())
if err != nil {
return nil, fmt.Errorf("failed to parse %q (%v)", u.String(), err)
}
nus[i] = *nu
}
for i, u := range nus {
h, err := resolveURL(ctx, lg, u)
if err != nil {
return nil, fmt.Errorf("failed to resolve %q (%v)", u.String(), err)
}
if h != "" {
nus[i].Host = h
}
}
newurls = append(newurls, nus)
}
return newurls, nil
}
|
[
"func",
"resolveTCPAddrs",
"(",
"ctx",
"context",
".",
"Context",
",",
"lg",
"*",
"zap",
".",
"Logger",
",",
"urls",
"[",
"]",
"[",
"]",
"url",
".",
"URL",
")",
"(",
"[",
"]",
"[",
"]",
"url",
".",
"URL",
",",
"error",
")",
"{",
"newurls",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"url",
".",
"URL",
",",
"0",
")",
"\n",
"for",
"_",
",",
"us",
":=",
"range",
"urls",
"{",
"nus",
":=",
"make",
"(",
"[",
"]",
"url",
".",
"URL",
",",
"len",
"(",
"us",
")",
")",
"\n",
"for",
"i",
",",
"u",
":=",
"range",
"us",
"{",
"nu",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"u",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to parse %q (%v)\"",
",",
"u",
".",
"String",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"nus",
"[",
"i",
"]",
"=",
"*",
"nu",
"\n",
"}",
"\n",
"for",
"i",
",",
"u",
":=",
"range",
"nus",
"{",
"h",
",",
"err",
":=",
"resolveURL",
"(",
"ctx",
",",
"lg",
",",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to resolve %q (%v)\"",
",",
"u",
".",
"String",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"h",
"!=",
"\"\"",
"{",
"nus",
"[",
"i",
"]",
".",
"Host",
"=",
"h",
"\n",
"}",
"\n",
"}",
"\n",
"newurls",
"=",
"append",
"(",
"newurls",
",",
"nus",
")",
"\n",
"}",
"\n",
"return",
"newurls",
",",
"nil",
"\n",
"}"
] |
// resolveTCPAddrs is a convenience wrapper for net.ResolveTCPAddr.
// resolveTCPAddrs return a new set of url.URLs, in which all DNS hostnames
// are resolved.
|
[
"resolveTCPAddrs",
"is",
"a",
"convenience",
"wrapper",
"for",
"net",
".",
"ResolveTCPAddr",
".",
"resolveTCPAddrs",
"return",
"a",
"new",
"set",
"of",
"url",
".",
"URLs",
"in",
"which",
"all",
"DNS",
"hostnames",
"are",
"resolved",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/netutil/netutil.go#L66-L89
|
test
|
etcd-io/etcd
|
pkg/netutil/netutil.go
|
urlsEqual
|
func urlsEqual(ctx context.Context, lg *zap.Logger, a []url.URL, b []url.URL) (bool, error) {
if len(a) != len(b) {
return false, fmt.Errorf("len(%q) != len(%q)", urlsToStrings(a), urlsToStrings(b))
}
urls, err := resolveTCPAddrs(ctx, lg, [][]url.URL{a, b})
if err != nil {
return false, err
}
preva, prevb := a, b
a, b = urls[0], urls[1]
sort.Sort(types.URLs(a))
sort.Sort(types.URLs(b))
for i := range a {
if !reflect.DeepEqual(a[i], b[i]) {
return false, fmt.Errorf("%q(resolved from %q) != %q(resolved from %q)",
a[i].String(), preva[i].String(),
b[i].String(), prevb[i].String(),
)
}
}
return true, nil
}
|
go
|
func urlsEqual(ctx context.Context, lg *zap.Logger, a []url.URL, b []url.URL) (bool, error) {
if len(a) != len(b) {
return false, fmt.Errorf("len(%q) != len(%q)", urlsToStrings(a), urlsToStrings(b))
}
urls, err := resolveTCPAddrs(ctx, lg, [][]url.URL{a, b})
if err != nil {
return false, err
}
preva, prevb := a, b
a, b = urls[0], urls[1]
sort.Sort(types.URLs(a))
sort.Sort(types.URLs(b))
for i := range a {
if !reflect.DeepEqual(a[i], b[i]) {
return false, fmt.Errorf("%q(resolved from %q) != %q(resolved from %q)",
a[i].String(), preva[i].String(),
b[i].String(), prevb[i].String(),
)
}
}
return true, nil
}
|
[
"func",
"urlsEqual",
"(",
"ctx",
"context",
".",
"Context",
",",
"lg",
"*",
"zap",
".",
"Logger",
",",
"a",
"[",
"]",
"url",
".",
"URL",
",",
"b",
"[",
"]",
"url",
".",
"URL",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"len",
"(",
"a",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"len(%q) != len(%q)\"",
",",
"urlsToStrings",
"(",
"a",
")",
",",
"urlsToStrings",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"urls",
",",
"err",
":=",
"resolveTCPAddrs",
"(",
"ctx",
",",
"lg",
",",
"[",
"]",
"[",
"]",
"url",
".",
"URL",
"{",
"a",
",",
"b",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"preva",
",",
"prevb",
":=",
"a",
",",
"b",
"\n",
"a",
",",
"b",
"=",
"urls",
"[",
"0",
"]",
",",
"urls",
"[",
"1",
"]",
"\n",
"sort",
".",
"Sort",
"(",
"types",
".",
"URLs",
"(",
"a",
")",
")",
"\n",
"sort",
".",
"Sort",
"(",
"types",
".",
"URLs",
"(",
"b",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"a",
"{",
"if",
"!",
"reflect",
".",
"DeepEqual",
"(",
"a",
"[",
"i",
"]",
",",
"b",
"[",
"i",
"]",
")",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"%q(resolved from %q) != %q(resolved from %q)\"",
",",
"a",
"[",
"i",
"]",
".",
"String",
"(",
")",
",",
"preva",
"[",
"i",
"]",
".",
"String",
"(",
")",
",",
"b",
"[",
"i",
"]",
".",
"String",
"(",
")",
",",
"prevb",
"[",
"i",
"]",
".",
"String",
"(",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] |
// urlsEqual checks equality of url.URLS between two arrays.
// This check pass even if an URL is in hostname and opposite is in IP address.
|
[
"urlsEqual",
"checks",
"equality",
"of",
"url",
".",
"URLS",
"between",
"two",
"arrays",
".",
"This",
"check",
"pass",
"even",
"if",
"an",
"URL",
"is",
"in",
"hostname",
"and",
"opposite",
"is",
"in",
"IP",
"address",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/netutil/netutil.go#L147-L168
|
test
|
etcd-io/etcd
|
pkg/netutil/netutil.go
|
URLStringsEqual
|
func URLStringsEqual(ctx context.Context, lg *zap.Logger, a []string, b []string) (bool, error) {
if len(a) != len(b) {
return false, fmt.Errorf("len(%q) != len(%q)", a, b)
}
urlsA := make([]url.URL, 0)
for _, str := range a {
u, err := url.Parse(str)
if err != nil {
return false, fmt.Errorf("failed to parse %q", str)
}
urlsA = append(urlsA, *u)
}
urlsB := make([]url.URL, 0)
for _, str := range b {
u, err := url.Parse(str)
if err != nil {
return false, fmt.Errorf("failed to parse %q", str)
}
urlsB = append(urlsB, *u)
}
if lg == nil {
lg, _ = zap.NewProduction()
if lg == nil {
lg = zap.NewExample()
}
}
return urlsEqual(ctx, lg, urlsA, urlsB)
}
|
go
|
func URLStringsEqual(ctx context.Context, lg *zap.Logger, a []string, b []string) (bool, error) {
if len(a) != len(b) {
return false, fmt.Errorf("len(%q) != len(%q)", a, b)
}
urlsA := make([]url.URL, 0)
for _, str := range a {
u, err := url.Parse(str)
if err != nil {
return false, fmt.Errorf("failed to parse %q", str)
}
urlsA = append(urlsA, *u)
}
urlsB := make([]url.URL, 0)
for _, str := range b {
u, err := url.Parse(str)
if err != nil {
return false, fmt.Errorf("failed to parse %q", str)
}
urlsB = append(urlsB, *u)
}
if lg == nil {
lg, _ = zap.NewProduction()
if lg == nil {
lg = zap.NewExample()
}
}
return urlsEqual(ctx, lg, urlsA, urlsB)
}
|
[
"func",
"URLStringsEqual",
"(",
"ctx",
"context",
".",
"Context",
",",
"lg",
"*",
"zap",
".",
"Logger",
",",
"a",
"[",
"]",
"string",
",",
"b",
"[",
"]",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"len",
"(",
"a",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"len(%q) != len(%q)\"",
",",
"a",
",",
"b",
")",
"\n",
"}",
"\n",
"urlsA",
":=",
"make",
"(",
"[",
"]",
"url",
".",
"URL",
",",
"0",
")",
"\n",
"for",
"_",
",",
"str",
":=",
"range",
"a",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to parse %q\"",
",",
"str",
")",
"\n",
"}",
"\n",
"urlsA",
"=",
"append",
"(",
"urlsA",
",",
"*",
"u",
")",
"\n",
"}",
"\n",
"urlsB",
":=",
"make",
"(",
"[",
"]",
"url",
".",
"URL",
",",
"0",
")",
"\n",
"for",
"_",
",",
"str",
":=",
"range",
"b",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to parse %q\"",
",",
"str",
")",
"\n",
"}",
"\n",
"urlsB",
"=",
"append",
"(",
"urlsB",
",",
"*",
"u",
")",
"\n",
"}",
"\n",
"if",
"lg",
"==",
"nil",
"{",
"lg",
",",
"_",
"=",
"zap",
".",
"NewProduction",
"(",
")",
"\n",
"if",
"lg",
"==",
"nil",
"{",
"lg",
"=",
"zap",
".",
"NewExample",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"urlsEqual",
"(",
"ctx",
",",
"lg",
",",
"urlsA",
",",
"urlsB",
")",
"\n",
"}"
] |
// URLStringsEqual returns "true" if given URLs are valid
// and resolved to same IP addresses. Otherwise, return "false"
// and error, if any.
|
[
"URLStringsEqual",
"returns",
"true",
"if",
"given",
"URLs",
"are",
"valid",
"and",
"resolved",
"to",
"same",
"IP",
"addresses",
".",
"Otherwise",
"return",
"false",
"and",
"error",
"if",
"any",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/netutil/netutil.go#L173-L200
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
NewLeaseCommand
|
func NewLeaseCommand() *cobra.Command {
lc := &cobra.Command{
Use: "lease <subcommand>",
Short: "Lease related commands",
}
lc.AddCommand(NewLeaseGrantCommand())
lc.AddCommand(NewLeaseRevokeCommand())
lc.AddCommand(NewLeaseTimeToLiveCommand())
lc.AddCommand(NewLeaseListCommand())
lc.AddCommand(NewLeaseKeepAliveCommand())
return lc
}
|
go
|
func NewLeaseCommand() *cobra.Command {
lc := &cobra.Command{
Use: "lease <subcommand>",
Short: "Lease related commands",
}
lc.AddCommand(NewLeaseGrantCommand())
lc.AddCommand(NewLeaseRevokeCommand())
lc.AddCommand(NewLeaseTimeToLiveCommand())
lc.AddCommand(NewLeaseListCommand())
lc.AddCommand(NewLeaseKeepAliveCommand())
return lc
}
|
[
"func",
"NewLeaseCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"lc",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"lease <subcommand>\"",
",",
"Short",
":",
"\"Lease related commands\"",
",",
"}",
"\n",
"lc",
".",
"AddCommand",
"(",
"NewLeaseGrantCommand",
"(",
")",
")",
"\n",
"lc",
".",
"AddCommand",
"(",
"NewLeaseRevokeCommand",
"(",
")",
")",
"\n",
"lc",
".",
"AddCommand",
"(",
"NewLeaseTimeToLiveCommand",
"(",
")",
")",
"\n",
"lc",
".",
"AddCommand",
"(",
"NewLeaseListCommand",
"(",
")",
")",
"\n",
"lc",
".",
"AddCommand",
"(",
"NewLeaseKeepAliveCommand",
"(",
")",
")",
"\n",
"return",
"lc",
"\n",
"}"
] |
// NewLeaseCommand returns the cobra command for "lease".
|
[
"NewLeaseCommand",
"returns",
"the",
"cobra",
"command",
"for",
"lease",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L28-L41
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
NewLeaseGrantCommand
|
func NewLeaseGrantCommand() *cobra.Command {
lc := &cobra.Command{
Use: "grant <ttl>",
Short: "Creates leases",
Run: leaseGrantCommandFunc,
}
return lc
}
|
go
|
func NewLeaseGrantCommand() *cobra.Command {
lc := &cobra.Command{
Use: "grant <ttl>",
Short: "Creates leases",
Run: leaseGrantCommandFunc,
}
return lc
}
|
[
"func",
"NewLeaseGrantCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"lc",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"grant <ttl>\"",
",",
"Short",
":",
"\"Creates leases\"",
",",
"Run",
":",
"leaseGrantCommandFunc",
",",
"}",
"\n",
"return",
"lc",
"\n",
"}"
] |
// NewLeaseGrantCommand returns the cobra command for "lease grant".
|
[
"NewLeaseGrantCommand",
"returns",
"the",
"cobra",
"command",
"for",
"lease",
"grant",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L44-L53
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
leaseGrantCommandFunc
|
func leaseGrantCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease grant command needs TTL argument"))
}
ttl, err := strconv.ParseInt(args[0], 10, 64)
if err != nil {
ExitWithError(ExitBadArgs, fmt.Errorf("bad TTL (%v)", err))
}
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).Grant(ctx, ttl)
cancel()
if err != nil {
ExitWithError(ExitError, fmt.Errorf("failed to grant lease (%v)", err))
}
display.Grant(*resp)
}
|
go
|
func leaseGrantCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease grant command needs TTL argument"))
}
ttl, err := strconv.ParseInt(args[0], 10, 64)
if err != nil {
ExitWithError(ExitBadArgs, fmt.Errorf("bad TTL (%v)", err))
}
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).Grant(ctx, ttl)
cancel()
if err != nil {
ExitWithError(ExitError, fmt.Errorf("failed to grant lease (%v)", err))
}
display.Grant(*resp)
}
|
[
"func",
"leaseGrantCommandFunc",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"args",
")",
"!=",
"1",
"{",
"ExitWithError",
"(",
"ExitBadArgs",
",",
"fmt",
".",
"Errorf",
"(",
"\"lease grant command needs TTL argument\"",
")",
")",
"\n",
"}",
"\n",
"ttl",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"args",
"[",
"0",
"]",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitBadArgs",
",",
"fmt",
".",
"Errorf",
"(",
"\"bad TTL (%v)\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"commandCtx",
"(",
"cmd",
")",
"\n",
"resp",
",",
"err",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"Grant",
"(",
"ctx",
",",
"ttl",
")",
"\n",
"cancel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitError",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to grant lease (%v)\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"display",
".",
"Grant",
"(",
"*",
"resp",
")",
"\n",
"}"
] |
// leaseGrantCommandFunc executes the "lease grant" command.
|
[
"leaseGrantCommandFunc",
"executes",
"the",
"lease",
"grant",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L56-L73
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
NewLeaseRevokeCommand
|
func NewLeaseRevokeCommand() *cobra.Command {
lc := &cobra.Command{
Use: "revoke <leaseID>",
Short: "Revokes leases",
Run: leaseRevokeCommandFunc,
}
return lc
}
|
go
|
func NewLeaseRevokeCommand() *cobra.Command {
lc := &cobra.Command{
Use: "revoke <leaseID>",
Short: "Revokes leases",
Run: leaseRevokeCommandFunc,
}
return lc
}
|
[
"func",
"NewLeaseRevokeCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"lc",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"revoke <leaseID>\"",
",",
"Short",
":",
"\"Revokes leases\"",
",",
"Run",
":",
"leaseRevokeCommandFunc",
",",
"}",
"\n",
"return",
"lc",
"\n",
"}"
] |
// NewLeaseRevokeCommand returns the cobra command for "lease revoke".
|
[
"NewLeaseRevokeCommand",
"returns",
"the",
"cobra",
"command",
"for",
"lease",
"revoke",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L76-L85
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
leaseRevokeCommandFunc
|
func leaseRevokeCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease revoke command needs 1 argument"))
}
id := leaseFromArgs(args[0])
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).Revoke(ctx, id)
cancel()
if err != nil {
ExitWithError(ExitError, fmt.Errorf("failed to revoke lease (%v)", err))
}
display.Revoke(id, *resp)
}
|
go
|
func leaseRevokeCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease revoke command needs 1 argument"))
}
id := leaseFromArgs(args[0])
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).Revoke(ctx, id)
cancel()
if err != nil {
ExitWithError(ExitError, fmt.Errorf("failed to revoke lease (%v)", err))
}
display.Revoke(id, *resp)
}
|
[
"func",
"leaseRevokeCommandFunc",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"args",
")",
"!=",
"1",
"{",
"ExitWithError",
"(",
"ExitBadArgs",
",",
"fmt",
".",
"Errorf",
"(",
"\"lease revoke command needs 1 argument\"",
")",
")",
"\n",
"}",
"\n",
"id",
":=",
"leaseFromArgs",
"(",
"args",
"[",
"0",
"]",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"commandCtx",
"(",
"cmd",
")",
"\n",
"resp",
",",
"err",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"Revoke",
"(",
"ctx",
",",
"id",
")",
"\n",
"cancel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitError",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to revoke lease (%v)\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"display",
".",
"Revoke",
"(",
"id",
",",
"*",
"resp",
")",
"\n",
"}"
] |
// leaseRevokeCommandFunc executes the "lease grant" command.
|
[
"leaseRevokeCommandFunc",
"executes",
"the",
"lease",
"grant",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L88-L101
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
NewLeaseTimeToLiveCommand
|
func NewLeaseTimeToLiveCommand() *cobra.Command {
lc := &cobra.Command{
Use: "timetolive <leaseID> [options]",
Short: "Get lease information",
Run: leaseTimeToLiveCommandFunc,
}
lc.Flags().BoolVar(&timeToLiveKeys, "keys", false, "Get keys attached to this lease")
return lc
}
|
go
|
func NewLeaseTimeToLiveCommand() *cobra.Command {
lc := &cobra.Command{
Use: "timetolive <leaseID> [options]",
Short: "Get lease information",
Run: leaseTimeToLiveCommandFunc,
}
lc.Flags().BoolVar(&timeToLiveKeys, "keys", false, "Get keys attached to this lease")
return lc
}
|
[
"func",
"NewLeaseTimeToLiveCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"lc",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"timetolive <leaseID> [options]\"",
",",
"Short",
":",
"\"Get lease information\"",
",",
"Run",
":",
"leaseTimeToLiveCommandFunc",
",",
"}",
"\n",
"lc",
".",
"Flags",
"(",
")",
".",
"BoolVar",
"(",
"&",
"timeToLiveKeys",
",",
"\"keys\"",
",",
"false",
",",
"\"Get keys attached to this lease\"",
")",
"\n",
"return",
"lc",
"\n",
"}"
] |
// NewLeaseTimeToLiveCommand returns the cobra command for "lease timetolive".
|
[
"NewLeaseTimeToLiveCommand",
"returns",
"the",
"cobra",
"command",
"for",
"lease",
"timetolive",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L106-L116
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
leaseTimeToLiveCommandFunc
|
func leaseTimeToLiveCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease timetolive command needs lease ID as argument"))
}
var opts []v3.LeaseOption
if timeToLiveKeys {
opts = append(opts, v3.WithAttachedKeys())
}
resp, rerr := mustClientFromCmd(cmd).TimeToLive(context.TODO(), leaseFromArgs(args[0]), opts...)
if rerr != nil {
ExitWithError(ExitBadConnection, rerr)
}
display.TimeToLive(*resp, timeToLiveKeys)
}
|
go
|
func leaseTimeToLiveCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease timetolive command needs lease ID as argument"))
}
var opts []v3.LeaseOption
if timeToLiveKeys {
opts = append(opts, v3.WithAttachedKeys())
}
resp, rerr := mustClientFromCmd(cmd).TimeToLive(context.TODO(), leaseFromArgs(args[0]), opts...)
if rerr != nil {
ExitWithError(ExitBadConnection, rerr)
}
display.TimeToLive(*resp, timeToLiveKeys)
}
|
[
"func",
"leaseTimeToLiveCommandFunc",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"args",
")",
"!=",
"1",
"{",
"ExitWithError",
"(",
"ExitBadArgs",
",",
"fmt",
".",
"Errorf",
"(",
"\"lease timetolive command needs lease ID as argument\"",
")",
")",
"\n",
"}",
"\n",
"var",
"opts",
"[",
"]",
"v3",
".",
"LeaseOption",
"\n",
"if",
"timeToLiveKeys",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"v3",
".",
"WithAttachedKeys",
"(",
")",
")",
"\n",
"}",
"\n",
"resp",
",",
"rerr",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"TimeToLive",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"leaseFromArgs",
"(",
"args",
"[",
"0",
"]",
")",
",",
"opts",
"...",
")",
"\n",
"if",
"rerr",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitBadConnection",
",",
"rerr",
")",
"\n",
"}",
"\n",
"display",
".",
"TimeToLive",
"(",
"*",
"resp",
",",
"timeToLiveKeys",
")",
"\n",
"}"
] |
// leaseTimeToLiveCommandFunc executes the "lease timetolive" command.
|
[
"leaseTimeToLiveCommandFunc",
"executes",
"the",
"lease",
"timetolive",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L119-L132
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
NewLeaseListCommand
|
func NewLeaseListCommand() *cobra.Command {
lc := &cobra.Command{
Use: "list",
Short: "List all active leases",
Run: leaseListCommandFunc,
}
return lc
}
|
go
|
func NewLeaseListCommand() *cobra.Command {
lc := &cobra.Command{
Use: "list",
Short: "List all active leases",
Run: leaseListCommandFunc,
}
return lc
}
|
[
"func",
"NewLeaseListCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"lc",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"list\"",
",",
"Short",
":",
"\"List all active leases\"",
",",
"Run",
":",
"leaseListCommandFunc",
",",
"}",
"\n",
"return",
"lc",
"\n",
"}"
] |
// NewLeaseListCommand returns the cobra command for "lease list".
|
[
"NewLeaseListCommand",
"returns",
"the",
"cobra",
"command",
"for",
"lease",
"list",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L135-L142
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
leaseListCommandFunc
|
func leaseListCommandFunc(cmd *cobra.Command, args []string) {
resp, rerr := mustClientFromCmd(cmd).Leases(context.TODO())
if rerr != nil {
ExitWithError(ExitBadConnection, rerr)
}
display.Leases(*resp)
}
|
go
|
func leaseListCommandFunc(cmd *cobra.Command, args []string) {
resp, rerr := mustClientFromCmd(cmd).Leases(context.TODO())
if rerr != nil {
ExitWithError(ExitBadConnection, rerr)
}
display.Leases(*resp)
}
|
[
"func",
"leaseListCommandFunc",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"resp",
",",
"rerr",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"Leases",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"if",
"rerr",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitBadConnection",
",",
"rerr",
")",
"\n",
"}",
"\n",
"display",
".",
"Leases",
"(",
"*",
"resp",
")",
"\n",
"}"
] |
// leaseListCommandFunc executes the "lease list" command.
|
[
"leaseListCommandFunc",
"executes",
"the",
"lease",
"list",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L145-L151
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
NewLeaseKeepAliveCommand
|
func NewLeaseKeepAliveCommand() *cobra.Command {
lc := &cobra.Command{
Use: "keep-alive [options] <leaseID>",
Short: "Keeps leases alive (renew)",
Run: leaseKeepAliveCommandFunc,
}
lc.Flags().BoolVar(&leaseKeepAliveOnce, "once", false, "Resets the keep-alive time to its original value and exits immediately")
return lc
}
|
go
|
func NewLeaseKeepAliveCommand() *cobra.Command {
lc := &cobra.Command{
Use: "keep-alive [options] <leaseID>",
Short: "Keeps leases alive (renew)",
Run: leaseKeepAliveCommandFunc,
}
lc.Flags().BoolVar(&leaseKeepAliveOnce, "once", false, "Resets the keep-alive time to its original value and exits immediately")
return lc
}
|
[
"func",
"NewLeaseKeepAliveCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"lc",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"keep-alive [options] <leaseID>\"",
",",
"Short",
":",
"\"Keeps leases alive (renew)\"",
",",
"Run",
":",
"leaseKeepAliveCommandFunc",
",",
"}",
"\n",
"lc",
".",
"Flags",
"(",
")",
".",
"BoolVar",
"(",
"&",
"leaseKeepAliveOnce",
",",
"\"once\"",
",",
"false",
",",
"\"Resets the keep-alive time to its original value and exits immediately\"",
")",
"\n",
"return",
"lc",
"\n",
"}"
] |
// NewLeaseKeepAliveCommand returns the cobra command for "lease keep-alive".
|
[
"NewLeaseKeepAliveCommand",
"returns",
"the",
"cobra",
"command",
"for",
"lease",
"keep",
"-",
"alive",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L158-L169
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/lease_command.go
|
leaseKeepAliveCommandFunc
|
func leaseKeepAliveCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease keep-alive command needs lease ID as argument"))
}
id := leaseFromArgs(args[0])
if leaseKeepAliveOnce {
respc, kerr := mustClientFromCmd(cmd).KeepAliveOnce(context.TODO(), id)
if kerr != nil {
ExitWithError(ExitBadConnection, kerr)
}
display.KeepAlive(*respc)
return
}
respc, kerr := mustClientFromCmd(cmd).KeepAlive(context.TODO(), id)
if kerr != nil {
ExitWithError(ExitBadConnection, kerr)
}
for resp := range respc {
display.KeepAlive(*resp)
}
if _, ok := (display).(*simplePrinter); ok {
fmt.Printf("lease %016x expired or revoked.\n", id)
}
}
|
go
|
func leaseKeepAliveCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 1 {
ExitWithError(ExitBadArgs, fmt.Errorf("lease keep-alive command needs lease ID as argument"))
}
id := leaseFromArgs(args[0])
if leaseKeepAliveOnce {
respc, kerr := mustClientFromCmd(cmd).KeepAliveOnce(context.TODO(), id)
if kerr != nil {
ExitWithError(ExitBadConnection, kerr)
}
display.KeepAlive(*respc)
return
}
respc, kerr := mustClientFromCmd(cmd).KeepAlive(context.TODO(), id)
if kerr != nil {
ExitWithError(ExitBadConnection, kerr)
}
for resp := range respc {
display.KeepAlive(*resp)
}
if _, ok := (display).(*simplePrinter); ok {
fmt.Printf("lease %016x expired or revoked.\n", id)
}
}
|
[
"func",
"leaseKeepAliveCommandFunc",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"args",
")",
"!=",
"1",
"{",
"ExitWithError",
"(",
"ExitBadArgs",
",",
"fmt",
".",
"Errorf",
"(",
"\"lease keep-alive command needs lease ID as argument\"",
")",
")",
"\n",
"}",
"\n",
"id",
":=",
"leaseFromArgs",
"(",
"args",
"[",
"0",
"]",
")",
"\n",
"if",
"leaseKeepAliveOnce",
"{",
"respc",
",",
"kerr",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"KeepAliveOnce",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"id",
")",
"\n",
"if",
"kerr",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitBadConnection",
",",
"kerr",
")",
"\n",
"}",
"\n",
"display",
".",
"KeepAlive",
"(",
"*",
"respc",
")",
"\n",
"return",
"\n",
"}",
"\n",
"respc",
",",
"kerr",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"KeepAlive",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"id",
")",
"\n",
"if",
"kerr",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitBadConnection",
",",
"kerr",
")",
"\n",
"}",
"\n",
"for",
"resp",
":=",
"range",
"respc",
"{",
"display",
".",
"KeepAlive",
"(",
"*",
"resp",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"(",
"display",
")",
".",
"(",
"*",
"simplePrinter",
")",
";",
"ok",
"{",
"fmt",
".",
"Printf",
"(",
"\"lease %016x expired or revoked.\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"}"
] |
// leaseKeepAliveCommandFunc executes the "lease keep-alive" command.
|
[
"leaseKeepAliveCommandFunc",
"executes",
"the",
"lease",
"keep",
"-",
"alive",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/lease_command.go#L172-L199
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/alarm_command.go
|
NewAlarmCommand
|
func NewAlarmCommand() *cobra.Command {
ac := &cobra.Command{
Use: "alarm <subcommand>",
Short: "Alarm related commands",
}
ac.AddCommand(NewAlarmDisarmCommand())
ac.AddCommand(NewAlarmListCommand())
return ac
}
|
go
|
func NewAlarmCommand() *cobra.Command {
ac := &cobra.Command{
Use: "alarm <subcommand>",
Short: "Alarm related commands",
}
ac.AddCommand(NewAlarmDisarmCommand())
ac.AddCommand(NewAlarmListCommand())
return ac
}
|
[
"func",
"NewAlarmCommand",
"(",
")",
"*",
"cobra",
".",
"Command",
"{",
"ac",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"alarm <subcommand>\"",
",",
"Short",
":",
"\"Alarm related commands\"",
",",
"}",
"\n",
"ac",
".",
"AddCommand",
"(",
"NewAlarmDisarmCommand",
"(",
")",
")",
"\n",
"ac",
".",
"AddCommand",
"(",
"NewAlarmListCommand",
"(",
")",
")",
"\n",
"return",
"ac",
"\n",
"}"
] |
// NewAlarmCommand returns the cobra command for "alarm".
|
[
"NewAlarmCommand",
"returns",
"the",
"cobra",
"command",
"for",
"alarm",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/alarm_command.go#L25-L35
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/alarm_command.go
|
alarmDisarmCommandFunc
|
func alarmDisarmCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 0 {
ExitWithError(ExitBadArgs, fmt.Errorf("alarm disarm command accepts no arguments"))
}
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).AlarmDisarm(ctx, &v3.AlarmMember{})
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.Alarm(*resp)
}
|
go
|
func alarmDisarmCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 0 {
ExitWithError(ExitBadArgs, fmt.Errorf("alarm disarm command accepts no arguments"))
}
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).AlarmDisarm(ctx, &v3.AlarmMember{})
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.Alarm(*resp)
}
|
[
"func",
"alarmDisarmCommandFunc",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"args",
")",
"!=",
"0",
"{",
"ExitWithError",
"(",
"ExitBadArgs",
",",
"fmt",
".",
"Errorf",
"(",
"\"alarm disarm command accepts no arguments\"",
")",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"commandCtx",
"(",
"cmd",
")",
"\n",
"resp",
",",
"err",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"AlarmDisarm",
"(",
"ctx",
",",
"&",
"v3",
".",
"AlarmMember",
"{",
"}",
")",
"\n",
"cancel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitError",
",",
"err",
")",
"\n",
"}",
"\n",
"display",
".",
"Alarm",
"(",
"*",
"resp",
")",
"\n",
"}"
] |
// alarmDisarmCommandFunc executes the "alarm disarm" command.
|
[
"alarmDisarmCommandFunc",
"executes",
"the",
"alarm",
"disarm",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/alarm_command.go#L47-L58
|
test
|
etcd-io/etcd
|
etcdctl/ctlv3/command/alarm_command.go
|
alarmListCommandFunc
|
func alarmListCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 0 {
ExitWithError(ExitBadArgs, fmt.Errorf("alarm list command accepts no arguments"))
}
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).AlarmList(ctx)
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.Alarm(*resp)
}
|
go
|
func alarmListCommandFunc(cmd *cobra.Command, args []string) {
if len(args) != 0 {
ExitWithError(ExitBadArgs, fmt.Errorf("alarm list command accepts no arguments"))
}
ctx, cancel := commandCtx(cmd)
resp, err := mustClientFromCmd(cmd).AlarmList(ctx)
cancel()
if err != nil {
ExitWithError(ExitError, err)
}
display.Alarm(*resp)
}
|
[
"func",
"alarmListCommandFunc",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"args",
")",
"!=",
"0",
"{",
"ExitWithError",
"(",
"ExitBadArgs",
",",
"fmt",
".",
"Errorf",
"(",
"\"alarm list command accepts no arguments\"",
")",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"commandCtx",
"(",
"cmd",
")",
"\n",
"resp",
",",
"err",
":=",
"mustClientFromCmd",
"(",
"cmd",
")",
".",
"AlarmList",
"(",
"ctx",
")",
"\n",
"cancel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ExitWithError",
"(",
"ExitError",
",",
"err",
")",
"\n",
"}",
"\n",
"display",
".",
"Alarm",
"(",
"*",
"resp",
")",
"\n",
"}"
] |
// alarmListCommandFunc executes the "alarm list" command.
|
[
"alarmListCommandFunc",
"executes",
"the",
"alarm",
"list",
"command",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdctl/ctlv3/command/alarm_command.go#L70-L81
|
test
|
etcd-io/etcd
|
functional/rpcpb/etcd_config.go
|
Flags
|
func (e *Etcd) Flags() (fs []string) {
tp := reflect.TypeOf(*e)
vo := reflect.ValueOf(*e)
for _, name := range etcdFields {
field, ok := tp.FieldByName(name)
if !ok {
panic(fmt.Errorf("field %q not found", name))
}
fv := reflect.Indirect(vo).FieldByName(name)
var sv string
switch fv.Type().Kind() {
case reflect.String:
sv = fv.String()
case reflect.Slice:
n := fv.Len()
sl := make([]string, n)
for i := 0; i < n; i++ {
sl[i] = fv.Index(i).String()
}
sv = strings.Join(sl, ",")
case reflect.Int64:
sv = fmt.Sprintf("%d", fv.Int())
case reflect.Bool:
sv = fmt.Sprintf("%v", fv.Bool())
default:
panic(fmt.Errorf("field %q (%v) cannot be parsed", name, fv.Type().Kind()))
}
fname := field.Tag.Get("yaml")
// TODO: remove this
if fname == "initial-corrupt-check" {
fname = "experimental-" + fname
}
if sv != "" {
fs = append(fs, fmt.Sprintf("--%s=%s", fname, sv))
}
}
return fs
}
|
go
|
func (e *Etcd) Flags() (fs []string) {
tp := reflect.TypeOf(*e)
vo := reflect.ValueOf(*e)
for _, name := range etcdFields {
field, ok := tp.FieldByName(name)
if !ok {
panic(fmt.Errorf("field %q not found", name))
}
fv := reflect.Indirect(vo).FieldByName(name)
var sv string
switch fv.Type().Kind() {
case reflect.String:
sv = fv.String()
case reflect.Slice:
n := fv.Len()
sl := make([]string, n)
for i := 0; i < n; i++ {
sl[i] = fv.Index(i).String()
}
sv = strings.Join(sl, ",")
case reflect.Int64:
sv = fmt.Sprintf("%d", fv.Int())
case reflect.Bool:
sv = fmt.Sprintf("%v", fv.Bool())
default:
panic(fmt.Errorf("field %q (%v) cannot be parsed", name, fv.Type().Kind()))
}
fname := field.Tag.Get("yaml")
// TODO: remove this
if fname == "initial-corrupt-check" {
fname = "experimental-" + fname
}
if sv != "" {
fs = append(fs, fmt.Sprintf("--%s=%s", fname, sv))
}
}
return fs
}
|
[
"func",
"(",
"e",
"*",
"Etcd",
")",
"Flags",
"(",
")",
"(",
"fs",
"[",
"]",
"string",
")",
"{",
"tp",
":=",
"reflect",
".",
"TypeOf",
"(",
"*",
"e",
")",
"\n",
"vo",
":=",
"reflect",
".",
"ValueOf",
"(",
"*",
"e",
")",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"etcdFields",
"{",
"field",
",",
"ok",
":=",
"tp",
".",
"FieldByName",
"(",
"name",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"field %q not found\"",
",",
"name",
")",
")",
"\n",
"}",
"\n",
"fv",
":=",
"reflect",
".",
"Indirect",
"(",
"vo",
")",
".",
"FieldByName",
"(",
"name",
")",
"\n",
"var",
"sv",
"string",
"\n",
"switch",
"fv",
".",
"Type",
"(",
")",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"String",
":",
"sv",
"=",
"fv",
".",
"String",
"(",
")",
"\n",
"case",
"reflect",
".",
"Slice",
":",
"n",
":=",
"fv",
".",
"Len",
"(",
")",
"\n",
"sl",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"sl",
"[",
"i",
"]",
"=",
"fv",
".",
"Index",
"(",
"i",
")",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"sv",
"=",
"strings",
".",
"Join",
"(",
"sl",
",",
"\",\"",
")",
"\n",
"case",
"reflect",
".",
"Int64",
":",
"sv",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%d\"",
",",
"fv",
".",
"Int",
"(",
")",
")",
"\n",
"case",
"reflect",
".",
"Bool",
":",
"sv",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"fv",
".",
"Bool",
"(",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"field %q (%v) cannot be parsed\"",
",",
"name",
",",
"fv",
".",
"Type",
"(",
")",
".",
"Kind",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"fname",
":=",
"field",
".",
"Tag",
".",
"Get",
"(",
"\"yaml\"",
")",
"\n",
"if",
"fname",
"==",
"\"initial-corrupt-check\"",
"{",
"fname",
"=",
"\"experimental-\"",
"+",
"fname",
"\n",
"}",
"\n",
"if",
"sv",
"!=",
"\"\"",
"{",
"fs",
"=",
"append",
"(",
"fs",
",",
"fmt",
".",
"Sprintf",
"(",
"\"--%s=%s\"",
",",
"fname",
",",
"sv",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fs",
"\n",
"}"
] |
// Flags returns etcd flags in string slice.
|
[
"Flags",
"returns",
"etcd",
"flags",
"in",
"string",
"slice",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/functional/rpcpb/etcd_config.go#L67-L107
|
test
|
etcd-io/etcd
|
functional/rpcpb/etcd_config.go
|
EmbedConfig
|
func (e *Etcd) EmbedConfig() (cfg *embed.Config, err error) {
var lcURLs types.URLs
lcURLs, err = types.NewURLs(e.ListenClientURLs)
if err != nil {
return nil, err
}
var acURLs types.URLs
acURLs, err = types.NewURLs(e.AdvertiseClientURLs)
if err != nil {
return nil, err
}
var lpURLs types.URLs
lpURLs, err = types.NewURLs(e.ListenPeerURLs)
if err != nil {
return nil, err
}
var apURLs types.URLs
apURLs, err = types.NewURLs(e.AdvertisePeerURLs)
if err != nil {
return nil, err
}
cfg = embed.NewConfig()
cfg.Name = e.Name
cfg.Dir = e.DataDir
cfg.WalDir = e.WALDir
cfg.TickMs = uint(e.HeartbeatIntervalMs)
cfg.ElectionMs = uint(e.ElectionTimeoutMs)
cfg.LCUrls = lcURLs
cfg.ACUrls = acURLs
cfg.ClientAutoTLS = e.ClientAutoTLS
cfg.ClientTLSInfo = transport.TLSInfo{
ClientCertAuth: e.ClientCertAuth,
CertFile: e.ClientCertFile,
KeyFile: e.ClientKeyFile,
TrustedCAFile: e.ClientTrustedCAFile,
}
cfg.LPUrls = lpURLs
cfg.APUrls = apURLs
cfg.PeerAutoTLS = e.PeerAutoTLS
cfg.PeerTLSInfo = transport.TLSInfo{
ClientCertAuth: e.PeerClientCertAuth,
CertFile: e.PeerCertFile,
KeyFile: e.PeerKeyFile,
TrustedCAFile: e.PeerTrustedCAFile,
}
cfg.InitialCluster = e.InitialCluster
cfg.ClusterState = e.InitialClusterState
cfg.InitialClusterToken = e.InitialClusterToken
cfg.SnapshotCount = uint64(e.SnapshotCount)
cfg.QuotaBackendBytes = e.QuotaBackendBytes
cfg.PreVote = e.PreVote
cfg.ExperimentalInitialCorruptCheck = e.InitialCorruptCheck
cfg.Logger = e.Logger
cfg.LogOutputs = e.LogOutputs
cfg.Debug = e.Debug
return cfg, nil
}
|
go
|
func (e *Etcd) EmbedConfig() (cfg *embed.Config, err error) {
var lcURLs types.URLs
lcURLs, err = types.NewURLs(e.ListenClientURLs)
if err != nil {
return nil, err
}
var acURLs types.URLs
acURLs, err = types.NewURLs(e.AdvertiseClientURLs)
if err != nil {
return nil, err
}
var lpURLs types.URLs
lpURLs, err = types.NewURLs(e.ListenPeerURLs)
if err != nil {
return nil, err
}
var apURLs types.URLs
apURLs, err = types.NewURLs(e.AdvertisePeerURLs)
if err != nil {
return nil, err
}
cfg = embed.NewConfig()
cfg.Name = e.Name
cfg.Dir = e.DataDir
cfg.WalDir = e.WALDir
cfg.TickMs = uint(e.HeartbeatIntervalMs)
cfg.ElectionMs = uint(e.ElectionTimeoutMs)
cfg.LCUrls = lcURLs
cfg.ACUrls = acURLs
cfg.ClientAutoTLS = e.ClientAutoTLS
cfg.ClientTLSInfo = transport.TLSInfo{
ClientCertAuth: e.ClientCertAuth,
CertFile: e.ClientCertFile,
KeyFile: e.ClientKeyFile,
TrustedCAFile: e.ClientTrustedCAFile,
}
cfg.LPUrls = lpURLs
cfg.APUrls = apURLs
cfg.PeerAutoTLS = e.PeerAutoTLS
cfg.PeerTLSInfo = transport.TLSInfo{
ClientCertAuth: e.PeerClientCertAuth,
CertFile: e.PeerCertFile,
KeyFile: e.PeerKeyFile,
TrustedCAFile: e.PeerTrustedCAFile,
}
cfg.InitialCluster = e.InitialCluster
cfg.ClusterState = e.InitialClusterState
cfg.InitialClusterToken = e.InitialClusterToken
cfg.SnapshotCount = uint64(e.SnapshotCount)
cfg.QuotaBackendBytes = e.QuotaBackendBytes
cfg.PreVote = e.PreVote
cfg.ExperimentalInitialCorruptCheck = e.InitialCorruptCheck
cfg.Logger = e.Logger
cfg.LogOutputs = e.LogOutputs
cfg.Debug = e.Debug
return cfg, nil
}
|
[
"func",
"(",
"e",
"*",
"Etcd",
")",
"EmbedConfig",
"(",
")",
"(",
"cfg",
"*",
"embed",
".",
"Config",
",",
"err",
"error",
")",
"{",
"var",
"lcURLs",
"types",
".",
"URLs",
"\n",
"lcURLs",
",",
"err",
"=",
"types",
".",
"NewURLs",
"(",
"e",
".",
"ListenClientURLs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"acURLs",
"types",
".",
"URLs",
"\n",
"acURLs",
",",
"err",
"=",
"types",
".",
"NewURLs",
"(",
"e",
".",
"AdvertiseClientURLs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"lpURLs",
"types",
".",
"URLs",
"\n",
"lpURLs",
",",
"err",
"=",
"types",
".",
"NewURLs",
"(",
"e",
".",
"ListenPeerURLs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"apURLs",
"types",
".",
"URLs",
"\n",
"apURLs",
",",
"err",
"=",
"types",
".",
"NewURLs",
"(",
"e",
".",
"AdvertisePeerURLs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cfg",
"=",
"embed",
".",
"NewConfig",
"(",
")",
"\n",
"cfg",
".",
"Name",
"=",
"e",
".",
"Name",
"\n",
"cfg",
".",
"Dir",
"=",
"e",
".",
"DataDir",
"\n",
"cfg",
".",
"WalDir",
"=",
"e",
".",
"WALDir",
"\n",
"cfg",
".",
"TickMs",
"=",
"uint",
"(",
"e",
".",
"HeartbeatIntervalMs",
")",
"\n",
"cfg",
".",
"ElectionMs",
"=",
"uint",
"(",
"e",
".",
"ElectionTimeoutMs",
")",
"\n",
"cfg",
".",
"LCUrls",
"=",
"lcURLs",
"\n",
"cfg",
".",
"ACUrls",
"=",
"acURLs",
"\n",
"cfg",
".",
"ClientAutoTLS",
"=",
"e",
".",
"ClientAutoTLS",
"\n",
"cfg",
".",
"ClientTLSInfo",
"=",
"transport",
".",
"TLSInfo",
"{",
"ClientCertAuth",
":",
"e",
".",
"ClientCertAuth",
",",
"CertFile",
":",
"e",
".",
"ClientCertFile",
",",
"KeyFile",
":",
"e",
".",
"ClientKeyFile",
",",
"TrustedCAFile",
":",
"e",
".",
"ClientTrustedCAFile",
",",
"}",
"\n",
"cfg",
".",
"LPUrls",
"=",
"lpURLs",
"\n",
"cfg",
".",
"APUrls",
"=",
"apURLs",
"\n",
"cfg",
".",
"PeerAutoTLS",
"=",
"e",
".",
"PeerAutoTLS",
"\n",
"cfg",
".",
"PeerTLSInfo",
"=",
"transport",
".",
"TLSInfo",
"{",
"ClientCertAuth",
":",
"e",
".",
"PeerClientCertAuth",
",",
"CertFile",
":",
"e",
".",
"PeerCertFile",
",",
"KeyFile",
":",
"e",
".",
"PeerKeyFile",
",",
"TrustedCAFile",
":",
"e",
".",
"PeerTrustedCAFile",
",",
"}",
"\n",
"cfg",
".",
"InitialCluster",
"=",
"e",
".",
"InitialCluster",
"\n",
"cfg",
".",
"ClusterState",
"=",
"e",
".",
"InitialClusterState",
"\n",
"cfg",
".",
"InitialClusterToken",
"=",
"e",
".",
"InitialClusterToken",
"\n",
"cfg",
".",
"SnapshotCount",
"=",
"uint64",
"(",
"e",
".",
"SnapshotCount",
")",
"\n",
"cfg",
".",
"QuotaBackendBytes",
"=",
"e",
".",
"QuotaBackendBytes",
"\n",
"cfg",
".",
"PreVote",
"=",
"e",
".",
"PreVote",
"\n",
"cfg",
".",
"ExperimentalInitialCorruptCheck",
"=",
"e",
".",
"InitialCorruptCheck",
"\n",
"cfg",
".",
"Logger",
"=",
"e",
".",
"Logger",
"\n",
"cfg",
".",
"LogOutputs",
"=",
"e",
".",
"LogOutputs",
"\n",
"cfg",
".",
"Debug",
"=",
"e",
".",
"Debug",
"\n",
"return",
"cfg",
",",
"nil",
"\n",
"}"
] |
// EmbedConfig returns etcd embed.Config.
|
[
"EmbedConfig",
"returns",
"etcd",
"embed",
".",
"Config",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/functional/rpcpb/etcd_config.go#L110-L174
|
test
|
etcd-io/etcd
|
pkg/debugutil/pprof.go
|
PProfHandlers
|
func PProfHandlers() map[string]http.Handler {
// set only when there's no existing setting
if runtime.SetMutexProfileFraction(-1) == 0 {
// 1 out of 5 mutex events are reported, on average
runtime.SetMutexProfileFraction(5)
}
m := make(map[string]http.Handler)
m[HTTPPrefixPProf+"/"] = http.HandlerFunc(pprof.Index)
m[HTTPPrefixPProf+"/profile"] = http.HandlerFunc(pprof.Profile)
m[HTTPPrefixPProf+"/symbol"] = http.HandlerFunc(pprof.Symbol)
m[HTTPPrefixPProf+"/cmdline"] = http.HandlerFunc(pprof.Cmdline)
m[HTTPPrefixPProf+"/trace "] = http.HandlerFunc(pprof.Trace)
m[HTTPPrefixPProf+"/heap"] = pprof.Handler("heap")
m[HTTPPrefixPProf+"/goroutine"] = pprof.Handler("goroutine")
m[HTTPPrefixPProf+"/threadcreate"] = pprof.Handler("threadcreate")
m[HTTPPrefixPProf+"/block"] = pprof.Handler("block")
m[HTTPPrefixPProf+"/mutex"] = pprof.Handler("mutex")
return m
}
|
go
|
func PProfHandlers() map[string]http.Handler {
// set only when there's no existing setting
if runtime.SetMutexProfileFraction(-1) == 0 {
// 1 out of 5 mutex events are reported, on average
runtime.SetMutexProfileFraction(5)
}
m := make(map[string]http.Handler)
m[HTTPPrefixPProf+"/"] = http.HandlerFunc(pprof.Index)
m[HTTPPrefixPProf+"/profile"] = http.HandlerFunc(pprof.Profile)
m[HTTPPrefixPProf+"/symbol"] = http.HandlerFunc(pprof.Symbol)
m[HTTPPrefixPProf+"/cmdline"] = http.HandlerFunc(pprof.Cmdline)
m[HTTPPrefixPProf+"/trace "] = http.HandlerFunc(pprof.Trace)
m[HTTPPrefixPProf+"/heap"] = pprof.Handler("heap")
m[HTTPPrefixPProf+"/goroutine"] = pprof.Handler("goroutine")
m[HTTPPrefixPProf+"/threadcreate"] = pprof.Handler("threadcreate")
m[HTTPPrefixPProf+"/block"] = pprof.Handler("block")
m[HTTPPrefixPProf+"/mutex"] = pprof.Handler("mutex")
return m
}
|
[
"func",
"PProfHandlers",
"(",
")",
"map",
"[",
"string",
"]",
"http",
".",
"Handler",
"{",
"if",
"runtime",
".",
"SetMutexProfileFraction",
"(",
"-",
"1",
")",
"==",
"0",
"{",
"runtime",
".",
"SetMutexProfileFraction",
"(",
"5",
")",
"\n",
"}",
"\n",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"http",
".",
"Handler",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/\"",
"]",
"=",
"http",
".",
"HandlerFunc",
"(",
"pprof",
".",
"Index",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/profile\"",
"]",
"=",
"http",
".",
"HandlerFunc",
"(",
"pprof",
".",
"Profile",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/symbol\"",
"]",
"=",
"http",
".",
"HandlerFunc",
"(",
"pprof",
".",
"Symbol",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/cmdline\"",
"]",
"=",
"http",
".",
"HandlerFunc",
"(",
"pprof",
".",
"Cmdline",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/trace \"",
"]",
"=",
"http",
".",
"HandlerFunc",
"(",
"pprof",
".",
"Trace",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/heap\"",
"]",
"=",
"pprof",
".",
"Handler",
"(",
"\"heap\"",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/goroutine\"",
"]",
"=",
"pprof",
".",
"Handler",
"(",
"\"goroutine\"",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/threadcreate\"",
"]",
"=",
"pprof",
".",
"Handler",
"(",
"\"threadcreate\"",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/block\"",
"]",
"=",
"pprof",
".",
"Handler",
"(",
"\"block\"",
")",
"\n",
"m",
"[",
"HTTPPrefixPProf",
"+",
"\"/mutex\"",
"]",
"=",
"pprof",
".",
"Handler",
"(",
"\"mutex\"",
")",
"\n",
"return",
"m",
"\n",
"}"
] |
// PProfHandlers returns a map of pprof handlers keyed by the HTTP path.
|
[
"PProfHandlers",
"returns",
"a",
"map",
"of",
"pprof",
"handlers",
"keyed",
"by",
"the",
"HTTP",
"path",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/debugutil/pprof.go#L26-L47
|
test
|
etcd-io/etcd
|
etcdserver/quota.go
|
NewBackendQuota
|
func NewBackendQuota(s *EtcdServer, name string) Quota {
lg := s.getLogger()
quotaBackendBytes.Set(float64(s.Cfg.QuotaBackendBytes))
if s.Cfg.QuotaBackendBytes < 0 {
// disable quotas if negative
quotaLogOnce.Do(func() {
if lg != nil {
lg.Info(
"disabled backend quota",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", s.Cfg.QuotaBackendBytes),
)
} else {
plog.Warningf("disabling backend quota")
}
})
return &passthroughQuota{}
}
if s.Cfg.QuotaBackendBytes == 0 {
// use default size if no quota size given
quotaLogOnce.Do(func() {
if lg != nil {
lg.Info(
"enabled backend quota with default value",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", DefaultQuotaBytes),
zap.String("quota-size", DefaultQuotaSize),
)
}
})
quotaBackendBytes.Set(float64(DefaultQuotaBytes))
return &backendQuota{s, DefaultQuotaBytes}
}
quotaLogOnce.Do(func() {
if s.Cfg.QuotaBackendBytes > MaxQuotaBytes {
if lg != nil {
lg.Warn(
"quota exceeds the maximum value",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", s.Cfg.QuotaBackendBytes),
zap.String("quota-size", humanize.Bytes(uint64(s.Cfg.QuotaBackendBytes))),
zap.Int64("quota-maximum-size-bytes", MaxQuotaBytes),
zap.String("quota-maximum-size", maxQuotaSize),
)
} else {
plog.Warningf("backend quota %v exceeds maximum recommended quota %v", s.Cfg.QuotaBackendBytes, MaxQuotaBytes)
}
}
if lg != nil {
lg.Info(
"enabled backend quota",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", s.Cfg.QuotaBackendBytes),
zap.String("quota-size", humanize.Bytes(uint64(s.Cfg.QuotaBackendBytes))),
)
}
})
return &backendQuota{s, s.Cfg.QuotaBackendBytes}
}
|
go
|
func NewBackendQuota(s *EtcdServer, name string) Quota {
lg := s.getLogger()
quotaBackendBytes.Set(float64(s.Cfg.QuotaBackendBytes))
if s.Cfg.QuotaBackendBytes < 0 {
// disable quotas if negative
quotaLogOnce.Do(func() {
if lg != nil {
lg.Info(
"disabled backend quota",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", s.Cfg.QuotaBackendBytes),
)
} else {
plog.Warningf("disabling backend quota")
}
})
return &passthroughQuota{}
}
if s.Cfg.QuotaBackendBytes == 0 {
// use default size if no quota size given
quotaLogOnce.Do(func() {
if lg != nil {
lg.Info(
"enabled backend quota with default value",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", DefaultQuotaBytes),
zap.String("quota-size", DefaultQuotaSize),
)
}
})
quotaBackendBytes.Set(float64(DefaultQuotaBytes))
return &backendQuota{s, DefaultQuotaBytes}
}
quotaLogOnce.Do(func() {
if s.Cfg.QuotaBackendBytes > MaxQuotaBytes {
if lg != nil {
lg.Warn(
"quota exceeds the maximum value",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", s.Cfg.QuotaBackendBytes),
zap.String("quota-size", humanize.Bytes(uint64(s.Cfg.QuotaBackendBytes))),
zap.Int64("quota-maximum-size-bytes", MaxQuotaBytes),
zap.String("quota-maximum-size", maxQuotaSize),
)
} else {
plog.Warningf("backend quota %v exceeds maximum recommended quota %v", s.Cfg.QuotaBackendBytes, MaxQuotaBytes)
}
}
if lg != nil {
lg.Info(
"enabled backend quota",
zap.String("quota-name", name),
zap.Int64("quota-size-bytes", s.Cfg.QuotaBackendBytes),
zap.String("quota-size", humanize.Bytes(uint64(s.Cfg.QuotaBackendBytes))),
)
}
})
return &backendQuota{s, s.Cfg.QuotaBackendBytes}
}
|
[
"func",
"NewBackendQuota",
"(",
"s",
"*",
"EtcdServer",
",",
"name",
"string",
")",
"Quota",
"{",
"lg",
":=",
"s",
".",
"getLogger",
"(",
")",
"\n",
"quotaBackendBytes",
".",
"Set",
"(",
"float64",
"(",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
")",
")",
"\n",
"if",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
"<",
"0",
"{",
"quotaLogOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Info",
"(",
"\"disabled backend quota\"",
",",
"zap",
".",
"String",
"(",
"\"quota-name\"",
",",
"name",
")",
",",
"zap",
".",
"Int64",
"(",
"\"quota-size-bytes\"",
",",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
")",
",",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Warningf",
"(",
"\"disabling backend quota\"",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"return",
"&",
"passthroughQuota",
"{",
"}",
"\n",
"}",
"\n",
"if",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
"==",
"0",
"{",
"quotaLogOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Info",
"(",
"\"enabled backend quota with default value\"",
",",
"zap",
".",
"String",
"(",
"\"quota-name\"",
",",
"name",
")",
",",
"zap",
".",
"Int64",
"(",
"\"quota-size-bytes\"",
",",
"DefaultQuotaBytes",
")",
",",
"zap",
".",
"String",
"(",
"\"quota-size\"",
",",
"DefaultQuotaSize",
")",
",",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"quotaBackendBytes",
".",
"Set",
"(",
"float64",
"(",
"DefaultQuotaBytes",
")",
")",
"\n",
"return",
"&",
"backendQuota",
"{",
"s",
",",
"DefaultQuotaBytes",
"}",
"\n",
"}",
"\n",
"quotaLogOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"if",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
">",
"MaxQuotaBytes",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"quota exceeds the maximum value\"",
",",
"zap",
".",
"String",
"(",
"\"quota-name\"",
",",
"name",
")",
",",
"zap",
".",
"Int64",
"(",
"\"quota-size-bytes\"",
",",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
")",
",",
"zap",
".",
"String",
"(",
"\"quota-size\"",
",",
"humanize",
".",
"Bytes",
"(",
"uint64",
"(",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
")",
")",
")",
",",
"zap",
".",
"Int64",
"(",
"\"quota-maximum-size-bytes\"",
",",
"MaxQuotaBytes",
")",
",",
"zap",
".",
"String",
"(",
"\"quota-maximum-size\"",
",",
"maxQuotaSize",
")",
",",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Warningf",
"(",
"\"backend quota %v exceeds maximum recommended quota %v\"",
",",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
",",
"MaxQuotaBytes",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Info",
"(",
"\"enabled backend quota\"",
",",
"zap",
".",
"String",
"(",
"\"quota-name\"",
",",
"name",
")",
",",
"zap",
".",
"Int64",
"(",
"\"quota-size-bytes\"",
",",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
")",
",",
"zap",
".",
"String",
"(",
"\"quota-size\"",
",",
"humanize",
".",
"Bytes",
"(",
"uint64",
"(",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
")",
")",
")",
",",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"return",
"&",
"backendQuota",
"{",
"s",
",",
"s",
".",
"Cfg",
".",
"QuotaBackendBytes",
"}",
"\n",
"}"
] |
// NewBackendQuota creates a quota layer with the given storage limit.
|
[
"NewBackendQuota",
"creates",
"a",
"quota",
"layer",
"with",
"the",
"given",
"storage",
"limit",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/quota.go#L74-L135
|
test
|
etcd-io/etcd
|
proxy/grpcproxy/cluster.go
|
NewClusterProxy
|
func NewClusterProxy(c *clientv3.Client, advaddr string, prefix string) (pb.ClusterServer, <-chan struct{}) {
cp := &clusterProxy{
clus: c.Cluster,
ctx: c.Ctx(),
gr: &naming.GRPCResolver{Client: c},
advaddr: advaddr,
prefix: prefix,
umap: make(map[string]gnaming.Update),
}
donec := make(chan struct{})
if advaddr != "" && prefix != "" {
go func() {
defer close(donec)
cp.resolve(prefix)
}()
return cp, donec
}
close(donec)
return cp, donec
}
|
go
|
func NewClusterProxy(c *clientv3.Client, advaddr string, prefix string) (pb.ClusterServer, <-chan struct{}) {
cp := &clusterProxy{
clus: c.Cluster,
ctx: c.Ctx(),
gr: &naming.GRPCResolver{Client: c},
advaddr: advaddr,
prefix: prefix,
umap: make(map[string]gnaming.Update),
}
donec := make(chan struct{})
if advaddr != "" && prefix != "" {
go func() {
defer close(donec)
cp.resolve(prefix)
}()
return cp, donec
}
close(donec)
return cp, donec
}
|
[
"func",
"NewClusterProxy",
"(",
"c",
"*",
"clientv3",
".",
"Client",
",",
"advaddr",
"string",
",",
"prefix",
"string",
")",
"(",
"pb",
".",
"ClusterServer",
",",
"<-",
"chan",
"struct",
"{",
"}",
")",
"{",
"cp",
":=",
"&",
"clusterProxy",
"{",
"clus",
":",
"c",
".",
"Cluster",
",",
"ctx",
":",
"c",
".",
"Ctx",
"(",
")",
",",
"gr",
":",
"&",
"naming",
".",
"GRPCResolver",
"{",
"Client",
":",
"c",
"}",
",",
"advaddr",
":",
"advaddr",
",",
"prefix",
":",
"prefix",
",",
"umap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"gnaming",
".",
"Update",
")",
",",
"}",
"\n",
"donec",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"if",
"advaddr",
"!=",
"\"\"",
"&&",
"prefix",
"!=",
"\"\"",
"{",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"donec",
")",
"\n",
"cp",
".",
"resolve",
"(",
"prefix",
")",
"\n",
"}",
"(",
")",
"\n",
"return",
"cp",
",",
"donec",
"\n",
"}",
"\n",
"close",
"(",
"donec",
")",
"\n",
"return",
"cp",
",",
"donec",
"\n",
"}"
] |
// NewClusterProxy takes optional prefix to fetch grpc-proxy member endpoints.
// The returned channel is closed when there is grpc-proxy endpoint registered
// and the client's context is canceled so the 'register' loop returns.
|
[
"NewClusterProxy",
"takes",
"optional",
"prefix",
"to",
"fetch",
"grpc",
"-",
"proxy",
"member",
"endpoints",
".",
"The",
"returned",
"channel",
"is",
"closed",
"when",
"there",
"is",
"grpc",
"-",
"proxy",
"endpoint",
"registered",
"and",
"the",
"client",
"s",
"context",
"is",
"canceled",
"so",
"the",
"register",
"loop",
"returns",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/proxy/grpcproxy/cluster.go#L51-L73
|
test
|
etcd-io/etcd
|
lease/leasehttp/http.go
|
NewHandler
|
func NewHandler(l lease.Lessor, waitch func() <-chan struct{}) http.Handler {
return &leaseHandler{l, waitch}
}
|
go
|
func NewHandler(l lease.Lessor, waitch func() <-chan struct{}) http.Handler {
return &leaseHandler{l, waitch}
}
|
[
"func",
"NewHandler",
"(",
"l",
"lease",
".",
"Lessor",
",",
"waitch",
"func",
"(",
")",
"<-",
"chan",
"struct",
"{",
"}",
")",
"http",
".",
"Handler",
"{",
"return",
"&",
"leaseHandler",
"{",
"l",
",",
"waitch",
"}",
"\n",
"}"
] |
// NewHandler returns an http Handler for lease renewals
|
[
"NewHandler",
"returns",
"an",
"http",
"Handler",
"for",
"lease",
"renewals"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/lease/leasehttp/http.go#L40-L42
|
test
|
etcd-io/etcd
|
lease/leasehttp/http.go
|
TimeToLiveHTTP
|
func TimeToLiveHTTP(ctx context.Context, id lease.LeaseID, keys bool, url string, rt http.RoundTripper) (*leasepb.LeaseInternalResponse, error) {
// will post lreq protobuf to leader
lreq, err := (&leasepb.LeaseInternalRequest{
LeaseTimeToLiveRequest: &pb.LeaseTimeToLiveRequest{
ID: int64(id),
Keys: keys,
},
}).Marshal()
if err != nil {
return nil, err
}
req, err := http.NewRequest("POST", url, bytes.NewReader(lreq))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/protobuf")
req = req.WithContext(ctx)
cc := &http.Client{Transport: rt}
var b []byte
// buffer errc channel so that errc don't block inside the go routinue
resp, err := cc.Do(req)
if err != nil {
return nil, err
}
b, err = readResponse(resp)
if err != nil {
return nil, err
}
if resp.StatusCode == http.StatusRequestTimeout {
return nil, ErrLeaseHTTPTimeout
}
if resp.StatusCode == http.StatusNotFound {
return nil, lease.ErrLeaseNotFound
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("lease: unknown error(%s)", string(b))
}
lresp := &leasepb.LeaseInternalResponse{}
if err := lresp.Unmarshal(b); err != nil {
return nil, fmt.Errorf(`lease: %v. data = "%s"`, err, string(b))
}
if lresp.LeaseTimeToLiveResponse.ID != int64(id) {
return nil, fmt.Errorf("lease: renew id mismatch")
}
return lresp, nil
}
|
go
|
func TimeToLiveHTTP(ctx context.Context, id lease.LeaseID, keys bool, url string, rt http.RoundTripper) (*leasepb.LeaseInternalResponse, error) {
// will post lreq protobuf to leader
lreq, err := (&leasepb.LeaseInternalRequest{
LeaseTimeToLiveRequest: &pb.LeaseTimeToLiveRequest{
ID: int64(id),
Keys: keys,
},
}).Marshal()
if err != nil {
return nil, err
}
req, err := http.NewRequest("POST", url, bytes.NewReader(lreq))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/protobuf")
req = req.WithContext(ctx)
cc := &http.Client{Transport: rt}
var b []byte
// buffer errc channel so that errc don't block inside the go routinue
resp, err := cc.Do(req)
if err != nil {
return nil, err
}
b, err = readResponse(resp)
if err != nil {
return nil, err
}
if resp.StatusCode == http.StatusRequestTimeout {
return nil, ErrLeaseHTTPTimeout
}
if resp.StatusCode == http.StatusNotFound {
return nil, lease.ErrLeaseNotFound
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("lease: unknown error(%s)", string(b))
}
lresp := &leasepb.LeaseInternalResponse{}
if err := lresp.Unmarshal(b); err != nil {
return nil, fmt.Errorf(`lease: %v. data = "%s"`, err, string(b))
}
if lresp.LeaseTimeToLiveResponse.ID != int64(id) {
return nil, fmt.Errorf("lease: renew id mismatch")
}
return lresp, nil
}
|
[
"func",
"TimeToLiveHTTP",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"lease",
".",
"LeaseID",
",",
"keys",
"bool",
",",
"url",
"string",
",",
"rt",
"http",
".",
"RoundTripper",
")",
"(",
"*",
"leasepb",
".",
"LeaseInternalResponse",
",",
"error",
")",
"{",
"lreq",
",",
"err",
":=",
"(",
"&",
"leasepb",
".",
"LeaseInternalRequest",
"{",
"LeaseTimeToLiveRequest",
":",
"&",
"pb",
".",
"LeaseTimeToLiveRequest",
"{",
"ID",
":",
"int64",
"(",
"id",
")",
",",
"Keys",
":",
"keys",
",",
"}",
",",
"}",
")",
".",
"Marshal",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"POST\"",
",",
"url",
",",
"bytes",
".",
"NewReader",
"(",
"lreq",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"application/protobuf\"",
")",
"\n",
"req",
"=",
"req",
".",
"WithContext",
"(",
"ctx",
")",
"\n",
"cc",
":=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"rt",
"}",
"\n",
"var",
"b",
"[",
"]",
"byte",
"\n",
"resp",
",",
"err",
":=",
"cc",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"b",
",",
"err",
"=",
"readResponse",
"(",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"resp",
".",
"StatusCode",
"==",
"http",
".",
"StatusRequestTimeout",
"{",
"return",
"nil",
",",
"ErrLeaseHTTPTimeout",
"\n",
"}",
"\n",
"if",
"resp",
".",
"StatusCode",
"==",
"http",
".",
"StatusNotFound",
"{",
"return",
"nil",
",",
"lease",
".",
"ErrLeaseNotFound",
"\n",
"}",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"lease: unknown error(%s)\"",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"lresp",
":=",
"&",
"leasepb",
".",
"LeaseInternalResponse",
"{",
"}",
"\n",
"if",
"err",
":=",
"lresp",
".",
"Unmarshal",
"(",
"b",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"`lease: %v. data = \"%s\"`",
",",
"err",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"if",
"lresp",
".",
"LeaseTimeToLiveResponse",
".",
"ID",
"!=",
"int64",
"(",
"id",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"lease: renew id mismatch\"",
")",
"\n",
"}",
"\n",
"return",
"lresp",
",",
"nil",
"\n",
"}"
] |
// TimeToLiveHTTP retrieves lease information of the given lease ID.
|
[
"TimeToLiveHTTP",
"retrieves",
"lease",
"information",
"of",
"the",
"given",
"lease",
"ID",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/lease/leasehttp/http.go#L193-L242
|
test
|
etcd-io/etcd
|
mvcc/watcher_group.go
|
newWatcherBatch
|
func newWatcherBatch(wg *watcherGroup, evs []mvccpb.Event) watcherBatch {
if len(wg.watchers) == 0 {
return nil
}
wb := make(watcherBatch)
for _, ev := range evs {
for w := range wg.watcherSetByKey(string(ev.Kv.Key)) {
if ev.Kv.ModRevision >= w.minRev {
// don't double notify
wb.add(w, ev)
}
}
}
return wb
}
|
go
|
func newWatcherBatch(wg *watcherGroup, evs []mvccpb.Event) watcherBatch {
if len(wg.watchers) == 0 {
return nil
}
wb := make(watcherBatch)
for _, ev := range evs {
for w := range wg.watcherSetByKey(string(ev.Kv.Key)) {
if ev.Kv.ModRevision >= w.minRev {
// don't double notify
wb.add(w, ev)
}
}
}
return wb
}
|
[
"func",
"newWatcherBatch",
"(",
"wg",
"*",
"watcherGroup",
",",
"evs",
"[",
"]",
"mvccpb",
".",
"Event",
")",
"watcherBatch",
"{",
"if",
"len",
"(",
"wg",
".",
"watchers",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"wb",
":=",
"make",
"(",
"watcherBatch",
")",
"\n",
"for",
"_",
",",
"ev",
":=",
"range",
"evs",
"{",
"for",
"w",
":=",
"range",
"wg",
".",
"watcherSetByKey",
"(",
"string",
"(",
"ev",
".",
"Kv",
".",
"Key",
")",
")",
"{",
"if",
"ev",
".",
"Kv",
".",
"ModRevision",
">=",
"w",
".",
"minRev",
"{",
"wb",
".",
"add",
"(",
"w",
",",
"ev",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"wb",
"\n",
"}"
] |
// newWatcherBatch maps watchers to their matched events. It enables quick
// events look up by watcher.
|
[
"newWatcherBatch",
"maps",
"watchers",
"to",
"their",
"matched",
"events",
".",
"It",
"enables",
"quick",
"events",
"look",
"up",
"by",
"watcher",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/watcher_group.go#L81-L96
|
test
|
etcd-io/etcd
|
mvcc/watcher_group.go
|
add
|
func (wg *watcherGroup) add(wa *watcher) {
wg.watchers.add(wa)
if wa.end == nil {
wg.keyWatchers.add(wa)
return
}
// interval already registered?
ivl := adt.NewStringAffineInterval(string(wa.key), string(wa.end))
if iv := wg.ranges.Find(ivl); iv != nil {
iv.Val.(watcherSet).add(wa)
return
}
// not registered, put in interval tree
ws := make(watcherSet)
ws.add(wa)
wg.ranges.Insert(ivl, ws)
}
|
go
|
func (wg *watcherGroup) add(wa *watcher) {
wg.watchers.add(wa)
if wa.end == nil {
wg.keyWatchers.add(wa)
return
}
// interval already registered?
ivl := adt.NewStringAffineInterval(string(wa.key), string(wa.end))
if iv := wg.ranges.Find(ivl); iv != nil {
iv.Val.(watcherSet).add(wa)
return
}
// not registered, put in interval tree
ws := make(watcherSet)
ws.add(wa)
wg.ranges.Insert(ivl, ws)
}
|
[
"func",
"(",
"wg",
"*",
"watcherGroup",
")",
"add",
"(",
"wa",
"*",
"watcher",
")",
"{",
"wg",
".",
"watchers",
".",
"add",
"(",
"wa",
")",
"\n",
"if",
"wa",
".",
"end",
"==",
"nil",
"{",
"wg",
".",
"keyWatchers",
".",
"add",
"(",
"wa",
")",
"\n",
"return",
"\n",
"}",
"\n",
"ivl",
":=",
"adt",
".",
"NewStringAffineInterval",
"(",
"string",
"(",
"wa",
".",
"key",
")",
",",
"string",
"(",
"wa",
".",
"end",
")",
")",
"\n",
"if",
"iv",
":=",
"wg",
".",
"ranges",
".",
"Find",
"(",
"ivl",
")",
";",
"iv",
"!=",
"nil",
"{",
"iv",
".",
"Val",
".",
"(",
"watcherSet",
")",
".",
"add",
"(",
"wa",
")",
"\n",
"return",
"\n",
"}",
"\n",
"ws",
":=",
"make",
"(",
"watcherSet",
")",
"\n",
"ws",
".",
"add",
"(",
"wa",
")",
"\n",
"wg",
".",
"ranges",
".",
"Insert",
"(",
"ivl",
",",
"ws",
")",
"\n",
"}"
] |
// add puts a watcher in the group.
|
[
"add",
"puts",
"a",
"watcher",
"in",
"the",
"group",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/watcher_group.go#L164-L182
|
test
|
etcd-io/etcd
|
mvcc/watcher_group.go
|
contains
|
func (wg *watcherGroup) contains(key string) bool {
_, ok := wg.keyWatchers[key]
return ok || wg.ranges.Intersects(adt.NewStringAffinePoint(key))
}
|
go
|
func (wg *watcherGroup) contains(key string) bool {
_, ok := wg.keyWatchers[key]
return ok || wg.ranges.Intersects(adt.NewStringAffinePoint(key))
}
|
[
"func",
"(",
"wg",
"*",
"watcherGroup",
")",
"contains",
"(",
"key",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"wg",
".",
"keyWatchers",
"[",
"key",
"]",
"\n",
"return",
"ok",
"||",
"wg",
".",
"ranges",
".",
"Intersects",
"(",
"adt",
".",
"NewStringAffinePoint",
"(",
"key",
")",
")",
"\n",
"}"
] |
// contains is whether the given key has a watcher in the group.
|
[
"contains",
"is",
"whether",
"the",
"given",
"key",
"has",
"a",
"watcher",
"in",
"the",
"group",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/watcher_group.go#L185-L188
|
test
|
etcd-io/etcd
|
mvcc/watcher_group.go
|
delete
|
func (wg *watcherGroup) delete(wa *watcher) bool {
if _, ok := wg.watchers[wa]; !ok {
return false
}
wg.watchers.delete(wa)
if wa.end == nil {
wg.keyWatchers.delete(wa)
return true
}
ivl := adt.NewStringAffineInterval(string(wa.key), string(wa.end))
iv := wg.ranges.Find(ivl)
if iv == nil {
return false
}
ws := iv.Val.(watcherSet)
delete(ws, wa)
if len(ws) == 0 {
// remove interval missing watchers
if ok := wg.ranges.Delete(ivl); !ok {
panic("could not remove watcher from interval tree")
}
}
return true
}
|
go
|
func (wg *watcherGroup) delete(wa *watcher) bool {
if _, ok := wg.watchers[wa]; !ok {
return false
}
wg.watchers.delete(wa)
if wa.end == nil {
wg.keyWatchers.delete(wa)
return true
}
ivl := adt.NewStringAffineInterval(string(wa.key), string(wa.end))
iv := wg.ranges.Find(ivl)
if iv == nil {
return false
}
ws := iv.Val.(watcherSet)
delete(ws, wa)
if len(ws) == 0 {
// remove interval missing watchers
if ok := wg.ranges.Delete(ivl); !ok {
panic("could not remove watcher from interval tree")
}
}
return true
}
|
[
"func",
"(",
"wg",
"*",
"watcherGroup",
")",
"delete",
"(",
"wa",
"*",
"watcher",
")",
"bool",
"{",
"if",
"_",
",",
"ok",
":=",
"wg",
".",
"watchers",
"[",
"wa",
"]",
";",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"wg",
".",
"watchers",
".",
"delete",
"(",
"wa",
")",
"\n",
"if",
"wa",
".",
"end",
"==",
"nil",
"{",
"wg",
".",
"keyWatchers",
".",
"delete",
"(",
"wa",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"ivl",
":=",
"adt",
".",
"NewStringAffineInterval",
"(",
"string",
"(",
"wa",
".",
"key",
")",
",",
"string",
"(",
"wa",
".",
"end",
")",
")",
"\n",
"iv",
":=",
"wg",
".",
"ranges",
".",
"Find",
"(",
"ivl",
")",
"\n",
"if",
"iv",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"ws",
":=",
"iv",
".",
"Val",
".",
"(",
"watcherSet",
")",
"\n",
"delete",
"(",
"ws",
",",
"wa",
")",
"\n",
"if",
"len",
"(",
"ws",
")",
"==",
"0",
"{",
"if",
"ok",
":=",
"wg",
".",
"ranges",
".",
"Delete",
"(",
"ivl",
")",
";",
"!",
"ok",
"{",
"panic",
"(",
"\"could not remove watcher from interval tree\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// delete removes a watcher from the group.
|
[
"delete",
"removes",
"a",
"watcher",
"from",
"the",
"group",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/watcher_group.go#L194-L220
|
test
|
etcd-io/etcd
|
mvcc/watcher_group.go
|
choose
|
func (wg *watcherGroup) choose(maxWatchers int, curRev, compactRev int64) (*watcherGroup, int64) {
if len(wg.watchers) < maxWatchers {
return wg, wg.chooseAll(curRev, compactRev)
}
ret := newWatcherGroup()
for w := range wg.watchers {
if maxWatchers <= 0 {
break
}
maxWatchers--
ret.add(w)
}
return &ret, ret.chooseAll(curRev, compactRev)
}
|
go
|
func (wg *watcherGroup) choose(maxWatchers int, curRev, compactRev int64) (*watcherGroup, int64) {
if len(wg.watchers) < maxWatchers {
return wg, wg.chooseAll(curRev, compactRev)
}
ret := newWatcherGroup()
for w := range wg.watchers {
if maxWatchers <= 0 {
break
}
maxWatchers--
ret.add(w)
}
return &ret, ret.chooseAll(curRev, compactRev)
}
|
[
"func",
"(",
"wg",
"*",
"watcherGroup",
")",
"choose",
"(",
"maxWatchers",
"int",
",",
"curRev",
",",
"compactRev",
"int64",
")",
"(",
"*",
"watcherGroup",
",",
"int64",
")",
"{",
"if",
"len",
"(",
"wg",
".",
"watchers",
")",
"<",
"maxWatchers",
"{",
"return",
"wg",
",",
"wg",
".",
"chooseAll",
"(",
"curRev",
",",
"compactRev",
")",
"\n",
"}",
"\n",
"ret",
":=",
"newWatcherGroup",
"(",
")",
"\n",
"for",
"w",
":=",
"range",
"wg",
".",
"watchers",
"{",
"if",
"maxWatchers",
"<=",
"0",
"{",
"break",
"\n",
"}",
"\n",
"maxWatchers",
"--",
"\n",
"ret",
".",
"add",
"(",
"w",
")",
"\n",
"}",
"\n",
"return",
"&",
"ret",
",",
"ret",
".",
"chooseAll",
"(",
"curRev",
",",
"compactRev",
")",
"\n",
"}"
] |
// choose selects watchers from the watcher group to update
|
[
"choose",
"selects",
"watchers",
"from",
"the",
"watcher",
"group",
"to",
"update"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/watcher_group.go#L223-L236
|
test
|
etcd-io/etcd
|
mvcc/watcher_group.go
|
watcherSetByKey
|
func (wg *watcherGroup) watcherSetByKey(key string) watcherSet {
wkeys := wg.keyWatchers[key]
wranges := wg.ranges.Stab(adt.NewStringAffinePoint(key))
// zero-copy cases
switch {
case len(wranges) == 0:
// no need to merge ranges or copy; reuse single-key set
return wkeys
case len(wranges) == 0 && len(wkeys) == 0:
return nil
case len(wranges) == 1 && len(wkeys) == 0:
return wranges[0].Val.(watcherSet)
}
// copy case
ret := make(watcherSet)
ret.union(wg.keyWatchers[key])
for _, item := range wranges {
ret.union(item.Val.(watcherSet))
}
return ret
}
|
go
|
func (wg *watcherGroup) watcherSetByKey(key string) watcherSet {
wkeys := wg.keyWatchers[key]
wranges := wg.ranges.Stab(adt.NewStringAffinePoint(key))
// zero-copy cases
switch {
case len(wranges) == 0:
// no need to merge ranges or copy; reuse single-key set
return wkeys
case len(wranges) == 0 && len(wkeys) == 0:
return nil
case len(wranges) == 1 && len(wkeys) == 0:
return wranges[0].Val.(watcherSet)
}
// copy case
ret := make(watcherSet)
ret.union(wg.keyWatchers[key])
for _, item := range wranges {
ret.union(item.Val.(watcherSet))
}
return ret
}
|
[
"func",
"(",
"wg",
"*",
"watcherGroup",
")",
"watcherSetByKey",
"(",
"key",
"string",
")",
"watcherSet",
"{",
"wkeys",
":=",
"wg",
".",
"keyWatchers",
"[",
"key",
"]",
"\n",
"wranges",
":=",
"wg",
".",
"ranges",
".",
"Stab",
"(",
"adt",
".",
"NewStringAffinePoint",
"(",
"key",
")",
")",
"\n",
"switch",
"{",
"case",
"len",
"(",
"wranges",
")",
"==",
"0",
":",
"return",
"wkeys",
"\n",
"case",
"len",
"(",
"wranges",
")",
"==",
"0",
"&&",
"len",
"(",
"wkeys",
")",
"==",
"0",
":",
"return",
"nil",
"\n",
"case",
"len",
"(",
"wranges",
")",
"==",
"1",
"&&",
"len",
"(",
"wkeys",
")",
"==",
"0",
":",
"return",
"wranges",
"[",
"0",
"]",
".",
"Val",
".",
"(",
"watcherSet",
")",
"\n",
"}",
"\n",
"ret",
":=",
"make",
"(",
"watcherSet",
")",
"\n",
"ret",
".",
"union",
"(",
"wg",
".",
"keyWatchers",
"[",
"key",
"]",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"wranges",
"{",
"ret",
".",
"union",
"(",
"item",
".",
"Val",
".",
"(",
"watcherSet",
")",
")",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] |
// watcherSetByKey gets the set of watchers that receive events on the given key.
|
[
"watcherSetByKey",
"gets",
"the",
"set",
"of",
"watchers",
"that",
"receive",
"events",
"on",
"the",
"given",
"key",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/watcher_group.go#L270-L292
|
test
|
etcd-io/etcd
|
pkg/adt/interval_tree.go
|
Compare
|
func (ivl *Interval) Compare(c Comparable) int {
ivl2 := c.(*Interval)
ivbCmpBegin := ivl.Begin.Compare(ivl2.Begin)
ivbCmpEnd := ivl.Begin.Compare(ivl2.End)
iveCmpBegin := ivl.End.Compare(ivl2.Begin)
// ivl is left of ivl2
if ivbCmpBegin < 0 && iveCmpBegin <= 0 {
return -1
}
// iv is right of iv2
if ivbCmpEnd >= 0 {
return 1
}
return 0
}
|
go
|
func (ivl *Interval) Compare(c Comparable) int {
ivl2 := c.(*Interval)
ivbCmpBegin := ivl.Begin.Compare(ivl2.Begin)
ivbCmpEnd := ivl.Begin.Compare(ivl2.End)
iveCmpBegin := ivl.End.Compare(ivl2.Begin)
// ivl is left of ivl2
if ivbCmpBegin < 0 && iveCmpBegin <= 0 {
return -1
}
// iv is right of iv2
if ivbCmpEnd >= 0 {
return 1
}
return 0
}
|
[
"func",
"(",
"ivl",
"*",
"Interval",
")",
"Compare",
"(",
"c",
"Comparable",
")",
"int",
"{",
"ivl2",
":=",
"c",
".",
"(",
"*",
"Interval",
")",
"\n",
"ivbCmpBegin",
":=",
"ivl",
".",
"Begin",
".",
"Compare",
"(",
"ivl2",
".",
"Begin",
")",
"\n",
"ivbCmpEnd",
":=",
"ivl",
".",
"Begin",
".",
"Compare",
"(",
"ivl2",
".",
"End",
")",
"\n",
"iveCmpBegin",
":=",
"ivl",
".",
"End",
".",
"Compare",
"(",
"ivl2",
".",
"Begin",
")",
"\n",
"if",
"ivbCmpBegin",
"<",
"0",
"&&",
"iveCmpBegin",
"<=",
"0",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n",
"if",
"ivbCmpEnd",
">=",
"0",
"{",
"return",
"1",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"}"
] |
// Compare on an interval gives == if the interval overlaps.
|
[
"Compare",
"on",
"an",
"interval",
"gives",
"==",
"if",
"the",
"interval",
"overlaps",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L46-L63
|
test
|
etcd-io/etcd
|
pkg/adt/interval_tree.go
|
successor
|
func (x *intervalNode) successor() *intervalNode {
if x.right != nil {
return x.right.min()
}
y := x.parent
for y != nil && x == y.right {
x = y
y = y.parent
}
return y
}
|
go
|
func (x *intervalNode) successor() *intervalNode {
if x.right != nil {
return x.right.min()
}
y := x.parent
for y != nil && x == y.right {
x = y
y = y.parent
}
return y
}
|
[
"func",
"(",
"x",
"*",
"intervalNode",
")",
"successor",
"(",
")",
"*",
"intervalNode",
"{",
"if",
"x",
".",
"right",
"!=",
"nil",
"{",
"return",
"x",
".",
"right",
".",
"min",
"(",
")",
"\n",
"}",
"\n",
"y",
":=",
"x",
".",
"parent",
"\n",
"for",
"y",
"!=",
"nil",
"&&",
"x",
"==",
"y",
".",
"right",
"{",
"x",
"=",
"y",
"\n",
"y",
"=",
"y",
".",
"parent",
"\n",
"}",
"\n",
"return",
"y",
"\n",
"}"
] |
// successor is the next in-order node in the tree
|
[
"successor",
"is",
"the",
"next",
"in",
"-",
"order",
"node",
"in",
"the",
"tree"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L104-L114
|
test
|
etcd-io/etcd
|
pkg/adt/interval_tree.go
|
updateMax
|
func (x *intervalNode) updateMax() {
for x != nil {
oldmax := x.max
max := x.iv.Ivl.End
if x.left != nil && x.left.max.Compare(max) > 0 {
max = x.left.max
}
if x.right != nil && x.right.max.Compare(max) > 0 {
max = x.right.max
}
if oldmax.Compare(max) == 0 {
break
}
x.max = max
x = x.parent
}
}
|
go
|
func (x *intervalNode) updateMax() {
for x != nil {
oldmax := x.max
max := x.iv.Ivl.End
if x.left != nil && x.left.max.Compare(max) > 0 {
max = x.left.max
}
if x.right != nil && x.right.max.Compare(max) > 0 {
max = x.right.max
}
if oldmax.Compare(max) == 0 {
break
}
x.max = max
x = x.parent
}
}
|
[
"func",
"(",
"x",
"*",
"intervalNode",
")",
"updateMax",
"(",
")",
"{",
"for",
"x",
"!=",
"nil",
"{",
"oldmax",
":=",
"x",
".",
"max",
"\n",
"max",
":=",
"x",
".",
"iv",
".",
"Ivl",
".",
"End",
"\n",
"if",
"x",
".",
"left",
"!=",
"nil",
"&&",
"x",
".",
"left",
".",
"max",
".",
"Compare",
"(",
"max",
")",
">",
"0",
"{",
"max",
"=",
"x",
".",
"left",
".",
"max",
"\n",
"}",
"\n",
"if",
"x",
".",
"right",
"!=",
"nil",
"&&",
"x",
".",
"right",
".",
"max",
".",
"Compare",
"(",
"max",
")",
">",
"0",
"{",
"max",
"=",
"x",
".",
"right",
".",
"max",
"\n",
"}",
"\n",
"if",
"oldmax",
".",
"Compare",
"(",
"max",
")",
"==",
"0",
"{",
"break",
"\n",
"}",
"\n",
"x",
".",
"max",
"=",
"max",
"\n",
"x",
"=",
"x",
".",
"parent",
"\n",
"}",
"\n",
"}"
] |
// updateMax updates the maximum values for a node and its ancestors
|
[
"updateMax",
"updates",
"the",
"maximum",
"values",
"for",
"a",
"node",
"and",
"its",
"ancestors"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L117-L133
|
test
|
etcd-io/etcd
|
pkg/adt/interval_tree.go
|
visit
|
func (x *intervalNode) visit(iv *Interval, nv nodeVisitor) bool {
if x == nil {
return true
}
v := iv.Compare(&x.iv.Ivl)
switch {
case v < 0:
if !x.left.visit(iv, nv) {
return false
}
case v > 0:
maxiv := Interval{x.iv.Ivl.Begin, x.max}
if maxiv.Compare(iv) == 0 {
if !x.left.visit(iv, nv) || !x.right.visit(iv, nv) {
return false
}
}
default:
if !x.left.visit(iv, nv) || !nv(x) || !x.right.visit(iv, nv) {
return false
}
}
return true
}
|
go
|
func (x *intervalNode) visit(iv *Interval, nv nodeVisitor) bool {
if x == nil {
return true
}
v := iv.Compare(&x.iv.Ivl)
switch {
case v < 0:
if !x.left.visit(iv, nv) {
return false
}
case v > 0:
maxiv := Interval{x.iv.Ivl.Begin, x.max}
if maxiv.Compare(iv) == 0 {
if !x.left.visit(iv, nv) || !x.right.visit(iv, nv) {
return false
}
}
default:
if !x.left.visit(iv, nv) || !nv(x) || !x.right.visit(iv, nv) {
return false
}
}
return true
}
|
[
"func",
"(",
"x",
"*",
"intervalNode",
")",
"visit",
"(",
"iv",
"*",
"Interval",
",",
"nv",
"nodeVisitor",
")",
"bool",
"{",
"if",
"x",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"v",
":=",
"iv",
".",
"Compare",
"(",
"&",
"x",
".",
"iv",
".",
"Ivl",
")",
"\n",
"switch",
"{",
"case",
"v",
"<",
"0",
":",
"if",
"!",
"x",
".",
"left",
".",
"visit",
"(",
"iv",
",",
"nv",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"case",
"v",
">",
"0",
":",
"maxiv",
":=",
"Interval",
"{",
"x",
".",
"iv",
".",
"Ivl",
".",
"Begin",
",",
"x",
".",
"max",
"}",
"\n",
"if",
"maxiv",
".",
"Compare",
"(",
"iv",
")",
"==",
"0",
"{",
"if",
"!",
"x",
".",
"left",
".",
"visit",
"(",
"iv",
",",
"nv",
")",
"||",
"!",
"x",
".",
"right",
".",
"visit",
"(",
"iv",
",",
"nv",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"if",
"!",
"x",
".",
"left",
".",
"visit",
"(",
"iv",
",",
"nv",
")",
"||",
"!",
"nv",
"(",
"x",
")",
"||",
"!",
"x",
".",
"right",
".",
"visit",
"(",
"iv",
",",
"nv",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// visit will call a node visitor on each node that overlaps the given interval
|
[
"visit",
"will",
"call",
"a",
"node",
"visitor",
"on",
"each",
"node",
"that",
"overlaps",
"the",
"given",
"interval"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L138-L161
|
test
|
etcd-io/etcd
|
pkg/adt/interval_tree.go
|
Delete
|
func (ivt *IntervalTree) Delete(ivl Interval) bool {
z := ivt.find(ivl)
if z == nil {
return false
}
y := z
if z.left != nil && z.right != nil {
y = z.successor()
}
x := y.left
if x == nil {
x = y.right
}
if x != nil {
x.parent = y.parent
}
if y.parent == nil {
ivt.root = x
} else {
if y == y.parent.left {
y.parent.left = x
} else {
y.parent.right = x
}
y.parent.updateMax()
}
if y != z {
z.iv = y.iv
z.updateMax()
}
if y.color() == black && x != nil {
ivt.deleteFixup(x)
}
ivt.count--
return true
}
|
go
|
func (ivt *IntervalTree) Delete(ivl Interval) bool {
z := ivt.find(ivl)
if z == nil {
return false
}
y := z
if z.left != nil && z.right != nil {
y = z.successor()
}
x := y.left
if x == nil {
x = y.right
}
if x != nil {
x.parent = y.parent
}
if y.parent == nil {
ivt.root = x
} else {
if y == y.parent.left {
y.parent.left = x
} else {
y.parent.right = x
}
y.parent.updateMax()
}
if y != z {
z.iv = y.iv
z.updateMax()
}
if y.color() == black && x != nil {
ivt.deleteFixup(x)
}
ivt.count--
return true
}
|
[
"func",
"(",
"ivt",
"*",
"IntervalTree",
")",
"Delete",
"(",
"ivl",
"Interval",
")",
"bool",
"{",
"z",
":=",
"ivt",
".",
"find",
"(",
"ivl",
")",
"\n",
"if",
"z",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"y",
":=",
"z",
"\n",
"if",
"z",
".",
"left",
"!=",
"nil",
"&&",
"z",
".",
"right",
"!=",
"nil",
"{",
"y",
"=",
"z",
".",
"successor",
"(",
")",
"\n",
"}",
"\n",
"x",
":=",
"y",
".",
"left",
"\n",
"if",
"x",
"==",
"nil",
"{",
"x",
"=",
"y",
".",
"right",
"\n",
"}",
"\n",
"if",
"x",
"!=",
"nil",
"{",
"x",
".",
"parent",
"=",
"y",
".",
"parent",
"\n",
"}",
"\n",
"if",
"y",
".",
"parent",
"==",
"nil",
"{",
"ivt",
".",
"root",
"=",
"x",
"\n",
"}",
"else",
"{",
"if",
"y",
"==",
"y",
".",
"parent",
".",
"left",
"{",
"y",
".",
"parent",
".",
"left",
"=",
"x",
"\n",
"}",
"else",
"{",
"y",
".",
"parent",
".",
"right",
"=",
"x",
"\n",
"}",
"\n",
"y",
".",
"parent",
".",
"updateMax",
"(",
")",
"\n",
"}",
"\n",
"if",
"y",
"!=",
"z",
"{",
"z",
".",
"iv",
"=",
"y",
".",
"iv",
"\n",
"z",
".",
"updateMax",
"(",
")",
"\n",
"}",
"\n",
"if",
"y",
".",
"color",
"(",
")",
"==",
"black",
"&&",
"x",
"!=",
"nil",
"{",
"ivt",
".",
"deleteFixup",
"(",
"x",
")",
"\n",
"}",
"\n",
"ivt",
".",
"count",
"--",
"\n",
"return",
"true",
"\n",
"}"
] |
// Delete removes the node with the given interval from the tree, returning
// true if a node is in fact removed.
|
[
"Delete",
"removes",
"the",
"node",
"with",
"the",
"given",
"interval",
"from",
"the",
"tree",
"returning",
"true",
"if",
"a",
"node",
"is",
"in",
"fact",
"removed",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L178-L218
|
test
|
etcd-io/etcd
|
pkg/adt/interval_tree.go
|
Insert
|
func (ivt *IntervalTree) Insert(ivl Interval, val interface{}) {
var y *intervalNode
z := &intervalNode{iv: IntervalValue{ivl, val}, max: ivl.End, c: red}
x := ivt.root
for x != nil {
y = x
if z.iv.Ivl.Begin.Compare(x.iv.Ivl.Begin) < 0 {
x = x.left
} else {
x = x.right
}
}
z.parent = y
if y == nil {
ivt.root = z
} else {
if z.iv.Ivl.Begin.Compare(y.iv.Ivl.Begin) < 0 {
y.left = z
} else {
y.right = z
}
y.updateMax()
}
z.c = red
ivt.insertFixup(z)
ivt.count++
}
|
go
|
func (ivt *IntervalTree) Insert(ivl Interval, val interface{}) {
var y *intervalNode
z := &intervalNode{iv: IntervalValue{ivl, val}, max: ivl.End, c: red}
x := ivt.root
for x != nil {
y = x
if z.iv.Ivl.Begin.Compare(x.iv.Ivl.Begin) < 0 {
x = x.left
} else {
x = x.right
}
}
z.parent = y
if y == nil {
ivt.root = z
} else {
if z.iv.Ivl.Begin.Compare(y.iv.Ivl.Begin) < 0 {
y.left = z
} else {
y.right = z
}
y.updateMax()
}
z.c = red
ivt.insertFixup(z)
ivt.count++
}
|
[
"func",
"(",
"ivt",
"*",
"IntervalTree",
")",
"Insert",
"(",
"ivl",
"Interval",
",",
"val",
"interface",
"{",
"}",
")",
"{",
"var",
"y",
"*",
"intervalNode",
"\n",
"z",
":=",
"&",
"intervalNode",
"{",
"iv",
":",
"IntervalValue",
"{",
"ivl",
",",
"val",
"}",
",",
"max",
":",
"ivl",
".",
"End",
",",
"c",
":",
"red",
"}",
"\n",
"x",
":=",
"ivt",
".",
"root",
"\n",
"for",
"x",
"!=",
"nil",
"{",
"y",
"=",
"x",
"\n",
"if",
"z",
".",
"iv",
".",
"Ivl",
".",
"Begin",
".",
"Compare",
"(",
"x",
".",
"iv",
".",
"Ivl",
".",
"Begin",
")",
"<",
"0",
"{",
"x",
"=",
"x",
".",
"left",
"\n",
"}",
"else",
"{",
"x",
"=",
"x",
".",
"right",
"\n",
"}",
"\n",
"}",
"\n",
"z",
".",
"parent",
"=",
"y",
"\n",
"if",
"y",
"==",
"nil",
"{",
"ivt",
".",
"root",
"=",
"z",
"\n",
"}",
"else",
"{",
"if",
"z",
".",
"iv",
".",
"Ivl",
".",
"Begin",
".",
"Compare",
"(",
"y",
".",
"iv",
".",
"Ivl",
".",
"Begin",
")",
"<",
"0",
"{",
"y",
".",
"left",
"=",
"z",
"\n",
"}",
"else",
"{",
"y",
".",
"right",
"=",
"z",
"\n",
"}",
"\n",
"y",
".",
"updateMax",
"(",
")",
"\n",
"}",
"\n",
"z",
".",
"c",
"=",
"red",
"\n",
"ivt",
".",
"insertFixup",
"(",
"z",
")",
"\n",
"ivt",
".",
"count",
"++",
"\n",
"}"
] |
// Insert adds a node with the given interval into the tree.
|
[
"Insert",
"adds",
"a",
"node",
"with",
"the",
"given",
"interval",
"into",
"the",
"tree",
"."
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L285-L312
|
test
|
etcd-io/etcd
|
pkg/adt/interval_tree.go
|
rotateLeft
|
func (ivt *IntervalTree) rotateLeft(x *intervalNode) {
y := x.right
x.right = y.left
if y.left != nil {
y.left.parent = x
}
x.updateMax()
ivt.replaceParent(x, y)
y.left = x
y.updateMax()
}
|
go
|
func (ivt *IntervalTree) rotateLeft(x *intervalNode) {
y := x.right
x.right = y.left
if y.left != nil {
y.left.parent = x
}
x.updateMax()
ivt.replaceParent(x, y)
y.left = x
y.updateMax()
}
|
[
"func",
"(",
"ivt",
"*",
"IntervalTree",
")",
"rotateLeft",
"(",
"x",
"*",
"intervalNode",
")",
"{",
"y",
":=",
"x",
".",
"right",
"\n",
"x",
".",
"right",
"=",
"y",
".",
"left",
"\n",
"if",
"y",
".",
"left",
"!=",
"nil",
"{",
"y",
".",
"left",
".",
"parent",
"=",
"x",
"\n",
"}",
"\n",
"x",
".",
"updateMax",
"(",
")",
"\n",
"ivt",
".",
"replaceParent",
"(",
"x",
",",
"y",
")",
"\n",
"y",
".",
"left",
"=",
"x",
"\n",
"y",
".",
"updateMax",
"(",
")",
"\n",
"}"
] |
// rotateLeft moves x so it is left of its right child
|
[
"rotateLeft",
"moves",
"x",
"so",
"it",
"is",
"left",
"of",
"its",
"right",
"child"
] |
616592d9ba993e3fe9798eef581316016df98906
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L355-L365
|
test
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.