repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
maxence-charriere/app
|
internal/http/gzip.go
|
GzipHandler
|
func GzipHandler(h http.Handler, webDir string) http.Handler {
return &gzipHandler{
Handler: h,
webDir: webDir,
}
}
|
go
|
func GzipHandler(h http.Handler, webDir string) http.Handler {
return &gzipHandler{
Handler: h,
webDir: webDir,
}
}
|
[
"func",
"GzipHandler",
"(",
"h",
"http",
".",
"Handler",
",",
"webDir",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"&",
"gzipHandler",
"{",
"Handler",
":",
"h",
",",
"webDir",
":",
"webDir",
",",
"}",
"\n",
"}"
] |
// GzipHandler returns a decorated version of the given handler that serves
// available gzipped static resources.
|
[
"GzipHandler",
"returns",
"a",
"decorated",
"version",
"of",
"the",
"given",
"handler",
"that",
"serves",
"available",
"gzipped",
"static",
"resources",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/gzip.go#L14-L19
|
train
|
maxence-charriere/app
|
event.go
|
Subscribe
|
func (s *Subscriber) Subscribe(e Event, f interface{}) *Subscriber {
unsubscribe := s.events.subscribe(e, f)
s.unsuscribes = append(s.unsuscribes, unsubscribe)
return s
}
|
go
|
func (s *Subscriber) Subscribe(e Event, f interface{}) *Subscriber {
unsubscribe := s.events.subscribe(e, f)
s.unsuscribes = append(s.unsuscribes, unsubscribe)
return s
}
|
[
"func",
"(",
"s",
"*",
"Subscriber",
")",
"Subscribe",
"(",
"e",
"Event",
",",
"f",
"interface",
"{",
"}",
")",
"*",
"Subscriber",
"{",
"unsubscribe",
":=",
"s",
".",
"events",
".",
"subscribe",
"(",
"e",
",",
"f",
")",
"\n",
"s",
".",
"unsuscribes",
"=",
"append",
"(",
"s",
".",
"unsuscribes",
",",
"unsubscribe",
")",
"\n",
"return",
"s",
"\n",
"}"
] |
// Subscribe subscribes a function to the given event. Emit fails if the
// subscribed func have more arguments than the emitted event.
//
// Panics if f is not a func.
|
[
"Subscribe",
"subscribes",
"a",
"function",
"to",
"the",
"given",
"event",
".",
"Emit",
"fails",
"if",
"the",
"subscribed",
"func",
"have",
"more",
"arguments",
"than",
"the",
"emitted",
"event",
".",
"Panics",
"if",
"f",
"is",
"not",
"a",
"func",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/event.go#L24-L28
|
train
|
maxence-charriere/app
|
event.go
|
Emit
|
func (r *eventRegistry) Emit(e Event, args ...interface{}) {
r.mutex.RLock()
defer r.mutex.RUnlock()
for _, h := range r.handlers[e] {
if err := r.callHandler(h.MsgHandler, args...); err != nil {
Logf("emitting %s failed: %s", e, err)
}
}
}
|
go
|
func (r *eventRegistry) Emit(e Event, args ...interface{}) {
r.mutex.RLock()
defer r.mutex.RUnlock()
for _, h := range r.handlers[e] {
if err := r.callHandler(h.MsgHandler, args...); err != nil {
Logf("emitting %s failed: %s", e, err)
}
}
}
|
[
"func",
"(",
"r",
"*",
"eventRegistry",
")",
"Emit",
"(",
"e",
"Event",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"r",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"r",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"h",
":=",
"range",
"r",
".",
"handlers",
"[",
"e",
"]",
"{",
"if",
"err",
":=",
"r",
".",
"callHandler",
"(",
"h",
".",
"MsgHandler",
",",
"args",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"Logf",
"(",
"\"",
"\"",
",",
"e",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Emit emits the event with the given arguments.
|
[
"Emit",
"emits",
"the",
"event",
"with",
"the",
"given",
"arguments",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/event.go#L101-L110
|
train
|
maxence-charriere/app
|
demo/cmd/demo-wasm/main.go
|
main
|
func main() {
// Imports the hello component declared above in order to make it loadable
// in a page or usable in other components.
//
// Imported component can be used as URL or html tags by referencing them by
// their lowercased names.
// E.g:
// Hello => hello
// foo.Bar => foo.bar
app.Import(&Hello{})
// Defines the component to load when an URL without path is loaded.
app.DefaultPath = "/hello"
// Runs the app in the browser.
if err := app.Run(); err != nil {
log.Print(err)
}
}
|
go
|
func main() {
// Imports the hello component declared above in order to make it loadable
// in a page or usable in other components.
//
// Imported component can be used as URL or html tags by referencing them by
// their lowercased names.
// E.g:
// Hello => hello
// foo.Bar => foo.bar
app.Import(&Hello{})
// Defines the component to load when an URL without path is loaded.
app.DefaultPath = "/hello"
// Runs the app in the browser.
if err := app.Run(); err != nil {
log.Print(err)
}
}
|
[
"func",
"main",
"(",
")",
"{",
"// Imports the hello component declared above in order to make it loadable",
"// in a page or usable in other components.",
"//",
"// Imported component can be used as URL or html tags by referencing them by",
"// their lowercased names.",
"// E.g:",
"// Hello => hello",
"// foo.Bar => foo.bar",
"app",
".",
"Import",
"(",
"&",
"Hello",
"{",
"}",
")",
"\n\n",
"// Defines the component to load when an URL without path is loaded.",
"app",
".",
"DefaultPath",
"=",
"\"",
"\"",
"\n\n",
"// Runs the app in the browser.",
"if",
"err",
":=",
"app",
".",
"Run",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// The app entry point.
|
[
"The",
"app",
"entry",
"point",
"."
] |
a4bd499377b93214614b805d3c2c74e0fea2379d
|
https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/demo/cmd/demo-wasm/main.go#L10-L28
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
New
|
func New(cfg *Config) *Transport {
ctx, cancel := context.WithCancel(context.Background())
if cfg.RaftID != "" {
ctx = log.WithField(ctx, "raft_id", cfg.RaftID)
}
t := &Transport{
peers: make(map[uint64]*peer),
config: cfg,
unknownc: make(chan raftpb.Message),
done: make(chan struct{}),
ctx: ctx,
cancel: cancel,
deferredConns: make(map[*grpc.ClientConn]*time.Timer),
}
go t.run(ctx)
return t
}
|
go
|
func New(cfg *Config) *Transport {
ctx, cancel := context.WithCancel(context.Background())
if cfg.RaftID != "" {
ctx = log.WithField(ctx, "raft_id", cfg.RaftID)
}
t := &Transport{
peers: make(map[uint64]*peer),
config: cfg,
unknownc: make(chan raftpb.Message),
done: make(chan struct{}),
ctx: ctx,
cancel: cancel,
deferredConns: make(map[*grpc.ClientConn]*time.Timer),
}
go t.run(ctx)
return t
}
|
[
"func",
"New",
"(",
"cfg",
"*",
"Config",
")",
"*",
"Transport",
"{",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"if",
"cfg",
".",
"RaftID",
"!=",
"\"",
"\"",
"{",
"ctx",
"=",
"log",
".",
"WithField",
"(",
"ctx",
",",
"\"",
"\"",
",",
"cfg",
".",
"RaftID",
")",
"\n",
"}",
"\n",
"t",
":=",
"&",
"Transport",
"{",
"peers",
":",
"make",
"(",
"map",
"[",
"uint64",
"]",
"*",
"peer",
")",
",",
"config",
":",
"cfg",
",",
"unknownc",
":",
"make",
"(",
"chan",
"raftpb",
".",
"Message",
")",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"ctx",
":",
"ctx",
",",
"cancel",
":",
"cancel",
",",
"deferredConns",
":",
"make",
"(",
"map",
"[",
"*",
"grpc",
".",
"ClientConn",
"]",
"*",
"time",
".",
"Timer",
")",
",",
"}",
"\n",
"go",
"t",
".",
"run",
"(",
"ctx",
")",
"\n",
"return",
"t",
"\n",
"}"
] |
// New returns new Transport with specified Config.
|
[
"New",
"returns",
"new",
"Transport",
"with",
"specified",
"Config",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L64-L81
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
Send
|
func (t *Transport) Send(m raftpb.Message) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
if t.config.IsIDRemoved(m.To) {
return errors.Errorf("refusing to send message %s to removed member %x", m.Type, m.To)
}
p, ok := t.peers[m.To]
if !ok {
log.G(t.ctx).Warningf("sending message %s to an unrecognized member ID %x", m.Type, m.To)
select {
// we need to process messages to unknown peers in separate goroutine
// to not block sender
case t.unknownc <- m:
case <-t.ctx.Done():
return t.ctx.Err()
default:
return errors.New("unknown messages queue is full")
}
return nil
}
if err := p.send(m); err != nil {
return errors.Wrapf(err, "failed to send message %x to %x", m.Type, m.To)
}
return nil
}
|
go
|
func (t *Transport) Send(m raftpb.Message) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
if t.config.IsIDRemoved(m.To) {
return errors.Errorf("refusing to send message %s to removed member %x", m.Type, m.To)
}
p, ok := t.peers[m.To]
if !ok {
log.G(t.ctx).Warningf("sending message %s to an unrecognized member ID %x", m.Type, m.To)
select {
// we need to process messages to unknown peers in separate goroutine
// to not block sender
case t.unknownc <- m:
case <-t.ctx.Done():
return t.ctx.Err()
default:
return errors.New("unknown messages queue is full")
}
return nil
}
if err := p.send(m); err != nil {
return errors.Wrapf(err, "failed to send message %x to %x", m.Type, m.To)
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"Send",
"(",
"m",
"raftpb",
".",
"Message",
")",
"error",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"t",
".",
"stopped",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"t",
".",
"config",
".",
"IsIDRemoved",
"(",
"m",
".",
"To",
")",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Type",
",",
"m",
".",
"To",
")",
"\n",
"}",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"m",
".",
"To",
"]",
"\n",
"if",
"!",
"ok",
"{",
"log",
".",
"G",
"(",
"t",
".",
"ctx",
")",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"m",
".",
"Type",
",",
"m",
".",
"To",
")",
"\n",
"select",
"{",
"// we need to process messages to unknown peers in separate goroutine",
"// to not block sender",
"case",
"t",
".",
"unknownc",
"<-",
"m",
":",
"case",
"<-",
"t",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"t",
".",
"ctx",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"p",
".",
"send",
"(",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"m",
".",
"Type",
",",
"m",
".",
"To",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Send sends raft message to remote peers.
|
[
"Send",
"sends",
"raft",
"message",
"to",
"remote",
"peers",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L125-L152
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
RemovePeer
|
func (t *Transport) RemovePeer(id uint64) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
delete(t.peers, id)
cc := p.conn()
p.stop()
timer := time.AfterFunc(8*time.Second, func() {
t.mu.Lock()
if !t.stopped {
delete(t.deferredConns, cc)
cc.Close()
}
t.mu.Unlock()
})
// store connection and timer for cleaning up on stop
t.deferredConns[cc] = timer
return nil
}
|
go
|
func (t *Transport) RemovePeer(id uint64) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
delete(t.peers, id)
cc := p.conn()
p.stop()
timer := time.AfterFunc(8*time.Second, func() {
t.mu.Lock()
if !t.stopped {
delete(t.deferredConns, cc)
cc.Close()
}
t.mu.Unlock()
})
// store connection and timer for cleaning up on stop
t.deferredConns[cc] = timer
return nil
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"RemovePeer",
"(",
"id",
"uint64",
")",
"error",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"t",
".",
"stopped",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrIsNotFound",
"\n",
"}",
"\n",
"delete",
"(",
"t",
".",
"peers",
",",
"id",
")",
"\n",
"cc",
":=",
"p",
".",
"conn",
"(",
")",
"\n",
"p",
".",
"stop",
"(",
")",
"\n",
"timer",
":=",
"time",
".",
"AfterFunc",
"(",
"8",
"*",
"time",
".",
"Second",
",",
"func",
"(",
")",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"!",
"t",
".",
"stopped",
"{",
"delete",
"(",
"t",
".",
"deferredConns",
",",
"cc",
")",
"\n",
"cc",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}",
")",
"\n",
"// store connection and timer for cleaning up on stop",
"t",
".",
"deferredConns",
"[",
"cc",
"]",
"=",
"timer",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// RemovePeer removes peer from Transport and wait for it to stop.
|
[
"RemovePeer",
"removes",
"peer",
"from",
"Transport",
"and",
"wait",
"for",
"it",
"to",
"stop",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L179-L205
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
UpdatePeer
|
func (t *Transport) UpdatePeer(id uint64, addr string) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
if err := p.update(addr); err != nil {
return err
}
log.G(t.ctx).Debugf("peer %x updated to address %s", id, addr)
return nil
}
|
go
|
func (t *Transport) UpdatePeer(id uint64, addr string) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
if err := p.update(addr); err != nil {
return err
}
log.G(t.ctx).Debugf("peer %x updated to address %s", id, addr)
return nil
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"UpdatePeer",
"(",
"id",
"uint64",
",",
"addr",
"string",
")",
"error",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"t",
".",
"stopped",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrIsNotFound",
"\n",
"}",
"\n",
"if",
"err",
":=",
"p",
".",
"update",
"(",
"addr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"log",
".",
"G",
"(",
"t",
".",
"ctx",
")",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"id",
",",
"addr",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UpdatePeer updates peer with new address. It replaces connection immediately.
|
[
"UpdatePeer",
"updates",
"peer",
"with",
"new",
"address",
".",
"It",
"replaces",
"connection",
"immediately",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L208-L224
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
UpdatePeerAddr
|
func (t *Transport) UpdatePeerAddr(id uint64, addr string) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
return p.updateAddr(addr)
}
|
go
|
func (t *Transport) UpdatePeerAddr(id uint64, addr string) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.stopped {
return errors.New("transport stopped")
}
p, ok := t.peers[id]
if !ok {
return ErrIsNotFound
}
return p.updateAddr(addr)
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"UpdatePeerAddr",
"(",
"id",
"uint64",
",",
"addr",
"string",
")",
"error",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"t",
".",
"stopped",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrIsNotFound",
"\n",
"}",
"\n",
"return",
"p",
".",
"updateAddr",
"(",
"addr",
")",
"\n",
"}"
] |
// UpdatePeerAddr updates peer with new address, but delays connection creation.
// New address won't be used until first failure on old address.
|
[
"UpdatePeerAddr",
"updates",
"peer",
"with",
"new",
"address",
"but",
"delays",
"connection",
"creation",
".",
"New",
"address",
"won",
"t",
"be",
"used",
"until",
"first",
"failure",
"on",
"old",
"address",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L228-L240
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
PeerConn
|
func (t *Transport) PeerConn(id uint64) (*grpc.ClientConn, error) {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return nil, ErrIsNotFound
}
p.mu.Lock()
active := p.active
p.mu.Unlock()
if !active {
return nil, errors.New("peer is inactive")
}
return p.conn(), nil
}
|
go
|
func (t *Transport) PeerConn(id uint64) (*grpc.ClientConn, error) {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return nil, ErrIsNotFound
}
p.mu.Lock()
active := p.active
p.mu.Unlock()
if !active {
return nil, errors.New("peer is inactive")
}
return p.conn(), nil
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"PeerConn",
"(",
"id",
"uint64",
")",
"(",
"*",
"grpc",
".",
"ClientConn",
",",
"error",
")",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"ErrIsNotFound",
"\n",
"}",
"\n",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"active",
":=",
"p",
".",
"active",
"\n",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"active",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"p",
".",
"conn",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// PeerConn returns raw grpc connection to peer.
|
[
"PeerConn",
"returns",
"raw",
"grpc",
"connection",
"to",
"peer",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L243-L257
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
PeerAddr
|
func (t *Transport) PeerAddr(id uint64) (string, error) {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return "", ErrIsNotFound
}
return p.address(), nil
}
|
go
|
func (t *Transport) PeerAddr(id uint64) (string, error) {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return "", ErrIsNotFound
}
return p.address(), nil
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"PeerAddr",
"(",
"id",
"uint64",
")",
"(",
"string",
",",
"error",
")",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
",",
"ErrIsNotFound",
"\n",
"}",
"\n",
"return",
"p",
".",
"address",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// PeerAddr returns address of peer with id.
|
[
"PeerAddr",
"returns",
"address",
"of",
"peer",
"with",
"id",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L260-L268
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
HealthCheck
|
func (t *Transport) HealthCheck(ctx context.Context, id uint64) error {
t.mu.Lock()
p, ok := t.peers[id]
t.mu.Unlock()
if !ok {
return ErrIsNotFound
}
ctx, cancel := t.withContext(ctx)
defer cancel()
return p.healthCheck(ctx)
}
|
go
|
func (t *Transport) HealthCheck(ctx context.Context, id uint64) error {
t.mu.Lock()
p, ok := t.peers[id]
t.mu.Unlock()
if !ok {
return ErrIsNotFound
}
ctx, cancel := t.withContext(ctx)
defer cancel()
return p.healthCheck(ctx)
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"HealthCheck",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"uint64",
")",
"error",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrIsNotFound",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"t",
".",
"withContext",
"(",
"ctx",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"return",
"p",
".",
"healthCheck",
"(",
"ctx",
")",
"\n",
"}"
] |
// HealthCheck checks health of particular peer.
|
[
"HealthCheck",
"checks",
"health",
"of",
"particular",
"peer",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L271-L281
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
Active
|
func (t *Transport) Active(id uint64) bool {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return false
}
p.mu.Lock()
active := p.active
p.mu.Unlock()
return active
}
|
go
|
func (t *Transport) Active(id uint64) bool {
t.mu.Lock()
defer t.mu.Unlock()
p, ok := t.peers[id]
if !ok {
return false
}
p.mu.Lock()
active := p.active
p.mu.Unlock()
return active
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"Active",
"(",
"id",
"uint64",
")",
"bool",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"p",
",",
"ok",
":=",
"t",
".",
"peers",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"active",
":=",
"p",
".",
"active",
"\n",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"active",
"\n",
"}"
] |
// Active returns true if node was recently active and false otherwise.
|
[
"Active",
"returns",
"true",
"if",
"node",
"was",
"recently",
"active",
"and",
"false",
"otherwise",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L284-L295
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
LongestActive
|
func (t *Transport) LongestActive() (uint64, error) {
p, err := t.longestActive()
if err != nil {
return 0, err
}
return p.id, nil
}
|
go
|
func (t *Transport) LongestActive() (uint64, error) {
p, err := t.longestActive()
if err != nil {
return 0, err
}
return p.id, nil
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"LongestActive",
"(",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"t",
".",
"longestActive",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"id",
",",
"nil",
"\n",
"}"
] |
// LongestActive returns the ID of the peer that has been active for the longest
// length of time.
|
[
"LongestActive",
"returns",
"the",
"ID",
"of",
"the",
"peer",
"that",
"has",
"been",
"active",
"for",
"the",
"longest",
"length",
"of",
"time",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L299-L306
|
train
|
docker/swarmkit
|
manager/state/raft/transport/transport.go
|
longestActive
|
func (t *Transport) longestActive() (*peer, error) {
var longest *peer
var longestTime time.Time
t.mu.Lock()
defer t.mu.Unlock()
for _, p := range t.peers {
becameActive := p.activeTime()
if becameActive.IsZero() {
continue
}
if longest == nil {
longest = p
continue
}
if becameActive.Before(longestTime) {
longest = p
longestTime = becameActive
}
}
if longest == nil {
return nil, errors.New("failed to find longest active peer")
}
return longest, nil
}
|
go
|
func (t *Transport) longestActive() (*peer, error) {
var longest *peer
var longestTime time.Time
t.mu.Lock()
defer t.mu.Unlock()
for _, p := range t.peers {
becameActive := p.activeTime()
if becameActive.IsZero() {
continue
}
if longest == nil {
longest = p
continue
}
if becameActive.Before(longestTime) {
longest = p
longestTime = becameActive
}
}
if longest == nil {
return nil, errors.New("failed to find longest active peer")
}
return longest, nil
}
|
[
"func",
"(",
"t",
"*",
"Transport",
")",
"longestActive",
"(",
")",
"(",
"*",
"peer",
",",
"error",
")",
"{",
"var",
"longest",
"*",
"peer",
"\n",
"var",
"longestTime",
"time",
".",
"Time",
"\n",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"t",
".",
"peers",
"{",
"becameActive",
":=",
"p",
".",
"activeTime",
"(",
")",
"\n",
"if",
"becameActive",
".",
"IsZero",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"longest",
"==",
"nil",
"{",
"longest",
"=",
"p",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"becameActive",
".",
"Before",
"(",
"longestTime",
")",
"{",
"longest",
"=",
"p",
"\n",
"longestTime",
"=",
"becameActive",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"longest",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"longest",
",",
"nil",
"\n",
"}"
] |
// longestActive returns the peer that has been active for the longest length of
// time.
|
[
"longestActive",
"returns",
"the",
"peer",
"that",
"has",
"been",
"active",
"for",
"the",
"longest",
"length",
"of",
"time",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/transport/transport.go#L310-L333
|
train
|
docker/swarmkit
|
manager/state/store/extensions.go
|
EventUpdate
|
func (e extensionEntry) EventUpdate(oldObject api.StoreObject) api.Event {
if oldObject != nil {
return api.EventUpdateExtension{Extension: e.Extension, OldExtension: oldObject.(extensionEntry).Extension}
}
return api.EventUpdateExtension{Extension: e.Extension}
}
|
go
|
func (e extensionEntry) EventUpdate(oldObject api.StoreObject) api.Event {
if oldObject != nil {
return api.EventUpdateExtension{Extension: e.Extension, OldExtension: oldObject.(extensionEntry).Extension}
}
return api.EventUpdateExtension{Extension: e.Extension}
}
|
[
"func",
"(",
"e",
"extensionEntry",
")",
"EventUpdate",
"(",
"oldObject",
"api",
".",
"StoreObject",
")",
"api",
".",
"Event",
"{",
"if",
"oldObject",
"!=",
"nil",
"{",
"return",
"api",
".",
"EventUpdateExtension",
"{",
"Extension",
":",
"e",
".",
"Extension",
",",
"OldExtension",
":",
"oldObject",
".",
"(",
"extensionEntry",
")",
".",
"Extension",
"}",
"\n",
"}",
"\n",
"return",
"api",
".",
"EventUpdateExtension",
"{",
"Extension",
":",
"e",
".",
"Extension",
"}",
"\n",
"}"
] |
// ensure that when update events are emitted, we unwrap extensionEntry
|
[
"ensure",
"that",
"when",
"update",
"events",
"are",
"emitted",
"we",
"unwrap",
"extensionEntry"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/extensions.go#L74-L79
|
train
|
docker/swarmkit
|
manager/state/store/extensions.go
|
CreateExtension
|
func CreateExtension(tx Tx, e *api.Extension) error {
// Ensure the name is not already in use.
if tx.lookup(tableExtension, indexName, strings.ToLower(e.Annotations.Name)) != nil {
return ErrNameConflict
}
// It can't conflict with built-in kinds either.
if _, ok := schema.Tables[e.Annotations.Name]; ok {
return ErrNameConflict
}
return tx.create(tableExtension, extensionEntry{e})
}
|
go
|
func CreateExtension(tx Tx, e *api.Extension) error {
// Ensure the name is not already in use.
if tx.lookup(tableExtension, indexName, strings.ToLower(e.Annotations.Name)) != nil {
return ErrNameConflict
}
// It can't conflict with built-in kinds either.
if _, ok := schema.Tables[e.Annotations.Name]; ok {
return ErrNameConflict
}
return tx.create(tableExtension, extensionEntry{e})
}
|
[
"func",
"CreateExtension",
"(",
"tx",
"Tx",
",",
"e",
"*",
"api",
".",
"Extension",
")",
"error",
"{",
"// Ensure the name is not already in use.",
"if",
"tx",
".",
"lookup",
"(",
"tableExtension",
",",
"indexName",
",",
"strings",
".",
"ToLower",
"(",
"e",
".",
"Annotations",
".",
"Name",
")",
")",
"!=",
"nil",
"{",
"return",
"ErrNameConflict",
"\n",
"}",
"\n\n",
"// It can't conflict with built-in kinds either.",
"if",
"_",
",",
"ok",
":=",
"schema",
".",
"Tables",
"[",
"e",
".",
"Annotations",
".",
"Name",
"]",
";",
"ok",
"{",
"return",
"ErrNameConflict",
"\n",
"}",
"\n\n",
"return",
"tx",
".",
"create",
"(",
"tableExtension",
",",
"extensionEntry",
"{",
"e",
"}",
")",
"\n",
"}"
] |
// CreateExtension adds a new extension to the store.
// Returns ErrExist if the ID is already taken.
|
[
"CreateExtension",
"adds",
"a",
"new",
"extension",
"to",
"the",
"store",
".",
"Returns",
"ErrExist",
"if",
"the",
"ID",
"is",
"already",
"taken",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/extensions.go#L83-L95
|
train
|
docker/swarmkit
|
manager/state/store/extensions.go
|
DeleteExtension
|
func DeleteExtension(tx Tx, id string) error {
e := tx.get(tableExtension, id)
if e == nil {
return ErrNotExist
}
resources, err := FindResources(tx, ByKind(e.(extensionEntry).Annotations.Name))
if err != nil {
return err
}
if len(resources) != 0 {
return errors.New("cannot delete extension because objects of this type exist in the data store")
}
return tx.delete(tableExtension, id)
}
|
go
|
func DeleteExtension(tx Tx, id string) error {
e := tx.get(tableExtension, id)
if e == nil {
return ErrNotExist
}
resources, err := FindResources(tx, ByKind(e.(extensionEntry).Annotations.Name))
if err != nil {
return err
}
if len(resources) != 0 {
return errors.New("cannot delete extension because objects of this type exist in the data store")
}
return tx.delete(tableExtension, id)
}
|
[
"func",
"DeleteExtension",
"(",
"tx",
"Tx",
",",
"id",
"string",
")",
"error",
"{",
"e",
":=",
"tx",
".",
"get",
"(",
"tableExtension",
",",
"id",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"ErrNotExist",
"\n",
"}",
"\n\n",
"resources",
",",
"err",
":=",
"FindResources",
"(",
"tx",
",",
"ByKind",
"(",
"e",
".",
"(",
"extensionEntry",
")",
".",
"Annotations",
".",
"Name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"resources",
")",
"!=",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"tx",
".",
"delete",
"(",
"tableExtension",
",",
"id",
")",
"\n",
"}"
] |
// DeleteExtension removes an extension from the store.
// Returns ErrNotExist if the object doesn't exist.
|
[
"DeleteExtension",
"removes",
"an",
"extension",
"from",
"the",
"store",
".",
"Returns",
"ErrNotExist",
"if",
"the",
"object",
"doesn",
"t",
"exist",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/extensions.go#L106-L122
|
train
|
docker/swarmkit
|
manager/state/store/extensions.go
|
GetExtension
|
func GetExtension(tx ReadTx, id string) *api.Extension {
e := tx.get(tableExtension, id)
if e == nil {
return nil
}
return e.(extensionEntry).Extension
}
|
go
|
func GetExtension(tx ReadTx, id string) *api.Extension {
e := tx.get(tableExtension, id)
if e == nil {
return nil
}
return e.(extensionEntry).Extension
}
|
[
"func",
"GetExtension",
"(",
"tx",
"ReadTx",
",",
"id",
"string",
")",
"*",
"api",
".",
"Extension",
"{",
"e",
":=",
"tx",
".",
"get",
"(",
"tableExtension",
",",
"id",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"e",
".",
"(",
"extensionEntry",
")",
".",
"Extension",
"\n",
"}"
] |
// GetExtension looks up an extension by ID.
// Returns nil if the object doesn't exist.
|
[
"GetExtension",
"looks",
"up",
"an",
"extension",
"by",
"ID",
".",
"Returns",
"nil",
"if",
"the",
"object",
"doesn",
"t",
"exist",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/extensions.go#L126-L132
|
train
|
docker/swarmkit
|
manager/state/store/extensions.go
|
FindExtensions
|
func FindExtensions(tx ReadTx, by By) ([]*api.Extension, error) {
checkType := func(by By) error {
switch by.(type) {
case byIDPrefix, byName, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
extensionList := []*api.Extension{}
appendResult := func(o api.StoreObject) {
extensionList = append(extensionList, o.(extensionEntry).Extension)
}
err := tx.find(tableExtension, by, checkType, appendResult)
return extensionList, err
}
|
go
|
func FindExtensions(tx ReadTx, by By) ([]*api.Extension, error) {
checkType := func(by By) error {
switch by.(type) {
case byIDPrefix, byName, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
extensionList := []*api.Extension{}
appendResult := func(o api.StoreObject) {
extensionList = append(extensionList, o.(extensionEntry).Extension)
}
err := tx.find(tableExtension, by, checkType, appendResult)
return extensionList, err
}
|
[
"func",
"FindExtensions",
"(",
"tx",
"ReadTx",
",",
"by",
"By",
")",
"(",
"[",
"]",
"*",
"api",
".",
"Extension",
",",
"error",
")",
"{",
"checkType",
":=",
"func",
"(",
"by",
"By",
")",
"error",
"{",
"switch",
"by",
".",
"(",
"type",
")",
"{",
"case",
"byIDPrefix",
",",
"byName",
",",
"byCustom",
",",
"byCustomPrefix",
":",
"return",
"nil",
"\n",
"default",
":",
"return",
"ErrInvalidFindBy",
"\n",
"}",
"\n",
"}",
"\n\n",
"extensionList",
":=",
"[",
"]",
"*",
"api",
".",
"Extension",
"{",
"}",
"\n",
"appendResult",
":=",
"func",
"(",
"o",
"api",
".",
"StoreObject",
")",
"{",
"extensionList",
"=",
"append",
"(",
"extensionList",
",",
"o",
".",
"(",
"extensionEntry",
")",
".",
"Extension",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"tx",
".",
"find",
"(",
"tableExtension",
",",
"by",
",",
"checkType",
",",
"appendResult",
")",
"\n",
"return",
"extensionList",
",",
"err",
"\n",
"}"
] |
// FindExtensions selects a set of extensions and returns them.
|
[
"FindExtensions",
"selects",
"a",
"set",
"of",
"extensions",
"and",
"returns",
"them",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/extensions.go#L135-L152
|
train
|
docker/swarmkit
|
manager/controlapi/node.go
|
GetNode
|
func (s *Server) GetNode(ctx context.Context, request *api.GetNodeRequest) (*api.GetNodeResponse, error) {
if request.NodeID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var node *api.Node
s.store.View(func(tx store.ReadTx) {
node = store.GetNode(tx, request.NodeID)
})
if node == nil {
return nil, status.Errorf(codes.NotFound, "node %s not found", request.NodeID)
}
if s.raft != nil {
memberlist := s.raft.GetMemberlist()
for _, member := range memberlist {
if member.NodeID == node.ID {
node.ManagerStatus = &api.ManagerStatus{
RaftID: member.RaftID,
Addr: member.Addr,
Leader: member.Status.Leader,
Reachability: member.Status.Reachability,
}
break
}
}
}
return &api.GetNodeResponse{
Node: node,
}, nil
}
|
go
|
func (s *Server) GetNode(ctx context.Context, request *api.GetNodeRequest) (*api.GetNodeResponse, error) {
if request.NodeID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var node *api.Node
s.store.View(func(tx store.ReadTx) {
node = store.GetNode(tx, request.NodeID)
})
if node == nil {
return nil, status.Errorf(codes.NotFound, "node %s not found", request.NodeID)
}
if s.raft != nil {
memberlist := s.raft.GetMemberlist()
for _, member := range memberlist {
if member.NodeID == node.ID {
node.ManagerStatus = &api.ManagerStatus{
RaftID: member.RaftID,
Addr: member.Addr,
Leader: member.Status.Leader,
Reachability: member.Status.Reachability,
}
break
}
}
}
return &api.GetNodeResponse{
Node: node,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"GetNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"GetNodeRequest",
")",
"(",
"*",
"api",
".",
"GetNodeResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"NodeID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"errInvalidArgument",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"var",
"node",
"*",
"api",
".",
"Node",
"\n",
"s",
".",
"store",
".",
"View",
"(",
"func",
"(",
"tx",
"store",
".",
"ReadTx",
")",
"{",
"node",
"=",
"store",
".",
"GetNode",
"(",
"tx",
",",
"request",
".",
"NodeID",
")",
"\n",
"}",
")",
"\n",
"if",
"node",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"NodeID",
")",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"raft",
"!=",
"nil",
"{",
"memberlist",
":=",
"s",
".",
"raft",
".",
"GetMemberlist",
"(",
")",
"\n",
"for",
"_",
",",
"member",
":=",
"range",
"memberlist",
"{",
"if",
"member",
".",
"NodeID",
"==",
"node",
".",
"ID",
"{",
"node",
".",
"ManagerStatus",
"=",
"&",
"api",
".",
"ManagerStatus",
"{",
"RaftID",
":",
"member",
".",
"RaftID",
",",
"Addr",
":",
"member",
".",
"Addr",
",",
"Leader",
":",
"member",
".",
"Status",
".",
"Leader",
",",
"Reachability",
":",
"member",
".",
"Status",
".",
"Reachability",
",",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"GetNodeResponse",
"{",
"Node",
":",
"node",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// GetNode returns a Node given a NodeID.
// - Returns `InvalidArgument` if NodeID is not provided.
// - Returns `NotFound` if the Node is not found.
|
[
"GetNode",
"returns",
"a",
"Node",
"given",
"a",
"NodeID",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"NodeID",
"is",
"not",
"provided",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Node",
"is",
"not",
"found",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/node.go#L26-L57
|
train
|
docker/swarmkit
|
manager/controlapi/node.go
|
UpdateNode
|
func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest) (*api.UpdateNodeResponse, error) {
if request.NodeID == "" || request.NodeVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
if err := validateNodeSpec(request.Spec); err != nil {
return nil, err
}
var (
node *api.Node
member *membership.Member
)
err := s.store.Update(func(tx store.Tx) error {
node = store.GetNode(tx, request.NodeID)
if node == nil {
return status.Errorf(codes.NotFound, "node %s not found", request.NodeID)
}
// Demotion sanity checks.
if node.Spec.DesiredRole == api.NodeRoleManager && request.Spec.DesiredRole == api.NodeRoleWorker {
// Check for manager entries in Store.
managers, err := store.FindNodes(tx, store.ByRole(api.NodeRoleManager))
if err != nil {
return status.Errorf(codes.Internal, "internal store error: %v", err)
}
if len(managers) == 1 && managers[0].ID == node.ID {
return status.Errorf(codes.FailedPrecondition, "attempting to demote the last manager of the swarm")
}
// Check for node in memberlist
if member = s.raft.GetMemberByNodeID(request.NodeID); member == nil {
return status.Errorf(codes.NotFound, "can't find manager in raft memberlist")
}
// Quorum safeguard
if !s.raft.CanRemoveMember(member.RaftID) {
return status.Errorf(codes.FailedPrecondition, "can't remove member from the raft: this would result in a loss of quorum")
}
}
node.Meta.Version = *request.NodeVersion
node.Spec = *request.Spec.Copy()
return store.UpdateNode(tx, node)
})
if err != nil {
return nil, err
}
return &api.UpdateNodeResponse{
Node: node,
}, nil
}
|
go
|
func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest) (*api.UpdateNodeResponse, error) {
if request.NodeID == "" || request.NodeVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
if err := validateNodeSpec(request.Spec); err != nil {
return nil, err
}
var (
node *api.Node
member *membership.Member
)
err := s.store.Update(func(tx store.Tx) error {
node = store.GetNode(tx, request.NodeID)
if node == nil {
return status.Errorf(codes.NotFound, "node %s not found", request.NodeID)
}
// Demotion sanity checks.
if node.Spec.DesiredRole == api.NodeRoleManager && request.Spec.DesiredRole == api.NodeRoleWorker {
// Check for manager entries in Store.
managers, err := store.FindNodes(tx, store.ByRole(api.NodeRoleManager))
if err != nil {
return status.Errorf(codes.Internal, "internal store error: %v", err)
}
if len(managers) == 1 && managers[0].ID == node.ID {
return status.Errorf(codes.FailedPrecondition, "attempting to demote the last manager of the swarm")
}
// Check for node in memberlist
if member = s.raft.GetMemberByNodeID(request.NodeID); member == nil {
return status.Errorf(codes.NotFound, "can't find manager in raft memberlist")
}
// Quorum safeguard
if !s.raft.CanRemoveMember(member.RaftID) {
return status.Errorf(codes.FailedPrecondition, "can't remove member from the raft: this would result in a loss of quorum")
}
}
node.Meta.Version = *request.NodeVersion
node.Spec = *request.Spec.Copy()
return store.UpdateNode(tx, node)
})
if err != nil {
return nil, err
}
return &api.UpdateNodeResponse{
Node: node,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"UpdateNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"UpdateNodeRequest",
")",
"(",
"*",
"api",
".",
"UpdateNodeResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"NodeID",
"==",
"\"",
"\"",
"||",
"request",
".",
"NodeVersion",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"errInvalidArgument",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateNodeSpec",
"(",
"request",
".",
"Spec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"(",
"node",
"*",
"api",
".",
"Node",
"\n",
"member",
"*",
"membership",
".",
"Member",
"\n",
")",
"\n\n",
"err",
":=",
"s",
".",
"store",
".",
"Update",
"(",
"func",
"(",
"tx",
"store",
".",
"Tx",
")",
"error",
"{",
"node",
"=",
"store",
".",
"GetNode",
"(",
"tx",
",",
"request",
".",
"NodeID",
")",
"\n",
"if",
"node",
"==",
"nil",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"NodeID",
")",
"\n",
"}",
"\n\n",
"// Demotion sanity checks.",
"if",
"node",
".",
"Spec",
".",
"DesiredRole",
"==",
"api",
".",
"NodeRoleManager",
"&&",
"request",
".",
"Spec",
".",
"DesiredRole",
"==",
"api",
".",
"NodeRoleWorker",
"{",
"// Check for manager entries in Store.",
"managers",
",",
"err",
":=",
"store",
".",
"FindNodes",
"(",
"tx",
",",
"store",
".",
"ByRole",
"(",
"api",
".",
"NodeRoleManager",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"managers",
")",
"==",
"1",
"&&",
"managers",
"[",
"0",
"]",
".",
"ID",
"==",
"node",
".",
"ID",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"FailedPrecondition",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check for node in memberlist",
"if",
"member",
"=",
"s",
".",
"raft",
".",
"GetMemberByNodeID",
"(",
"request",
".",
"NodeID",
")",
";",
"member",
"==",
"nil",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Quorum safeguard",
"if",
"!",
"s",
".",
"raft",
".",
"CanRemoveMember",
"(",
"member",
".",
"RaftID",
")",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"FailedPrecondition",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"node",
".",
"Meta",
".",
"Version",
"=",
"*",
"request",
".",
"NodeVersion",
"\n",
"node",
".",
"Spec",
"=",
"*",
"request",
".",
"Spec",
".",
"Copy",
"(",
")",
"\n",
"return",
"store",
".",
"UpdateNode",
"(",
"tx",
",",
"node",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"UpdateNodeResponse",
"{",
"Node",
":",
"node",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// UpdateNode updates a Node referenced by NodeID with the given NodeSpec.
// - Returns `NotFound` if the Node is not found.
// - Returns `InvalidArgument` if the NodeSpec is malformed.
// - Returns an error if the update fails.
|
[
"UpdateNode",
"updates",
"a",
"Node",
"referenced",
"by",
"NodeID",
"with",
"the",
"given",
"NodeSpec",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Node",
"is",
"not",
"found",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"NodeSpec",
"is",
"malformed",
".",
"-",
"Returns",
"an",
"error",
"if",
"the",
"update",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/node.go#L203-L255
|
train
|
docker/swarmkit
|
manager/state/store/by.go
|
BySlot
|
func BySlot(serviceID string, slot uint64) By {
return bySlot{serviceID: serviceID, slot: slot}
}
|
go
|
func BySlot(serviceID string, slot uint64) By {
return bySlot{serviceID: serviceID, slot: slot}
}
|
[
"func",
"BySlot",
"(",
"serviceID",
"string",
",",
"slot",
"uint64",
")",
"By",
"{",
"return",
"bySlot",
"{",
"serviceID",
":",
"serviceID",
",",
"slot",
":",
"slot",
"}",
"\n",
"}"
] |
// BySlot creates an object to pass to Find to select by slot.
|
[
"BySlot",
"creates",
"an",
"object",
"to",
"pass",
"to",
"Find",
"to",
"select",
"by",
"slot",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/by.go#L91-L93
|
train
|
docker/swarmkit
|
manager/state/store/by.go
|
ByCustom
|
func ByCustom(objType, index, value string) By {
return byCustom{
objType: objType,
index: index,
value: value,
}
}
|
go
|
func ByCustom(objType, index, value string) By {
return byCustom{
objType: objType,
index: index,
value: value,
}
}
|
[
"func",
"ByCustom",
"(",
"objType",
",",
"index",
",",
"value",
"string",
")",
"By",
"{",
"return",
"byCustom",
"{",
"objType",
":",
"objType",
",",
"index",
":",
"index",
",",
"value",
":",
"value",
",",
"}",
"\n",
"}"
] |
// ByCustom creates an object to pass to Find to search a custom index.
|
[
"ByCustom",
"creates",
"an",
"object",
"to",
"pass",
"to",
"Find",
"to",
"search",
"a",
"custom",
"index",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/by.go#L189-L195
|
train
|
docker/swarmkit
|
manager/state/store/by.go
|
ByCustomPrefix
|
func ByCustomPrefix(objType, index, value string) By {
return byCustomPrefix{
objType: objType,
index: index,
value: value,
}
}
|
go
|
func ByCustomPrefix(objType, index, value string) By {
return byCustomPrefix{
objType: objType,
index: index,
value: value,
}
}
|
[
"func",
"ByCustomPrefix",
"(",
"objType",
",",
"index",
",",
"value",
"string",
")",
"By",
"{",
"return",
"byCustomPrefix",
"{",
"objType",
":",
"objType",
",",
"index",
":",
"index",
",",
"value",
":",
"value",
",",
"}",
"\n",
"}"
] |
// ByCustomPrefix creates an object to pass to Find to search a custom index by
// a value prefix.
|
[
"ByCustomPrefix",
"creates",
"an",
"object",
"to",
"pass",
"to",
"Find",
"to",
"search",
"a",
"custom",
"index",
"by",
"a",
"value",
"prefix",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/store/by.go#L208-L214
|
train
|
docker/swarmkit
|
manager/keymanager/keymanager.go
|
DefaultConfig
|
func DefaultConfig() *Config {
return &Config{
ClusterName: store.DefaultClusterName,
Keylen: DefaultKeyLen,
RotationInterval: DefaultKeyRotationInterval,
Subsystems: []string{SubsystemGossip, SubsystemIPSec},
}
}
|
go
|
func DefaultConfig() *Config {
return &Config{
ClusterName: store.DefaultClusterName,
Keylen: DefaultKeyLen,
RotationInterval: DefaultKeyRotationInterval,
Subsystems: []string{SubsystemGossip, SubsystemIPSec},
}
}
|
[
"func",
"DefaultConfig",
"(",
")",
"*",
"Config",
"{",
"return",
"&",
"Config",
"{",
"ClusterName",
":",
"store",
".",
"DefaultClusterName",
",",
"Keylen",
":",
"DefaultKeyLen",
",",
"RotationInterval",
":",
"DefaultKeyRotationInterval",
",",
"Subsystems",
":",
"[",
"]",
"string",
"{",
"SubsystemGossip",
",",
"SubsystemIPSec",
"}",
",",
"}",
"\n",
"}"
] |
// DefaultConfig provides the default config for keymanager
|
[
"DefaultConfig",
"provides",
"the",
"default",
"config",
"for",
"keymanager"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/keymanager/keymanager.go#L72-L79
|
train
|
docker/swarmkit
|
manager/keymanager/keymanager.go
|
New
|
func New(store *store.MemoryStore, config *Config) *KeyManager {
for _, subsys := range config.Subsystems {
if subsys != SubsystemGossip && subsys != SubsystemIPSec {
return nil
}
}
return &KeyManager{
config: config,
store: store,
keyRing: &keyRing{lClock: genSkew()},
}
}
|
go
|
func New(store *store.MemoryStore, config *Config) *KeyManager {
for _, subsys := range config.Subsystems {
if subsys != SubsystemGossip && subsys != SubsystemIPSec {
return nil
}
}
return &KeyManager{
config: config,
store: store,
keyRing: &keyRing{lClock: genSkew()},
}
}
|
[
"func",
"New",
"(",
"store",
"*",
"store",
".",
"MemoryStore",
",",
"config",
"*",
"Config",
")",
"*",
"KeyManager",
"{",
"for",
"_",
",",
"subsys",
":=",
"range",
"config",
".",
"Subsystems",
"{",
"if",
"subsys",
"!=",
"SubsystemGossip",
"&&",
"subsys",
"!=",
"SubsystemIPSec",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"KeyManager",
"{",
"config",
":",
"config",
",",
"store",
":",
"store",
",",
"keyRing",
":",
"&",
"keyRing",
"{",
"lClock",
":",
"genSkew",
"(",
")",
"}",
",",
"}",
"\n",
"}"
] |
// New creates an instance of keymanager with the given config
|
[
"New",
"creates",
"an",
"instance",
"of",
"keymanager",
"with",
"the",
"given",
"config"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/keymanager/keymanager.go#L82-L93
|
train
|
docker/swarmkit
|
manager/keymanager/keymanager.go
|
Run
|
func (k *KeyManager) Run(ctx context.Context) error {
k.mu.Lock()
ctx = log.WithModule(ctx, "keymanager")
var (
clusters []*api.Cluster
err error
)
k.store.View(func(readTx store.ReadTx) {
clusters, err = store.FindClusters(readTx, store.ByName(k.config.ClusterName))
})
if err != nil {
log.G(ctx).Errorf("reading cluster config failed, %v", err)
k.mu.Unlock()
return err
}
cluster := clusters[0]
if len(cluster.NetworkBootstrapKeys) == 0 {
for _, subsys := range k.config.Subsystems {
for i := 0; i < keyringSize; i++ {
k.keyRing.keys = append(k.keyRing.keys, k.allocateKey(ctx, subsys))
}
}
if err := k.updateKey(cluster); err != nil {
log.G(ctx).Errorf("store update failed %v", err)
}
} else {
k.keyRing.lClock = cluster.EncryptionKeyLamportClock
k.keyRing.keys = cluster.NetworkBootstrapKeys
}
ticker := time.NewTicker(k.config.RotationInterval)
defer ticker.Stop()
k.ctx, k.cancel = context.WithCancel(ctx)
k.mu.Unlock()
for {
select {
case <-ticker.C:
k.rotateKey(ctx)
case <-k.ctx.Done():
return nil
}
}
}
|
go
|
func (k *KeyManager) Run(ctx context.Context) error {
k.mu.Lock()
ctx = log.WithModule(ctx, "keymanager")
var (
clusters []*api.Cluster
err error
)
k.store.View(func(readTx store.ReadTx) {
clusters, err = store.FindClusters(readTx, store.ByName(k.config.ClusterName))
})
if err != nil {
log.G(ctx).Errorf("reading cluster config failed, %v", err)
k.mu.Unlock()
return err
}
cluster := clusters[0]
if len(cluster.NetworkBootstrapKeys) == 0 {
for _, subsys := range k.config.Subsystems {
for i := 0; i < keyringSize; i++ {
k.keyRing.keys = append(k.keyRing.keys, k.allocateKey(ctx, subsys))
}
}
if err := k.updateKey(cluster); err != nil {
log.G(ctx).Errorf("store update failed %v", err)
}
} else {
k.keyRing.lClock = cluster.EncryptionKeyLamportClock
k.keyRing.keys = cluster.NetworkBootstrapKeys
}
ticker := time.NewTicker(k.config.RotationInterval)
defer ticker.Stop()
k.ctx, k.cancel = context.WithCancel(ctx)
k.mu.Unlock()
for {
select {
case <-ticker.C:
k.rotateKey(ctx)
case <-k.ctx.Done():
return nil
}
}
}
|
[
"func",
"(",
"k",
"*",
"KeyManager",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"ctx",
"=",
"log",
".",
"WithModule",
"(",
"ctx",
",",
"\"",
"\"",
")",
"\n",
"var",
"(",
"clusters",
"[",
"]",
"*",
"api",
".",
"Cluster",
"\n",
"err",
"error",
"\n",
")",
"\n",
"k",
".",
"store",
".",
"View",
"(",
"func",
"(",
"readTx",
"store",
".",
"ReadTx",
")",
"{",
"clusters",
",",
"err",
"=",
"store",
".",
"FindClusters",
"(",
"readTx",
",",
"store",
".",
"ByName",
"(",
"k",
".",
"config",
".",
"ClusterName",
")",
")",
"\n",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"cluster",
":=",
"clusters",
"[",
"0",
"]",
"\n",
"if",
"len",
"(",
"cluster",
".",
"NetworkBootstrapKeys",
")",
"==",
"0",
"{",
"for",
"_",
",",
"subsys",
":=",
"range",
"k",
".",
"config",
".",
"Subsystems",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"keyringSize",
";",
"i",
"++",
"{",
"k",
".",
"keyRing",
".",
"keys",
"=",
"append",
"(",
"k",
".",
"keyRing",
".",
"keys",
",",
"k",
".",
"allocateKey",
"(",
"ctx",
",",
"subsys",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"k",
".",
"updateKey",
"(",
"cluster",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"k",
".",
"keyRing",
".",
"lClock",
"=",
"cluster",
".",
"EncryptionKeyLamportClock",
"\n",
"k",
".",
"keyRing",
".",
"keys",
"=",
"cluster",
".",
"NetworkBootstrapKeys",
"\n",
"}",
"\n\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"k",
".",
"config",
".",
"RotationInterval",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n\n",
"k",
".",
"ctx",
",",
"k",
".",
"cancel",
"=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ticker",
".",
"C",
":",
"k",
".",
"rotateKey",
"(",
"ctx",
")",
"\n",
"case",
"<-",
"k",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Run starts the keymanager, it doesn't return
|
[
"Run",
"starts",
"the",
"keymanager",
"it",
"doesn",
"t",
"return"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/keymanager/keymanager.go#L173-L219
|
train
|
docker/swarmkit
|
manager/keymanager/keymanager.go
|
Stop
|
func (k *KeyManager) Stop() error {
k.mu.Lock()
defer k.mu.Unlock()
if k.cancel == nil {
return errors.New("keymanager is not started")
}
k.cancel()
return nil
}
|
go
|
func (k *KeyManager) Stop() error {
k.mu.Lock()
defer k.mu.Unlock()
if k.cancel == nil {
return errors.New("keymanager is not started")
}
k.cancel()
return nil
}
|
[
"func",
"(",
"k",
"*",
"KeyManager",
")",
"Stop",
"(",
")",
"error",
"{",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"k",
".",
"cancel",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"k",
".",
"cancel",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Stop stops the running instance of key manager
|
[
"Stop",
"stops",
"the",
"running",
"instance",
"of",
"key",
"manager"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/keymanager/keymanager.go#L222-L230
|
train
|
docker/swarmkit
|
manager/keymanager/keymanager.go
|
genSkew
|
func genSkew() uint64 {
b := make([]byte, 2)
if _, err := cryptorand.Read(b); err != nil {
panic(err)
}
return uint64(binary.BigEndian.Uint16(b))
}
|
go
|
func genSkew() uint64 {
b := make([]byte, 2)
if _, err := cryptorand.Read(b); err != nil {
panic(err)
}
return uint64(binary.BigEndian.Uint16(b))
}
|
[
"func",
"genSkew",
"(",
")",
"uint64",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"cryptorand",
".",
"Read",
"(",
"b",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"uint64",
"(",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"b",
")",
")",
"\n",
"}"
] |
// genSkew generates a random uint64 number between 0 and 65535
|
[
"genSkew",
"generates",
"a",
"random",
"uint64",
"number",
"between",
"0",
"and",
"65535"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/keymanager/keymanager.go#L233-L239
|
train
|
docker/swarmkit
|
ca/certificates.go
|
Signer
|
func (rca *RootCA) Signer() (*LocalSigner, error) {
if rca.Pool == nil || rca.signer == nil || len(rca.signer.Cert) == 0 || rca.signer.Signer == nil {
return nil, ErrNoValidSigner
}
return rca.signer, nil
}
|
go
|
func (rca *RootCA) Signer() (*LocalSigner, error) {
if rca.Pool == nil || rca.signer == nil || len(rca.signer.Cert) == 0 || rca.signer.Signer == nil {
return nil, ErrNoValidSigner
}
return rca.signer, nil
}
|
[
"func",
"(",
"rca",
"*",
"RootCA",
")",
"Signer",
"(",
")",
"(",
"*",
"LocalSigner",
",",
"error",
")",
"{",
"if",
"rca",
".",
"Pool",
"==",
"nil",
"||",
"rca",
".",
"signer",
"==",
"nil",
"||",
"len",
"(",
"rca",
".",
"signer",
".",
"Cert",
")",
"==",
"0",
"||",
"rca",
".",
"signer",
".",
"Signer",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrNoValidSigner",
"\n",
"}",
"\n\n",
"return",
"rca",
".",
"signer",
",",
"nil",
"\n",
"}"
] |
// Signer is an accessor for the local signer that returns an error if this root cannot sign.
|
[
"Signer",
"is",
"an",
"accessor",
"for",
"the",
"local",
"signer",
"that",
"returns",
"an",
"error",
"if",
"this",
"root",
"cannot",
"sign",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L192-L198
|
train
|
docker/swarmkit
|
ca/certificates.go
|
IssueAndSaveNewCertificates
|
func (rca *RootCA) IssueAndSaveNewCertificates(kw KeyWriter, cn, ou, org string) (*tls.Certificate, *IssuerInfo, error) {
csr, key, err := GenerateNewCSR()
if err != nil {
return nil, nil, errors.Wrap(err, "error when generating new node certs")
}
// Obtain a signed Certificate
certChain, err := rca.ParseValidateAndSignCSR(csr, cn, ou, org)
if err != nil {
return nil, nil, errors.Wrap(err, "failed to sign node certificate")
}
signer, err := rca.Signer()
if err != nil { // should never happen, since if ParseValidateAndSignCSR did not fail this root CA must have a signer
return nil, nil, err
}
// Create a valid TLSKeyPair out of the PEM encoded private key and certificate
tlsKeyPair, err := tls.X509KeyPair(certChain, key)
if err != nil {
return nil, nil, err
}
if err := kw.Write(NormalizePEMs(certChain), key, nil); err != nil {
return nil, nil, err
}
return &tlsKeyPair, &IssuerInfo{
PublicKey: signer.parsedCert.RawSubjectPublicKeyInfo,
Subject: signer.parsedCert.RawSubject,
}, nil
}
|
go
|
func (rca *RootCA) IssueAndSaveNewCertificates(kw KeyWriter, cn, ou, org string) (*tls.Certificate, *IssuerInfo, error) {
csr, key, err := GenerateNewCSR()
if err != nil {
return nil, nil, errors.Wrap(err, "error when generating new node certs")
}
// Obtain a signed Certificate
certChain, err := rca.ParseValidateAndSignCSR(csr, cn, ou, org)
if err != nil {
return nil, nil, errors.Wrap(err, "failed to sign node certificate")
}
signer, err := rca.Signer()
if err != nil { // should never happen, since if ParseValidateAndSignCSR did not fail this root CA must have a signer
return nil, nil, err
}
// Create a valid TLSKeyPair out of the PEM encoded private key and certificate
tlsKeyPair, err := tls.X509KeyPair(certChain, key)
if err != nil {
return nil, nil, err
}
if err := kw.Write(NormalizePEMs(certChain), key, nil); err != nil {
return nil, nil, err
}
return &tlsKeyPair, &IssuerInfo{
PublicKey: signer.parsedCert.RawSubjectPublicKeyInfo,
Subject: signer.parsedCert.RawSubject,
}, nil
}
|
[
"func",
"(",
"rca",
"*",
"RootCA",
")",
"IssueAndSaveNewCertificates",
"(",
"kw",
"KeyWriter",
",",
"cn",
",",
"ou",
",",
"org",
"string",
")",
"(",
"*",
"tls",
".",
"Certificate",
",",
"*",
"IssuerInfo",
",",
"error",
")",
"{",
"csr",
",",
"key",
",",
"err",
":=",
"GenerateNewCSR",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Obtain a signed Certificate",
"certChain",
",",
"err",
":=",
"rca",
".",
"ParseValidateAndSignCSR",
"(",
"csr",
",",
"cn",
",",
"ou",
",",
"org",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"signer",
",",
"err",
":=",
"rca",
".",
"Signer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// should never happen, since if ParseValidateAndSignCSR did not fail this root CA must have a signer",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Create a valid TLSKeyPair out of the PEM encoded private key and certificate",
"tlsKeyPair",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"certChain",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"kw",
".",
"Write",
"(",
"NormalizePEMs",
"(",
"certChain",
")",
",",
"key",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"tlsKeyPair",
",",
"&",
"IssuerInfo",
"{",
"PublicKey",
":",
"signer",
".",
"parsedCert",
".",
"RawSubjectPublicKeyInfo",
",",
"Subject",
":",
"signer",
".",
"parsedCert",
".",
"RawSubject",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// IssueAndSaveNewCertificates generates a new key-pair, signs it with the local root-ca, and returns a
// TLS certificate and the issuer information for the certificate.
|
[
"IssueAndSaveNewCertificates",
"generates",
"a",
"new",
"key",
"-",
"pair",
"signs",
"it",
"with",
"the",
"local",
"root",
"-",
"ca",
"and",
"returns",
"a",
"TLS",
"certificate",
"and",
"the",
"issuer",
"information",
"for",
"the",
"certificate",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L202-L232
|
train
|
docker/swarmkit
|
ca/certificates.go
|
RequestAndSaveNewCertificates
|
func (rca *RootCA) RequestAndSaveNewCertificates(ctx context.Context, kw KeyWriter, config CertificateRequestConfig) (*tls.Certificate, *IssuerInfo, error) {
// Create a new key/pair and CSR
csr, key, err := GenerateNewCSR()
if err != nil {
return nil, nil, errors.Wrap(err, "error when generating new node certs")
}
// Get the remote manager to issue a CA signed certificate for this node
// Retry up to 5 times in case the manager we first try to contact isn't
// responding properly (for example, it may have just been demoted).
var signedCert []byte
for i := 0; i != 5; i++ {
signedCert, err = GetRemoteSignedCertificate(ctx, csr, rca.Pool, config)
if err == nil {
break
}
// If the first attempt fails, we should try a remote
// connection. The local node may be a manager that was
// demoted, so the local connection (which is preferred) may
// not work. If we are successful in renewing the certificate,
// the local connection will not be returned by the connection
// broker anymore.
config.ForceRemote = true
// Wait a moment, in case a leader election was taking place.
select {
case <-time.After(config.RetryInterval):
case <-ctx.Done():
return nil, nil, ctx.Err()
}
}
if err != nil {
return nil, nil, err
}
// Доверяй, но проверяй.
// Before we overwrite our local key + certificate, let's make sure the server gave us one that is valid
// Create an X509Cert so we can .Verify()
// Check to see if this certificate was signed by our CA, and isn't expired
parsedCerts, chains, err := ValidateCertChain(rca.Pool, signedCert, false)
// TODO(cyli): - right now we need the invalid certificate in order to determine whether or not we should
// download a new root, because we only want to do that in the case of workers. When we have a single
// codepath for updating the root CAs for both managers and workers, this snippet can go.
if _, ok := err.(x509.UnknownAuthorityError); ok {
if parsedCerts, parseErr := helpers.ParseCertificatesPEM(signedCert); parseErr == nil && len(parsedCerts) > 0 {
return nil, nil, x509UnknownAuthError{
error: err,
failedLeafCert: parsedCerts[0],
}
}
}
if err != nil {
return nil, nil, err
}
// ValidateChain, if successful, will always return at least 1 parsed cert and at least 1 chain containing
// at least 2 certificates: the leaf and the root.
leafCert := parsedCerts[0]
issuer := chains[0][1]
// Create a valid TLSKeyPair out of the PEM encoded private key and certificate
tlsKeyPair, err := tls.X509KeyPair(signedCert, key)
if err != nil {
return nil, nil, err
}
var kekUpdate *KEKData
for i := 0; i < 5; i++ {
// ValidateCertChain will always return at least 1 cert, so indexing at 0 is safe
kekUpdate, err = rca.getKEKUpdate(ctx, leafCert, tlsKeyPair, config)
if err == nil {
break
}
config.ForceRemote = true
// Wait a moment, in case a leader election was taking place.
select {
case <-time.After(config.RetryInterval):
case <-ctx.Done():
return nil, nil, ctx.Err()
}
}
if err != nil {
return nil, nil, err
}
if err := kw.Write(NormalizePEMs(signedCert), key, kekUpdate); err != nil {
return nil, nil, err
}
return &tlsKeyPair, &IssuerInfo{
PublicKey: issuer.RawSubjectPublicKeyInfo,
Subject: issuer.RawSubject,
}, nil
}
|
go
|
func (rca *RootCA) RequestAndSaveNewCertificates(ctx context.Context, kw KeyWriter, config CertificateRequestConfig) (*tls.Certificate, *IssuerInfo, error) {
// Create a new key/pair and CSR
csr, key, err := GenerateNewCSR()
if err != nil {
return nil, nil, errors.Wrap(err, "error when generating new node certs")
}
// Get the remote manager to issue a CA signed certificate for this node
// Retry up to 5 times in case the manager we first try to contact isn't
// responding properly (for example, it may have just been demoted).
var signedCert []byte
for i := 0; i != 5; i++ {
signedCert, err = GetRemoteSignedCertificate(ctx, csr, rca.Pool, config)
if err == nil {
break
}
// If the first attempt fails, we should try a remote
// connection. The local node may be a manager that was
// demoted, so the local connection (which is preferred) may
// not work. If we are successful in renewing the certificate,
// the local connection will not be returned by the connection
// broker anymore.
config.ForceRemote = true
// Wait a moment, in case a leader election was taking place.
select {
case <-time.After(config.RetryInterval):
case <-ctx.Done():
return nil, nil, ctx.Err()
}
}
if err != nil {
return nil, nil, err
}
// Доверяй, но проверяй.
// Before we overwrite our local key + certificate, let's make sure the server gave us one that is valid
// Create an X509Cert so we can .Verify()
// Check to see if this certificate was signed by our CA, and isn't expired
parsedCerts, chains, err := ValidateCertChain(rca.Pool, signedCert, false)
// TODO(cyli): - right now we need the invalid certificate in order to determine whether or not we should
// download a new root, because we only want to do that in the case of workers. When we have a single
// codepath for updating the root CAs for both managers and workers, this snippet can go.
if _, ok := err.(x509.UnknownAuthorityError); ok {
if parsedCerts, parseErr := helpers.ParseCertificatesPEM(signedCert); parseErr == nil && len(parsedCerts) > 0 {
return nil, nil, x509UnknownAuthError{
error: err,
failedLeafCert: parsedCerts[0],
}
}
}
if err != nil {
return nil, nil, err
}
// ValidateChain, if successful, will always return at least 1 parsed cert and at least 1 chain containing
// at least 2 certificates: the leaf and the root.
leafCert := parsedCerts[0]
issuer := chains[0][1]
// Create a valid TLSKeyPair out of the PEM encoded private key and certificate
tlsKeyPair, err := tls.X509KeyPair(signedCert, key)
if err != nil {
return nil, nil, err
}
var kekUpdate *KEKData
for i := 0; i < 5; i++ {
// ValidateCertChain will always return at least 1 cert, so indexing at 0 is safe
kekUpdate, err = rca.getKEKUpdate(ctx, leafCert, tlsKeyPair, config)
if err == nil {
break
}
config.ForceRemote = true
// Wait a moment, in case a leader election was taking place.
select {
case <-time.After(config.RetryInterval):
case <-ctx.Done():
return nil, nil, ctx.Err()
}
}
if err != nil {
return nil, nil, err
}
if err := kw.Write(NormalizePEMs(signedCert), key, kekUpdate); err != nil {
return nil, nil, err
}
return &tlsKeyPair, &IssuerInfo{
PublicKey: issuer.RawSubjectPublicKeyInfo,
Subject: issuer.RawSubject,
}, nil
}
|
[
"func",
"(",
"rca",
"*",
"RootCA",
")",
"RequestAndSaveNewCertificates",
"(",
"ctx",
"context",
".",
"Context",
",",
"kw",
"KeyWriter",
",",
"config",
"CertificateRequestConfig",
")",
"(",
"*",
"tls",
".",
"Certificate",
",",
"*",
"IssuerInfo",
",",
"error",
")",
"{",
"// Create a new key/pair and CSR",
"csr",
",",
"key",
",",
"err",
":=",
"GenerateNewCSR",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get the remote manager to issue a CA signed certificate for this node",
"// Retry up to 5 times in case the manager we first try to contact isn't",
"// responding properly (for example, it may have just been demoted).",
"var",
"signedCert",
"[",
"]",
"byte",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"!=",
"5",
";",
"i",
"++",
"{",
"signedCert",
",",
"err",
"=",
"GetRemoteSignedCertificate",
"(",
"ctx",
",",
"csr",
",",
"rca",
".",
"Pool",
",",
"config",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n\n",
"// If the first attempt fails, we should try a remote",
"// connection. The local node may be a manager that was",
"// demoted, so the local connection (which is preferred) may",
"// not work. If we are successful in renewing the certificate,",
"// the local connection will not be returned by the connection",
"// broker anymore.",
"config",
".",
"ForceRemote",
"=",
"true",
"\n\n",
"// Wait a moment, in case a leader election was taking place.",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"config",
".",
"RetryInterval",
")",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"nil",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Доверяй, но проверяй.",
"// Before we overwrite our local key + certificate, let's make sure the server gave us one that is valid",
"// Create an X509Cert so we can .Verify()",
"// Check to see if this certificate was signed by our CA, and isn't expired",
"parsedCerts",
",",
"chains",
",",
"err",
":=",
"ValidateCertChain",
"(",
"rca",
".",
"Pool",
",",
"signedCert",
",",
"false",
")",
"\n",
"// TODO(cyli): - right now we need the invalid certificate in order to determine whether or not we should",
"// download a new root, because we only want to do that in the case of workers. When we have a single",
"// codepath for updating the root CAs for both managers and workers, this snippet can go.",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"x509",
".",
"UnknownAuthorityError",
")",
";",
"ok",
"{",
"if",
"parsedCerts",
",",
"parseErr",
":=",
"helpers",
".",
"ParseCertificatesPEM",
"(",
"signedCert",
")",
";",
"parseErr",
"==",
"nil",
"&&",
"len",
"(",
"parsedCerts",
")",
">",
"0",
"{",
"return",
"nil",
",",
"nil",
",",
"x509UnknownAuthError",
"{",
"error",
":",
"err",
",",
"failedLeafCert",
":",
"parsedCerts",
"[",
"0",
"]",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// ValidateChain, if successful, will always return at least 1 parsed cert and at least 1 chain containing",
"// at least 2 certificates: the leaf and the root.",
"leafCert",
":=",
"parsedCerts",
"[",
"0",
"]",
"\n",
"issuer",
":=",
"chains",
"[",
"0",
"]",
"[",
"1",
"]",
"\n\n",
"// Create a valid TLSKeyPair out of the PEM encoded private key and certificate",
"tlsKeyPair",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"signedCert",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"kekUpdate",
"*",
"KEKData",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"5",
";",
"i",
"++",
"{",
"// ValidateCertChain will always return at least 1 cert, so indexing at 0 is safe",
"kekUpdate",
",",
"err",
"=",
"rca",
".",
"getKEKUpdate",
"(",
"ctx",
",",
"leafCert",
",",
"tlsKeyPair",
",",
"config",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n\n",
"config",
".",
"ForceRemote",
"=",
"true",
"\n\n",
"// Wait a moment, in case a leader election was taking place.",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"config",
".",
"RetryInterval",
")",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"nil",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"kw",
".",
"Write",
"(",
"NormalizePEMs",
"(",
"signedCert",
")",
",",
"key",
",",
"kekUpdate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"tlsKeyPair",
",",
"&",
"IssuerInfo",
"{",
"PublicKey",
":",
"issuer",
".",
"RawSubjectPublicKeyInfo",
",",
"Subject",
":",
"issuer",
".",
"RawSubject",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// RequestAndSaveNewCertificates gets new certificates issued, either by signing them locally if a signer is
// available, or by requesting them from the remote server at remoteAddr. This function returns the TLS
// certificate and the issuer information for the certificate.
|
[
"RequestAndSaveNewCertificates",
"gets",
"new",
"certificates",
"issued",
"either",
"by",
"signing",
"them",
"locally",
"if",
"a",
"signer",
"is",
"available",
"or",
"by",
"requesting",
"them",
"from",
"the",
"remote",
"server",
"at",
"remoteAddr",
".",
"This",
"function",
"returns",
"the",
"TLS",
"certificate",
"and",
"the",
"issuer",
"information",
"for",
"the",
"certificate",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L237-L333
|
train
|
docker/swarmkit
|
ca/certificates.go
|
PrepareCSR
|
func PrepareCSR(csrBytes []byte, cn, ou, org string) cfsigner.SignRequest {
// All managers get added the subject-alt-name of CA, so they can be
// used for cert issuance.
hosts := []string{ou, cn}
if ou == ManagerRole {
hosts = append(hosts, CARole)
}
return cfsigner.SignRequest{
Request: string(csrBytes),
// OU is used for Authentication of the node type. The CN has the random
// node ID.
Subject: &cfsigner.Subject{CN: cn, Names: []cfcsr.Name{{OU: ou, O: org}}},
// Adding ou as DNS alt name, so clients can connect to ManagerRole and CARole
Hosts: hosts,
}
}
|
go
|
func PrepareCSR(csrBytes []byte, cn, ou, org string) cfsigner.SignRequest {
// All managers get added the subject-alt-name of CA, so they can be
// used for cert issuance.
hosts := []string{ou, cn}
if ou == ManagerRole {
hosts = append(hosts, CARole)
}
return cfsigner.SignRequest{
Request: string(csrBytes),
// OU is used for Authentication of the node type. The CN has the random
// node ID.
Subject: &cfsigner.Subject{CN: cn, Names: []cfcsr.Name{{OU: ou, O: org}}},
// Adding ou as DNS alt name, so clients can connect to ManagerRole and CARole
Hosts: hosts,
}
}
|
[
"func",
"PrepareCSR",
"(",
"csrBytes",
"[",
"]",
"byte",
",",
"cn",
",",
"ou",
",",
"org",
"string",
")",
"cfsigner",
".",
"SignRequest",
"{",
"// All managers get added the subject-alt-name of CA, so they can be",
"// used for cert issuance.",
"hosts",
":=",
"[",
"]",
"string",
"{",
"ou",
",",
"cn",
"}",
"\n",
"if",
"ou",
"==",
"ManagerRole",
"{",
"hosts",
"=",
"append",
"(",
"hosts",
",",
"CARole",
")",
"\n",
"}",
"\n\n",
"return",
"cfsigner",
".",
"SignRequest",
"{",
"Request",
":",
"string",
"(",
"csrBytes",
")",
",",
"// OU is used for Authentication of the node type. The CN has the random",
"// node ID.",
"Subject",
":",
"&",
"cfsigner",
".",
"Subject",
"{",
"CN",
":",
"cn",
",",
"Names",
":",
"[",
"]",
"cfcsr",
".",
"Name",
"{",
"{",
"OU",
":",
"ou",
",",
"O",
":",
"org",
"}",
"}",
"}",
",",
"// Adding ou as DNS alt name, so clients can connect to ManagerRole and CARole",
"Hosts",
":",
"hosts",
",",
"}",
"\n",
"}"
] |
// PrepareCSR creates a CFSSL Sign Request based on the given raw CSR and
// overrides the Subject and Hosts with the given extra args.
|
[
"PrepareCSR",
"creates",
"a",
"CFSSL",
"Sign",
"Request",
"based",
"on",
"the",
"given",
"raw",
"CSR",
"and",
"overrides",
"the",
"Subject",
"and",
"Hosts",
"with",
"the",
"given",
"extra",
"args",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L376-L392
|
train
|
docker/swarmkit
|
ca/certificates.go
|
ParseValidateAndSignCSR
|
func (rca *RootCA) ParseValidateAndSignCSR(csrBytes []byte, cn, ou, org string) ([]byte, error) {
signRequest := PrepareCSR(csrBytes, cn, ou, org)
signer, err := rca.Signer()
if err != nil {
return nil, err
}
cert, err := signer.Sign(signRequest)
if err != nil {
return nil, errors.Wrap(err, "failed to sign node certificate")
}
return append(cert, rca.Intermediates...), nil
}
|
go
|
func (rca *RootCA) ParseValidateAndSignCSR(csrBytes []byte, cn, ou, org string) ([]byte, error) {
signRequest := PrepareCSR(csrBytes, cn, ou, org)
signer, err := rca.Signer()
if err != nil {
return nil, err
}
cert, err := signer.Sign(signRequest)
if err != nil {
return nil, errors.Wrap(err, "failed to sign node certificate")
}
return append(cert, rca.Intermediates...), nil
}
|
[
"func",
"(",
"rca",
"*",
"RootCA",
")",
"ParseValidateAndSignCSR",
"(",
"csrBytes",
"[",
"]",
"byte",
",",
"cn",
",",
"ou",
",",
"org",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"signRequest",
":=",
"PrepareCSR",
"(",
"csrBytes",
",",
"cn",
",",
"ou",
",",
"org",
")",
"\n",
"signer",
",",
"err",
":=",
"rca",
".",
"Signer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cert",
",",
"err",
":=",
"signer",
".",
"Sign",
"(",
"signRequest",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"append",
"(",
"cert",
",",
"rca",
".",
"Intermediates",
"...",
")",
",",
"nil",
"\n",
"}"
] |
// ParseValidateAndSignCSR returns a signed certificate from a particular rootCA and a CSR.
|
[
"ParseValidateAndSignCSR",
"returns",
"a",
"signed",
"certificate",
"from",
"a",
"particular",
"rootCA",
"and",
"a",
"CSR",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L395-L407
|
train
|
docker/swarmkit
|
ca/certificates.go
|
CrossSignCACertificate
|
func (rca *RootCA) CrossSignCACertificate(otherCAPEM []byte) ([]byte, error) {
signer, err := rca.Signer()
if err != nil {
return nil, err
}
// create a new cert with exactly the same parameters, including the public key and exact NotBefore and NotAfter
template, err := helpers.ParseCertificatePEM(otherCAPEM)
if err != nil {
return nil, errors.New("could not parse new CA certificate")
}
if !template.IsCA {
return nil, errors.New("certificate not a CA")
}
template.SignatureAlgorithm = signer.parsedCert.SignatureAlgorithm // make sure we can sign with the signer key
derBytes, err := x509.CreateCertificate(cryptorand.Reader, template, signer.parsedCert, template.PublicKey, signer.cryptoSigner)
if err != nil {
return nil, errors.Wrap(err, "could not cross-sign new CA certificate using old CA material")
}
return pem.EncodeToMemory(&pem.Block{
Type: "CERTIFICATE",
Bytes: derBytes,
}), nil
}
|
go
|
func (rca *RootCA) CrossSignCACertificate(otherCAPEM []byte) ([]byte, error) {
signer, err := rca.Signer()
if err != nil {
return nil, err
}
// create a new cert with exactly the same parameters, including the public key and exact NotBefore and NotAfter
template, err := helpers.ParseCertificatePEM(otherCAPEM)
if err != nil {
return nil, errors.New("could not parse new CA certificate")
}
if !template.IsCA {
return nil, errors.New("certificate not a CA")
}
template.SignatureAlgorithm = signer.parsedCert.SignatureAlgorithm // make sure we can sign with the signer key
derBytes, err := x509.CreateCertificate(cryptorand.Reader, template, signer.parsedCert, template.PublicKey, signer.cryptoSigner)
if err != nil {
return nil, errors.Wrap(err, "could not cross-sign new CA certificate using old CA material")
}
return pem.EncodeToMemory(&pem.Block{
Type: "CERTIFICATE",
Bytes: derBytes,
}), nil
}
|
[
"func",
"(",
"rca",
"*",
"RootCA",
")",
"CrossSignCACertificate",
"(",
"otherCAPEM",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"signer",
",",
"err",
":=",
"rca",
".",
"Signer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// create a new cert with exactly the same parameters, including the public key and exact NotBefore and NotAfter",
"template",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatePEM",
"(",
"otherCAPEM",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"template",
".",
"IsCA",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"template",
".",
"SignatureAlgorithm",
"=",
"signer",
".",
"parsedCert",
".",
"SignatureAlgorithm",
"// make sure we can sign with the signer key",
"\n",
"derBytes",
",",
"err",
":=",
"x509",
".",
"CreateCertificate",
"(",
"cryptorand",
".",
"Reader",
",",
"template",
",",
"signer",
".",
"parsedCert",
",",
"template",
".",
"PublicKey",
",",
"signer",
".",
"cryptoSigner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"pem",
".",
"EncodeToMemory",
"(",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Bytes",
":",
"derBytes",
",",
"}",
")",
",",
"nil",
"\n",
"}"
] |
// CrossSignCACertificate takes a CA root certificate and generates an intermediate CA from it signed with the current root signer
|
[
"CrossSignCACertificate",
"takes",
"a",
"CA",
"root",
"certificate",
"and",
"generates",
"an",
"intermediate",
"CA",
"from",
"it",
"signed",
"with",
"the",
"current",
"root",
"signer"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L410-L436
|
train
|
docker/swarmkit
|
ca/certificates.go
|
NewRootCA
|
func NewRootCA(rootCertBytes, signCertBytes, signKeyBytes []byte, certExpiry time.Duration, intermediates []byte) (RootCA, error) {
// Parse all the certificates in the cert bundle
parsedCerts, err := helpers.ParseCertificatesPEM(rootCertBytes)
if err != nil {
return RootCA{}, errors.Wrap(err, "invalid root certificates")
}
// Check to see if we have at least one valid cert
if len(parsedCerts) < 1 {
return RootCA{}, errors.New("no valid root CA certificates found")
}
// Create a Pool with all of the certificates found
pool := x509.NewCertPool()
for _, cert := range parsedCerts {
if err := validateSignatureAlgorithm(cert); err != nil {
return RootCA{}, err
}
// Check to see if all of the certificates are valid, self-signed root CA certs
selfpool := x509.NewCertPool()
selfpool.AddCert(cert)
if _, err := cert.Verify(x509.VerifyOptions{Roots: selfpool}); err != nil {
return RootCA{}, errors.Wrap(err, "error while validating Root CA Certificate")
}
pool.AddCert(cert)
}
// Calculate the digest for our Root CA bundle
digest := digest.FromBytes(rootCertBytes)
// The intermediates supplied must be able to chain up to the root certificates, so that when they are appended to
// a leaf certificate, the leaf certificate can be validated through the intermediates to the root certificates.
var intermediatePool *x509.CertPool
var parsedIntermediates []*x509.Certificate
if len(intermediates) > 0 {
parsedIntermediates, _, err = ValidateCertChain(pool, intermediates, false)
if err != nil {
return RootCA{}, errors.Wrap(err, "invalid intermediate chain")
}
intermediatePool = x509.NewCertPool()
for _, cert := range parsedIntermediates {
intermediatePool.AddCert(cert)
}
}
var localSigner *LocalSigner
if len(signKeyBytes) != 0 || len(signCertBytes) != 0 {
localSigner, err = newLocalSigner(signKeyBytes, signCertBytes, certExpiry, pool, intermediatePool)
if err != nil {
return RootCA{}, err
}
// If a signer is provided and there are intermediates, then either the first intermediate would be the signer CA
// certificate (in which case it'd have the same subject and public key), or it would be a cross-signed
// intermediate with the same subject and public key as our signing CA certificate (which could be either an
// intermediate cert or a self-signed root cert).
if len(parsedIntermediates) > 0 && (!bytes.Equal(parsedIntermediates[0].RawSubject, localSigner.parsedCert.RawSubject) ||
!bytes.Equal(parsedIntermediates[0].RawSubjectPublicKeyInfo, localSigner.parsedCert.RawSubjectPublicKeyInfo)) {
return RootCA{}, errors.New(
"invalid intermediate chain - the first intermediate must have the same subject and public key as the signing cert")
}
}
return RootCA{signer: localSigner, Intermediates: intermediates, Digest: digest, Certs: rootCertBytes, Pool: pool}, nil
}
|
go
|
func NewRootCA(rootCertBytes, signCertBytes, signKeyBytes []byte, certExpiry time.Duration, intermediates []byte) (RootCA, error) {
// Parse all the certificates in the cert bundle
parsedCerts, err := helpers.ParseCertificatesPEM(rootCertBytes)
if err != nil {
return RootCA{}, errors.Wrap(err, "invalid root certificates")
}
// Check to see if we have at least one valid cert
if len(parsedCerts) < 1 {
return RootCA{}, errors.New("no valid root CA certificates found")
}
// Create a Pool with all of the certificates found
pool := x509.NewCertPool()
for _, cert := range parsedCerts {
if err := validateSignatureAlgorithm(cert); err != nil {
return RootCA{}, err
}
// Check to see if all of the certificates are valid, self-signed root CA certs
selfpool := x509.NewCertPool()
selfpool.AddCert(cert)
if _, err := cert.Verify(x509.VerifyOptions{Roots: selfpool}); err != nil {
return RootCA{}, errors.Wrap(err, "error while validating Root CA Certificate")
}
pool.AddCert(cert)
}
// Calculate the digest for our Root CA bundle
digest := digest.FromBytes(rootCertBytes)
// The intermediates supplied must be able to chain up to the root certificates, so that when they are appended to
// a leaf certificate, the leaf certificate can be validated through the intermediates to the root certificates.
var intermediatePool *x509.CertPool
var parsedIntermediates []*x509.Certificate
if len(intermediates) > 0 {
parsedIntermediates, _, err = ValidateCertChain(pool, intermediates, false)
if err != nil {
return RootCA{}, errors.Wrap(err, "invalid intermediate chain")
}
intermediatePool = x509.NewCertPool()
for _, cert := range parsedIntermediates {
intermediatePool.AddCert(cert)
}
}
var localSigner *LocalSigner
if len(signKeyBytes) != 0 || len(signCertBytes) != 0 {
localSigner, err = newLocalSigner(signKeyBytes, signCertBytes, certExpiry, pool, intermediatePool)
if err != nil {
return RootCA{}, err
}
// If a signer is provided and there are intermediates, then either the first intermediate would be the signer CA
// certificate (in which case it'd have the same subject and public key), or it would be a cross-signed
// intermediate with the same subject and public key as our signing CA certificate (which could be either an
// intermediate cert or a self-signed root cert).
if len(parsedIntermediates) > 0 && (!bytes.Equal(parsedIntermediates[0].RawSubject, localSigner.parsedCert.RawSubject) ||
!bytes.Equal(parsedIntermediates[0].RawSubjectPublicKeyInfo, localSigner.parsedCert.RawSubjectPublicKeyInfo)) {
return RootCA{}, errors.New(
"invalid intermediate chain - the first intermediate must have the same subject and public key as the signing cert")
}
}
return RootCA{signer: localSigner, Intermediates: intermediates, Digest: digest, Certs: rootCertBytes, Pool: pool}, nil
}
|
[
"func",
"NewRootCA",
"(",
"rootCertBytes",
",",
"signCertBytes",
",",
"signKeyBytes",
"[",
"]",
"byte",
",",
"certExpiry",
"time",
".",
"Duration",
",",
"intermediates",
"[",
"]",
"byte",
")",
"(",
"RootCA",
",",
"error",
")",
"{",
"// Parse all the certificates in the cert bundle",
"parsedCerts",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatesPEM",
"(",
"rootCertBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// Check to see if we have at least one valid cert",
"if",
"len",
"(",
"parsedCerts",
")",
"<",
"1",
"{",
"return",
"RootCA",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Create a Pool with all of the certificates found",
"pool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"for",
"_",
",",
"cert",
":=",
"range",
"parsedCerts",
"{",
"if",
"err",
":=",
"validateSignatureAlgorithm",
"(",
"cert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"// Check to see if all of the certificates are valid, self-signed root CA certs",
"selfpool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"selfpool",
".",
"AddCert",
"(",
"cert",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"cert",
".",
"Verify",
"(",
"x509",
".",
"VerifyOptions",
"{",
"Roots",
":",
"selfpool",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"pool",
".",
"AddCert",
"(",
"cert",
")",
"\n",
"}",
"\n\n",
"// Calculate the digest for our Root CA bundle",
"digest",
":=",
"digest",
".",
"FromBytes",
"(",
"rootCertBytes",
")",
"\n\n",
"// The intermediates supplied must be able to chain up to the root certificates, so that when they are appended to",
"// a leaf certificate, the leaf certificate can be validated through the intermediates to the root certificates.",
"var",
"intermediatePool",
"*",
"x509",
".",
"CertPool",
"\n",
"var",
"parsedIntermediates",
"[",
"]",
"*",
"x509",
".",
"Certificate",
"\n",
"if",
"len",
"(",
"intermediates",
")",
">",
"0",
"{",
"parsedIntermediates",
",",
"_",
",",
"err",
"=",
"ValidateCertChain",
"(",
"pool",
",",
"intermediates",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"intermediatePool",
"=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"for",
"_",
",",
"cert",
":=",
"range",
"parsedIntermediates",
"{",
"intermediatePool",
".",
"AddCert",
"(",
"cert",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"var",
"localSigner",
"*",
"LocalSigner",
"\n",
"if",
"len",
"(",
"signKeyBytes",
")",
"!=",
"0",
"||",
"len",
"(",
"signCertBytes",
")",
"!=",
"0",
"{",
"localSigner",
",",
"err",
"=",
"newLocalSigner",
"(",
"signKeyBytes",
",",
"signCertBytes",
",",
"certExpiry",
",",
"pool",
",",
"intermediatePool",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"// If a signer is provided and there are intermediates, then either the first intermediate would be the signer CA",
"// certificate (in which case it'd have the same subject and public key), or it would be a cross-signed",
"// intermediate with the same subject and public key as our signing CA certificate (which could be either an",
"// intermediate cert or a self-signed root cert).",
"if",
"len",
"(",
"parsedIntermediates",
")",
">",
"0",
"&&",
"(",
"!",
"bytes",
".",
"Equal",
"(",
"parsedIntermediates",
"[",
"0",
"]",
".",
"RawSubject",
",",
"localSigner",
".",
"parsedCert",
".",
"RawSubject",
")",
"||",
"!",
"bytes",
".",
"Equal",
"(",
"parsedIntermediates",
"[",
"0",
"]",
".",
"RawSubjectPublicKeyInfo",
",",
"localSigner",
".",
"parsedCert",
".",
"RawSubjectPublicKeyInfo",
")",
")",
"{",
"return",
"RootCA",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"RootCA",
"{",
"signer",
":",
"localSigner",
",",
"Intermediates",
":",
"intermediates",
",",
"Digest",
":",
"digest",
",",
"Certs",
":",
"rootCertBytes",
",",
"Pool",
":",
"pool",
"}",
",",
"nil",
"\n",
"}"
] |
// NewRootCA creates a new RootCA object from unparsed PEM cert bundle and key byte
// slices. key may be nil, and in this case NewRootCA will return a RootCA
// without a signer.
|
[
"NewRootCA",
"creates",
"a",
"new",
"RootCA",
"object",
"from",
"unparsed",
"PEM",
"cert",
"bundle",
"and",
"key",
"byte",
"slices",
".",
"key",
"may",
"be",
"nil",
"and",
"in",
"this",
"case",
"NewRootCA",
"will",
"return",
"a",
"RootCA",
"without",
"a",
"signer",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L450-L513
|
train
|
docker/swarmkit
|
ca/certificates.go
|
newLocalSigner
|
func newLocalSigner(keyBytes, certBytes []byte, certExpiry time.Duration, rootPool, intermediatePool *x509.CertPool) (*LocalSigner, error) {
if len(keyBytes) == 0 || len(certBytes) == 0 {
return nil, errors.New("must provide both a signing key and a signing cert, or neither")
}
parsedCerts, err := helpers.ParseCertificatesPEM(certBytes)
if err != nil {
return nil, errors.Wrap(err, "invalid signing CA cert")
}
if len(parsedCerts) == 0 {
return nil, errors.New("no valid signing CA certificates found")
}
if err := validateSignatureAlgorithm(parsedCerts[0]); err != nil {
return nil, err
}
opts := x509.VerifyOptions{
Roots: rootPool,
Intermediates: intermediatePool,
}
if _, err := parsedCerts[0].Verify(opts); err != nil {
return nil, errors.Wrap(err, "error while validating signing CA certificate against roots and intermediates")
}
// The key should not be encrypted, but it could be in PKCS8 format rather than PKCS1
priv, err := helpers.ParsePrivateKeyPEM(keyBytes)
if err != nil {
return nil, errors.Wrap(err, "malformed private key")
}
// We will always use the first certificate inside of the root bundle as the active one
if err := ensureCertKeyMatch(parsedCerts[0], priv.Public()); err != nil {
return nil, err
}
signer, err := local.NewSigner(priv, parsedCerts[0], cfsigner.DefaultSigAlgo(priv), SigningPolicy(certExpiry))
if err != nil {
return nil, err
}
return &LocalSigner{Cert: certBytes, Key: keyBytes, Signer: signer, parsedCert: parsedCerts[0], cryptoSigner: priv}, nil
}
|
go
|
func newLocalSigner(keyBytes, certBytes []byte, certExpiry time.Duration, rootPool, intermediatePool *x509.CertPool) (*LocalSigner, error) {
if len(keyBytes) == 0 || len(certBytes) == 0 {
return nil, errors.New("must provide both a signing key and a signing cert, or neither")
}
parsedCerts, err := helpers.ParseCertificatesPEM(certBytes)
if err != nil {
return nil, errors.Wrap(err, "invalid signing CA cert")
}
if len(parsedCerts) == 0 {
return nil, errors.New("no valid signing CA certificates found")
}
if err := validateSignatureAlgorithm(parsedCerts[0]); err != nil {
return nil, err
}
opts := x509.VerifyOptions{
Roots: rootPool,
Intermediates: intermediatePool,
}
if _, err := parsedCerts[0].Verify(opts); err != nil {
return nil, errors.Wrap(err, "error while validating signing CA certificate against roots and intermediates")
}
// The key should not be encrypted, but it could be in PKCS8 format rather than PKCS1
priv, err := helpers.ParsePrivateKeyPEM(keyBytes)
if err != nil {
return nil, errors.Wrap(err, "malformed private key")
}
// We will always use the first certificate inside of the root bundle as the active one
if err := ensureCertKeyMatch(parsedCerts[0], priv.Public()); err != nil {
return nil, err
}
signer, err := local.NewSigner(priv, parsedCerts[0], cfsigner.DefaultSigAlgo(priv), SigningPolicy(certExpiry))
if err != nil {
return nil, err
}
return &LocalSigner{Cert: certBytes, Key: keyBytes, Signer: signer, parsedCert: parsedCerts[0], cryptoSigner: priv}, nil
}
|
[
"func",
"newLocalSigner",
"(",
"keyBytes",
",",
"certBytes",
"[",
"]",
"byte",
",",
"certExpiry",
"time",
".",
"Duration",
",",
"rootPool",
",",
"intermediatePool",
"*",
"x509",
".",
"CertPool",
")",
"(",
"*",
"LocalSigner",
",",
"error",
")",
"{",
"if",
"len",
"(",
"keyBytes",
")",
"==",
"0",
"||",
"len",
"(",
"certBytes",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"parsedCerts",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatesPEM",
"(",
"certBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"parsedCerts",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"validateSignatureAlgorithm",
"(",
"parsedCerts",
"[",
"0",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"opts",
":=",
"x509",
".",
"VerifyOptions",
"{",
"Roots",
":",
"rootPool",
",",
"Intermediates",
":",
"intermediatePool",
",",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"parsedCerts",
"[",
"0",
"]",
".",
"Verify",
"(",
"opts",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// The key should not be encrypted, but it could be in PKCS8 format rather than PKCS1",
"priv",
",",
"err",
":=",
"helpers",
".",
"ParsePrivateKeyPEM",
"(",
"keyBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// We will always use the first certificate inside of the root bundle as the active one",
"if",
"err",
":=",
"ensureCertKeyMatch",
"(",
"parsedCerts",
"[",
"0",
"]",
",",
"priv",
".",
"Public",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"signer",
",",
"err",
":=",
"local",
".",
"NewSigner",
"(",
"priv",
",",
"parsedCerts",
"[",
"0",
"]",
",",
"cfsigner",
".",
"DefaultSigAlgo",
"(",
"priv",
")",
",",
"SigningPolicy",
"(",
"certExpiry",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"LocalSigner",
"{",
"Cert",
":",
"certBytes",
",",
"Key",
":",
"keyBytes",
",",
"Signer",
":",
"signer",
",",
"parsedCert",
":",
"parsedCerts",
"[",
"0",
"]",
",",
"cryptoSigner",
":",
"priv",
"}",
",",
"nil",
"\n",
"}"
] |
// newLocalSigner validates the signing cert and signing key to create a local signer, which accepts a crypto signer and a cert
|
[
"newLocalSigner",
"validates",
"the",
"signing",
"cert",
"and",
"signing",
"key",
"to",
"create",
"a",
"local",
"signer",
"which",
"accepts",
"a",
"crypto",
"signer",
"and",
"a",
"cert"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L615-L655
|
train
|
docker/swarmkit
|
ca/certificates.go
|
GetLocalRootCA
|
func GetLocalRootCA(paths CertPaths) (RootCA, error) {
// Check if we have a Certificate file
cert, err := ioutil.ReadFile(paths.Cert)
if err != nil {
if os.IsNotExist(err) {
err = ErrNoLocalRootCA
}
return RootCA{}, err
}
signingCert := cert
key, err := ioutil.ReadFile(paths.Key)
if err != nil {
if !os.IsNotExist(err) {
return RootCA{}, err
}
// There may not be a local key. It's okay to pass in a nil
// key. We'll get a root CA without a signer.
key = nil
signingCert = nil
}
return NewRootCA(cert, signingCert, key, DefaultNodeCertExpiration, nil)
}
|
go
|
func GetLocalRootCA(paths CertPaths) (RootCA, error) {
// Check if we have a Certificate file
cert, err := ioutil.ReadFile(paths.Cert)
if err != nil {
if os.IsNotExist(err) {
err = ErrNoLocalRootCA
}
return RootCA{}, err
}
signingCert := cert
key, err := ioutil.ReadFile(paths.Key)
if err != nil {
if !os.IsNotExist(err) {
return RootCA{}, err
}
// There may not be a local key. It's okay to pass in a nil
// key. We'll get a root CA without a signer.
key = nil
signingCert = nil
}
return NewRootCA(cert, signingCert, key, DefaultNodeCertExpiration, nil)
}
|
[
"func",
"GetLocalRootCA",
"(",
"paths",
"CertPaths",
")",
"(",
"RootCA",
",",
"error",
")",
"{",
"// Check if we have a Certificate file",
"cert",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"paths",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"err",
"=",
"ErrNoLocalRootCA",
"\n",
"}",
"\n\n",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"signingCert",
":=",
"cert",
"\n\n",
"key",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"paths",
".",
"Key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"// There may not be a local key. It's okay to pass in a nil",
"// key. We'll get a root CA without a signer.",
"key",
"=",
"nil",
"\n",
"signingCert",
"=",
"nil",
"\n",
"}",
"\n\n",
"return",
"NewRootCA",
"(",
"cert",
",",
"signingCert",
",",
"key",
",",
"DefaultNodeCertExpiration",
",",
"nil",
")",
"\n",
"}"
] |
// GetLocalRootCA validates if the contents of the file are a valid self-signed
// CA certificate, and returns the PEM-encoded Certificate if so
|
[
"GetLocalRootCA",
"validates",
"if",
"the",
"contents",
"of",
"the",
"file",
"are",
"a",
"valid",
"self",
"-",
"signed",
"CA",
"certificate",
"and",
"returns",
"the",
"PEM",
"-",
"encoded",
"Certificate",
"if",
"so"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L688-L712
|
train
|
docker/swarmkit
|
ca/certificates.go
|
GetRemoteCA
|
func GetRemoteCA(ctx context.Context, d digest.Digest, connBroker *connectionbroker.Broker) (RootCA, error) {
// This TLS Config is intentionally using InsecureSkipVerify. We use the
// digest instead to check the integrity of the CA certificate.
insecureCreds := credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
conn, err := getGRPCConnection(insecureCreds, connBroker, false)
if err != nil {
return RootCA{}, err
}
client := api.NewCAClient(conn.ClientConn)
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
defer func() {
conn.Close(err == nil)
}()
response, err := client.GetRootCACertificate(ctx, &api.GetRootCACertificateRequest{})
if err != nil {
return RootCA{}, err
}
// If a bundle of certificates are provided, the digest covers the entire bundle and not just
// one of the certificates in the bundle. Otherwise, a node can be MITMed while joining if
// the MITM CA provides a single certificate which matches the digest, and providing arbitrary
// other non-verified root certs that the manager certificate actually chains up to.
if d != "" {
verifier := d.Verifier()
if err != nil {
return RootCA{}, errors.Wrap(err, "unexpected error getting digest verifier")
}
io.Copy(verifier, bytes.NewReader(response.Certificate))
if !verifier.Verified() {
return RootCA{}, errors.Errorf("remote CA does not match fingerprint. Expected: %s", d.Hex())
}
}
// NewRootCA will validate that the certificates are otherwise valid and create a RootCA object.
// Since there is no key, the certificate expiry does not matter and will not be used.
return NewRootCA(response.Certificate, nil, nil, DefaultNodeCertExpiration, nil)
}
|
go
|
func GetRemoteCA(ctx context.Context, d digest.Digest, connBroker *connectionbroker.Broker) (RootCA, error) {
// This TLS Config is intentionally using InsecureSkipVerify. We use the
// digest instead to check the integrity of the CA certificate.
insecureCreds := credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
conn, err := getGRPCConnection(insecureCreds, connBroker, false)
if err != nil {
return RootCA{}, err
}
client := api.NewCAClient(conn.ClientConn)
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
defer func() {
conn.Close(err == nil)
}()
response, err := client.GetRootCACertificate(ctx, &api.GetRootCACertificateRequest{})
if err != nil {
return RootCA{}, err
}
// If a bundle of certificates are provided, the digest covers the entire bundle and not just
// one of the certificates in the bundle. Otherwise, a node can be MITMed while joining if
// the MITM CA provides a single certificate which matches the digest, and providing arbitrary
// other non-verified root certs that the manager certificate actually chains up to.
if d != "" {
verifier := d.Verifier()
if err != nil {
return RootCA{}, errors.Wrap(err, "unexpected error getting digest verifier")
}
io.Copy(verifier, bytes.NewReader(response.Certificate))
if !verifier.Verified() {
return RootCA{}, errors.Errorf("remote CA does not match fingerprint. Expected: %s", d.Hex())
}
}
// NewRootCA will validate that the certificates are otherwise valid and create a RootCA object.
// Since there is no key, the certificate expiry does not matter and will not be used.
return NewRootCA(response.Certificate, nil, nil, DefaultNodeCertExpiration, nil)
}
|
[
"func",
"GetRemoteCA",
"(",
"ctx",
"context",
".",
"Context",
",",
"d",
"digest",
".",
"Digest",
",",
"connBroker",
"*",
"connectionbroker",
".",
"Broker",
")",
"(",
"RootCA",
",",
"error",
")",
"{",
"// This TLS Config is intentionally using InsecureSkipVerify. We use the",
"// digest instead to check the integrity of the CA certificate.",
"insecureCreds",
":=",
"credentials",
".",
"NewTLS",
"(",
"&",
"tls",
".",
"Config",
"{",
"InsecureSkipVerify",
":",
"true",
"}",
")",
"\n",
"conn",
",",
"err",
":=",
"getGRPCConnection",
"(",
"insecureCreds",
",",
"connBroker",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"client",
":=",
"api",
".",
"NewCAClient",
"(",
"conn",
".",
"ClientConn",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"conn",
".",
"Close",
"(",
"err",
"==",
"nil",
")",
"\n",
"}",
"(",
")",
"\n",
"response",
",",
"err",
":=",
"client",
".",
"GetRootCACertificate",
"(",
"ctx",
",",
"&",
"api",
".",
"GetRootCACertificateRequest",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"// If a bundle of certificates are provided, the digest covers the entire bundle and not just",
"// one of the certificates in the bundle. Otherwise, a node can be MITMed while joining if",
"// the MITM CA provides a single certificate which matches the digest, and providing arbitrary",
"// other non-verified root certs that the manager certificate actually chains up to.",
"if",
"d",
"!=",
"\"",
"\"",
"{",
"verifier",
":=",
"d",
".",
"Verifier",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"io",
".",
"Copy",
"(",
"verifier",
",",
"bytes",
".",
"NewReader",
"(",
"response",
".",
"Certificate",
")",
")",
"\n\n",
"if",
"!",
"verifier",
".",
"Verified",
"(",
")",
"{",
"return",
"RootCA",
"{",
"}",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"d",
".",
"Hex",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// NewRootCA will validate that the certificates are otherwise valid and create a RootCA object.",
"// Since there is no key, the certificate expiry does not matter and will not be used.",
"return",
"NewRootCA",
"(",
"response",
".",
"Certificate",
",",
"nil",
",",
"nil",
",",
"DefaultNodeCertExpiration",
",",
"nil",
")",
"\n",
"}"
] |
// GetRemoteCA returns the remote endpoint's CA certificate bundle
|
[
"GetRemoteCA",
"returns",
"the",
"remote",
"endpoint",
"s",
"CA",
"certificate",
"bundle"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L727-L767
|
train
|
docker/swarmkit
|
ca/certificates.go
|
CreateRootCA
|
func CreateRootCA(rootCN string) (RootCA, error) {
// Create a simple CSR for the CA using the default CA validator and policy
req := cfcsr.CertificateRequest{
CN: rootCN,
KeyRequest: &cfcsr.BasicKeyRequest{A: RootKeyAlgo, S: RootKeySize},
CA: &cfcsr.CAConfig{Expiry: RootCAExpiration},
}
// Generate the CA and get the certificate and private key
cert, _, key, err := initca.New(&req)
if err != nil {
return RootCA{}, err
}
rootCA, err := NewRootCA(cert, cert, key, DefaultNodeCertExpiration, nil)
if err != nil {
return RootCA{}, err
}
return rootCA, nil
}
|
go
|
func CreateRootCA(rootCN string) (RootCA, error) {
// Create a simple CSR for the CA using the default CA validator and policy
req := cfcsr.CertificateRequest{
CN: rootCN,
KeyRequest: &cfcsr.BasicKeyRequest{A: RootKeyAlgo, S: RootKeySize},
CA: &cfcsr.CAConfig{Expiry: RootCAExpiration},
}
// Generate the CA and get the certificate and private key
cert, _, key, err := initca.New(&req)
if err != nil {
return RootCA{}, err
}
rootCA, err := NewRootCA(cert, cert, key, DefaultNodeCertExpiration, nil)
if err != nil {
return RootCA{}, err
}
return rootCA, nil
}
|
[
"func",
"CreateRootCA",
"(",
"rootCN",
"string",
")",
"(",
"RootCA",
",",
"error",
")",
"{",
"// Create a simple CSR for the CA using the default CA validator and policy",
"req",
":=",
"cfcsr",
".",
"CertificateRequest",
"{",
"CN",
":",
"rootCN",
",",
"KeyRequest",
":",
"&",
"cfcsr",
".",
"BasicKeyRequest",
"{",
"A",
":",
"RootKeyAlgo",
",",
"S",
":",
"RootKeySize",
"}",
",",
"CA",
":",
"&",
"cfcsr",
".",
"CAConfig",
"{",
"Expiry",
":",
"RootCAExpiration",
"}",
",",
"}",
"\n\n",
"// Generate the CA and get the certificate and private key",
"cert",
",",
"_",
",",
"key",
",",
"err",
":=",
"initca",
".",
"New",
"(",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"rootCA",
",",
"err",
":=",
"NewRootCA",
"(",
"cert",
",",
"cert",
",",
"key",
",",
"DefaultNodeCertExpiration",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"RootCA",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"rootCA",
",",
"nil",
"\n",
"}"
] |
// CreateRootCA creates a Certificate authority for a new Swarm Cluster, potentially
// overwriting any existing CAs.
|
[
"CreateRootCA",
"creates",
"a",
"Certificate",
"authority",
"for",
"a",
"new",
"Swarm",
"Cluster",
"potentially",
"overwriting",
"any",
"existing",
"CAs",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L771-L791
|
train
|
docker/swarmkit
|
ca/certificates.go
|
readCertValidity
|
func readCertValidity(kr KeyReader) (time.Time, time.Time, error) {
var zeroTime time.Time
// Read the Cert
cert, _, err := kr.Read()
if err != nil {
return zeroTime, zeroTime, err
}
// Create an x509 certificate out of the contents on disk
certBlock, _ := pem.Decode(cert)
if certBlock == nil {
return zeroTime, zeroTime, errors.New("failed to decode certificate block")
}
X509Cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return zeroTime, zeroTime, err
}
return X509Cert.NotBefore, X509Cert.NotAfter, nil
}
|
go
|
func readCertValidity(kr KeyReader) (time.Time, time.Time, error) {
var zeroTime time.Time
// Read the Cert
cert, _, err := kr.Read()
if err != nil {
return zeroTime, zeroTime, err
}
// Create an x509 certificate out of the contents on disk
certBlock, _ := pem.Decode(cert)
if certBlock == nil {
return zeroTime, zeroTime, errors.New("failed to decode certificate block")
}
X509Cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return zeroTime, zeroTime, err
}
return X509Cert.NotBefore, X509Cert.NotAfter, nil
}
|
[
"func",
"readCertValidity",
"(",
"kr",
"KeyReader",
")",
"(",
"time",
".",
"Time",
",",
"time",
".",
"Time",
",",
"error",
")",
"{",
"var",
"zeroTime",
"time",
".",
"Time",
"\n",
"// Read the Cert",
"cert",
",",
"_",
",",
"err",
":=",
"kr",
".",
"Read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"zeroTime",
",",
"zeroTime",
",",
"err",
"\n",
"}",
"\n\n",
"// Create an x509 certificate out of the contents on disk",
"certBlock",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"cert",
")",
"\n",
"if",
"certBlock",
"==",
"nil",
"{",
"return",
"zeroTime",
",",
"zeroTime",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"X509Cert",
",",
"err",
":=",
"x509",
".",
"ParseCertificate",
"(",
"certBlock",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"zeroTime",
",",
"zeroTime",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"X509Cert",
".",
"NotBefore",
",",
"X509Cert",
".",
"NotAfter",
",",
"nil",
"\n\n",
"}"
] |
// readCertValidity returns the certificate issue and expiration time
|
[
"readCertValidity",
"returns",
"the",
"certificate",
"issue",
"and",
"expiration",
"time"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L888-L908
|
train
|
docker/swarmkit
|
ca/certificates.go
|
SaveRootCA
|
func SaveRootCA(rootCA RootCA, paths CertPaths) error {
// Make sure the necessary dirs exist and they are writable
err := os.MkdirAll(filepath.Dir(paths.Cert), 0755)
if err != nil {
return err
}
// If the root certificate got returned successfully, save the rootCA to disk.
return ioutils.AtomicWriteFile(paths.Cert, rootCA.Certs, 0644)
}
|
go
|
func SaveRootCA(rootCA RootCA, paths CertPaths) error {
// Make sure the necessary dirs exist and they are writable
err := os.MkdirAll(filepath.Dir(paths.Cert), 0755)
if err != nil {
return err
}
// If the root certificate got returned successfully, save the rootCA to disk.
return ioutils.AtomicWriteFile(paths.Cert, rootCA.Certs, 0644)
}
|
[
"func",
"SaveRootCA",
"(",
"rootCA",
"RootCA",
",",
"paths",
"CertPaths",
")",
"error",
"{",
"// Make sure the necessary dirs exist and they are writable",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Dir",
"(",
"paths",
".",
"Cert",
")",
",",
"0755",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// If the root certificate got returned successfully, save the rootCA to disk.",
"return",
"ioutils",
".",
"AtomicWriteFile",
"(",
"paths",
".",
"Cert",
",",
"rootCA",
".",
"Certs",
",",
"0644",
")",
"\n",
"}"
] |
// SaveRootCA saves a RootCA object to disk
|
[
"SaveRootCA",
"saves",
"a",
"RootCA",
"object",
"to",
"disk"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L911-L920
|
train
|
docker/swarmkit
|
ca/certificates.go
|
GenerateNewCSR
|
func GenerateNewCSR() ([]byte, []byte, error) {
req := &cfcsr.CertificateRequest{
KeyRequest: cfcsr.NewBasicKeyRequest(),
}
csr, key, err := cfcsr.ParseRequest(req)
if err != nil {
return nil, nil, err
}
key, err = pkcs8.ConvertECPrivateKeyPEM(key)
return csr, key, err
}
|
go
|
func GenerateNewCSR() ([]byte, []byte, error) {
req := &cfcsr.CertificateRequest{
KeyRequest: cfcsr.NewBasicKeyRequest(),
}
csr, key, err := cfcsr.ParseRequest(req)
if err != nil {
return nil, nil, err
}
key, err = pkcs8.ConvertECPrivateKeyPEM(key)
return csr, key, err
}
|
[
"func",
"GenerateNewCSR",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"req",
":=",
"&",
"cfcsr",
".",
"CertificateRequest",
"{",
"KeyRequest",
":",
"cfcsr",
".",
"NewBasicKeyRequest",
"(",
")",
",",
"}",
"\n\n",
"csr",
",",
"key",
",",
"err",
":=",
"cfcsr",
".",
"ParseRequest",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"key",
",",
"err",
"=",
"pkcs8",
".",
"ConvertECPrivateKeyPEM",
"(",
"key",
")",
"\n",
"return",
"csr",
",",
"key",
",",
"err",
"\n",
"}"
] |
// GenerateNewCSR returns a newly generated key and CSR signed with said key
|
[
"GenerateNewCSR",
"returns",
"a",
"newly",
"generated",
"key",
"and",
"CSR",
"signed",
"with",
"said",
"key"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L923-L935
|
train
|
docker/swarmkit
|
ca/certificates.go
|
NormalizePEMs
|
func NormalizePEMs(certs []byte) []byte {
var (
results []byte
pemBlock *pem.Block
)
for {
pemBlock, certs = pem.Decode(bytes.TrimSpace(certs))
if pemBlock == nil {
return results
}
pemBlock.Headers = nil
results = append(results, pem.EncodeToMemory(pemBlock)...)
}
}
|
go
|
func NormalizePEMs(certs []byte) []byte {
var (
results []byte
pemBlock *pem.Block
)
for {
pemBlock, certs = pem.Decode(bytes.TrimSpace(certs))
if pemBlock == nil {
return results
}
pemBlock.Headers = nil
results = append(results, pem.EncodeToMemory(pemBlock)...)
}
}
|
[
"func",
"NormalizePEMs",
"(",
"certs",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"var",
"(",
"results",
"[",
"]",
"byte",
"\n",
"pemBlock",
"*",
"pem",
".",
"Block",
"\n",
")",
"\n",
"for",
"{",
"pemBlock",
",",
"certs",
"=",
"pem",
".",
"Decode",
"(",
"bytes",
".",
"TrimSpace",
"(",
"certs",
")",
")",
"\n",
"if",
"pemBlock",
"==",
"nil",
"{",
"return",
"results",
"\n",
"}",
"\n",
"pemBlock",
".",
"Headers",
"=",
"nil",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"pem",
".",
"EncodeToMemory",
"(",
"pemBlock",
")",
"...",
")",
"\n",
"}",
"\n",
"}"
] |
// NormalizePEMs takes a bundle of PEM-encoded certificates in a certificate bundle,
// decodes them, removes headers, and re-encodes them to make sure that they have
// consistent whitespace. Note that this is intended to normalize x509 certificates
// in PEM format, hence the stripping out of headers.
|
[
"NormalizePEMs",
"takes",
"a",
"bundle",
"of",
"PEM",
"-",
"encoded",
"certificates",
"in",
"a",
"certificate",
"bundle",
"decodes",
"them",
"removes",
"headers",
"and",
"re",
"-",
"encodes",
"them",
"to",
"make",
"sure",
"that",
"they",
"have",
"consistent",
"whitespace",
".",
"Note",
"that",
"this",
"is",
"intended",
"to",
"normalize",
"x509",
"certificates",
"in",
"PEM",
"format",
"hence",
"the",
"stripping",
"out",
"of",
"headers",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/certificates.go#L941-L954
|
train
|
docker/swarmkit
|
manager/state/watch.go
|
Matches
|
func (e EventCommit) Matches(watchEvent events.Event) bool {
_, ok := watchEvent.(EventCommit)
return ok
}
|
go
|
func (e EventCommit) Matches(watchEvent events.Event) bool {
_, ok := watchEvent.(EventCommit)
return ok
}
|
[
"func",
"(",
"e",
"EventCommit",
")",
"Matches",
"(",
"watchEvent",
"events",
".",
"Event",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"watchEvent",
".",
"(",
"EventCommit",
")",
"\n",
"return",
"ok",
"\n",
"}"
] |
// Matches returns true if this event is a commit event.
|
[
"Matches",
"returns",
"true",
"if",
"this",
"event",
"is",
"a",
"commit",
"event",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/watch.go#L15-L18
|
train
|
docker/swarmkit
|
manager/state/watch.go
|
TaskCheckStateGreaterThan
|
func TaskCheckStateGreaterThan(t1, t2 *api.Task) bool {
return t2.Status.State > t1.Status.State
}
|
go
|
func TaskCheckStateGreaterThan(t1, t2 *api.Task) bool {
return t2.Status.State > t1.Status.State
}
|
[
"func",
"TaskCheckStateGreaterThan",
"(",
"t1",
",",
"t2",
"*",
"api",
".",
"Task",
")",
"bool",
"{",
"return",
"t2",
".",
"Status",
".",
"State",
">",
"t1",
".",
"Status",
".",
"State",
"\n",
"}"
] |
// TaskCheckStateGreaterThan is a TaskCheckFunc for checking task state.
|
[
"TaskCheckStateGreaterThan",
"is",
"a",
"TaskCheckFunc",
"for",
"checking",
"task",
"state",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/watch.go#L21-L23
|
train
|
docker/swarmkit
|
manager/state/watch.go
|
NodeCheckState
|
func NodeCheckState(n1, n2 *api.Node) bool {
return n1.Status.State == n2.Status.State
}
|
go
|
func NodeCheckState(n1, n2 *api.Node) bool {
return n1.Status.State == n2.Status.State
}
|
[
"func",
"NodeCheckState",
"(",
"n1",
",",
"n2",
"*",
"api",
".",
"Node",
")",
"bool",
"{",
"return",
"n1",
".",
"Status",
".",
"State",
"==",
"n2",
".",
"Status",
".",
"State",
"\n",
"}"
] |
// NodeCheckState is a NodeCheckFunc for matching node state.
|
[
"NodeCheckState",
"is",
"a",
"NodeCheckFunc",
"for",
"matching",
"node",
"state",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/watch.go#L26-L28
|
train
|
docker/swarmkit
|
manager/state/watch.go
|
Matcher
|
func Matcher(specifiers ...api.Event) events.MatcherFunc {
return events.MatcherFunc(func(event events.Event) bool {
for _, s := range specifiers {
if s.Matches(event) {
return true
}
}
return false
})
}
|
go
|
func Matcher(specifiers ...api.Event) events.MatcherFunc {
return events.MatcherFunc(func(event events.Event) bool {
for _, s := range specifiers {
if s.Matches(event) {
return true
}
}
return false
})
}
|
[
"func",
"Matcher",
"(",
"specifiers",
"...",
"api",
".",
"Event",
")",
"events",
".",
"MatcherFunc",
"{",
"return",
"events",
".",
"MatcherFunc",
"(",
"func",
"(",
"event",
"events",
".",
"Event",
")",
"bool",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"specifiers",
"{",
"if",
"s",
".",
"Matches",
"(",
"event",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
")",
"\n",
"}"
] |
// Matcher returns an events.Matcher that Matches the specifiers with OR logic.
|
[
"Matcher",
"returns",
"an",
"events",
".",
"Matcher",
"that",
"Matches",
"the",
"specifiers",
"with",
"OR",
"logic",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/watch.go#L65-L74
|
train
|
docker/swarmkit
|
manager/controlapi/resource.go
|
CreateResource
|
func (s *Server) CreateResource(ctx context.Context, request *api.CreateResourceRequest) (*api.CreateResourceResponse, error) {
if request.Annotations == nil || request.Annotations.Name == "" {
return nil, status.Errorf(codes.InvalidArgument, "Resource must have a name")
}
// finally, validate that Kind is not an emptystring. We know that creating
// with Kind as empty string should fail at the store level, but to make
// errors clearer, special case this.
if request.Kind == "" {
return nil, status.Errorf(codes.InvalidArgument, "Resource must belong to an Extension")
}
r := &api.Resource{
ID: identity.NewID(),
Annotations: *request.Annotations,
Kind: request.Kind,
Payload: request.Payload,
}
err := s.store.Update(func(tx store.Tx) error {
return store.CreateResource(tx, r)
})
switch err {
case store.ErrNoKind:
return nil, status.Errorf(codes.InvalidArgument, "Kind %v is not registered", r.Kind)
case store.ErrNameConflict:
return nil, status.Errorf(
codes.AlreadyExists,
"A resource with name %v already exists",
r.Annotations.Name,
)
case nil:
log.G(ctx).WithFields(logrus.Fields{
"resource.Name": r.Annotations.Name,
"method": "CreateResource",
}).Debugf("resource created")
return &api.CreateResourceResponse{Resource: r}, nil
default:
return nil, err
}
}
|
go
|
func (s *Server) CreateResource(ctx context.Context, request *api.CreateResourceRequest) (*api.CreateResourceResponse, error) {
if request.Annotations == nil || request.Annotations.Name == "" {
return nil, status.Errorf(codes.InvalidArgument, "Resource must have a name")
}
// finally, validate that Kind is not an emptystring. We know that creating
// with Kind as empty string should fail at the store level, but to make
// errors clearer, special case this.
if request.Kind == "" {
return nil, status.Errorf(codes.InvalidArgument, "Resource must belong to an Extension")
}
r := &api.Resource{
ID: identity.NewID(),
Annotations: *request.Annotations,
Kind: request.Kind,
Payload: request.Payload,
}
err := s.store.Update(func(tx store.Tx) error {
return store.CreateResource(tx, r)
})
switch err {
case store.ErrNoKind:
return nil, status.Errorf(codes.InvalidArgument, "Kind %v is not registered", r.Kind)
case store.ErrNameConflict:
return nil, status.Errorf(
codes.AlreadyExists,
"A resource with name %v already exists",
r.Annotations.Name,
)
case nil:
log.G(ctx).WithFields(logrus.Fields{
"resource.Name": r.Annotations.Name,
"method": "CreateResource",
}).Debugf("resource created")
return &api.CreateResourceResponse{Resource: r}, nil
default:
return nil, err
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"CreateResource",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"CreateResourceRequest",
")",
"(",
"*",
"api",
".",
"CreateResourceResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"Annotations",
"==",
"nil",
"||",
"request",
".",
"Annotations",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// finally, validate that Kind is not an emptystring. We know that creating",
"// with Kind as empty string should fail at the store level, but to make",
"// errors clearer, special case this.",
"if",
"request",
".",
"Kind",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
":=",
"&",
"api",
".",
"Resource",
"{",
"ID",
":",
"identity",
".",
"NewID",
"(",
")",
",",
"Annotations",
":",
"*",
"request",
".",
"Annotations",
",",
"Kind",
":",
"request",
".",
"Kind",
",",
"Payload",
":",
"request",
".",
"Payload",
",",
"}",
"\n\n",
"err",
":=",
"s",
".",
"store",
".",
"Update",
"(",
"func",
"(",
"tx",
"store",
".",
"Tx",
")",
"error",
"{",
"return",
"store",
".",
"CreateResource",
"(",
"tx",
",",
"r",
")",
"\n",
"}",
")",
"\n\n",
"switch",
"err",
"{",
"case",
"store",
".",
"ErrNoKind",
":",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
",",
"r",
".",
"Kind",
")",
"\n",
"case",
"store",
".",
"ErrNameConflict",
":",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"AlreadyExists",
",",
"\"",
"\"",
",",
"r",
".",
"Annotations",
".",
"Name",
",",
")",
"\n",
"case",
"nil",
":",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"r",
".",
"Annotations",
".",
"Name",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
")",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"&",
"api",
".",
"CreateResourceResponse",
"{",
"Resource",
":",
"r",
"}",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// CreateResource returns a `CreateResourceResponse` after creating a `Resource` based
// on the provided `CreateResourceRequest.Resource`.
// - Returns `InvalidArgument` if the `CreateResourceRequest.Resource` is malformed,
// or if the config data is too long or contains invalid characters.
// - Returns an error if the creation fails.
|
[
"CreateResource",
"returns",
"a",
"CreateResourceResponse",
"after",
"creating",
"a",
"Resource",
"based",
"on",
"the",
"provided",
"CreateResourceRequest",
".",
"Resource",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"CreateResourceRequest",
".",
"Resource",
"is",
"malformed",
"or",
"if",
"the",
"config",
"data",
"is",
"too",
"long",
"or",
"contains",
"invalid",
"characters",
".",
"-",
"Returns",
"an",
"error",
"if",
"the",
"creation",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/resource.go#L21-L61
|
train
|
docker/swarmkit
|
manager/controlapi/resource.go
|
GetResource
|
func (s *Server) GetResource(ctx context.Context, request *api.GetResourceRequest) (*api.GetResourceResponse, error) {
if request.ResourceID == "" {
return nil, status.Errorf(codes.InvalidArgument, "resource ID must be present")
}
var resource *api.Resource
s.store.View(func(tx store.ReadTx) {
resource = store.GetResource(tx, request.ResourceID)
})
if resource == nil {
return nil, status.Errorf(codes.NotFound, "resource %s not found", request.ResourceID)
}
return &api.GetResourceResponse{Resource: resource}, nil
}
|
go
|
func (s *Server) GetResource(ctx context.Context, request *api.GetResourceRequest) (*api.GetResourceResponse, error) {
if request.ResourceID == "" {
return nil, status.Errorf(codes.InvalidArgument, "resource ID must be present")
}
var resource *api.Resource
s.store.View(func(tx store.ReadTx) {
resource = store.GetResource(tx, request.ResourceID)
})
if resource == nil {
return nil, status.Errorf(codes.NotFound, "resource %s not found", request.ResourceID)
}
return &api.GetResourceResponse{Resource: resource}, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"GetResource",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"GetResourceRequest",
")",
"(",
"*",
"api",
".",
"GetResourceResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"ResourceID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"resource",
"*",
"api",
".",
"Resource",
"\n",
"s",
".",
"store",
".",
"View",
"(",
"func",
"(",
"tx",
"store",
".",
"ReadTx",
")",
"{",
"resource",
"=",
"store",
".",
"GetResource",
"(",
"tx",
",",
"request",
".",
"ResourceID",
")",
"\n",
"}",
")",
"\n\n",
"if",
"resource",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"ResourceID",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"GetResourceResponse",
"{",
"Resource",
":",
"resource",
"}",
",",
"nil",
"\n",
"}"
] |
// GetResource returns a `GetResourceResponse` with a `Resource` with the same
// id as `GetResourceRequest.Resource`
// - Returns `NotFound` if the Resource with the given id is not found.
// - Returns `InvalidArgument` if the `GetResourceRequest.Resource` is empty.
// - Returns an error if getting fails.
|
[
"GetResource",
"returns",
"a",
"GetResourceResponse",
"with",
"a",
"Resource",
"with",
"the",
"same",
"id",
"as",
"GetResourceRequest",
".",
"Resource",
"-",
"Returns",
"NotFound",
"if",
"the",
"Resource",
"with",
"the",
"given",
"id",
"is",
"not",
"found",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"GetResourceRequest",
".",
"Resource",
"is",
"empty",
".",
"-",
"Returns",
"an",
"error",
"if",
"getting",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/resource.go#L68-L82
|
train
|
docker/swarmkit
|
manager/controlapi/resource.go
|
RemoveResource
|
func (s *Server) RemoveResource(ctx context.Context, request *api.RemoveResourceRequest) (*api.RemoveResourceResponse, error) {
if request.ResourceID == "" {
return nil, status.Errorf(codes.InvalidArgument, "resource ID must be present")
}
err := s.store.Update(func(tx store.Tx) error {
return store.DeleteResource(tx, request.ResourceID)
})
switch err {
case store.ErrNotExist:
return nil, status.Errorf(codes.NotFound, "resource %s not found", request.ResourceID)
case nil:
return &api.RemoveResourceResponse{}, nil
default:
return nil, err
}
}
|
go
|
func (s *Server) RemoveResource(ctx context.Context, request *api.RemoveResourceRequest) (*api.RemoveResourceResponse, error) {
if request.ResourceID == "" {
return nil, status.Errorf(codes.InvalidArgument, "resource ID must be present")
}
err := s.store.Update(func(tx store.Tx) error {
return store.DeleteResource(tx, request.ResourceID)
})
switch err {
case store.ErrNotExist:
return nil, status.Errorf(codes.NotFound, "resource %s not found", request.ResourceID)
case nil:
return &api.RemoveResourceResponse{}, nil
default:
return nil, err
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"RemoveResource",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"RemoveResourceRequest",
")",
"(",
"*",
"api",
".",
"RemoveResourceResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"ResourceID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"store",
".",
"Update",
"(",
"func",
"(",
"tx",
"store",
".",
"Tx",
")",
"error",
"{",
"return",
"store",
".",
"DeleteResource",
"(",
"tx",
",",
"request",
".",
"ResourceID",
")",
"\n",
"}",
")",
"\n",
"switch",
"err",
"{",
"case",
"store",
".",
"ErrNotExist",
":",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"ResourceID",
")",
"\n",
"case",
"nil",
":",
"return",
"&",
"api",
".",
"RemoveResourceResponse",
"{",
"}",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// RemoveResource removes the `Resource` referenced by `RemoveResourceRequest.ResourceID`.
// - Returns `InvalidArgument` if `RemoveResourceRequest.ResourceID` is empty.
// - Returns `NotFound` if the a resource named `RemoveResourceRequest.ResourceID` is not found.
// - Returns an error if the deletion fails.
|
[
"RemoveResource",
"removes",
"the",
"Resource",
"referenced",
"by",
"RemoveResourceRequest",
".",
"ResourceID",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"RemoveResourceRequest",
".",
"ResourceID",
"is",
"empty",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"a",
"resource",
"named",
"RemoveResourceRequest",
".",
"ResourceID",
"is",
"not",
"found",
".",
"-",
"Returns",
"an",
"error",
"if",
"the",
"deletion",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/resource.go#L88-L103
|
train
|
docker/swarmkit
|
manager/controlapi/resource.go
|
ListResources
|
func (s *Server) ListResources(ctx context.Context, request *api.ListResourcesRequest) (*api.ListResourcesResponse, error) {
var (
resources []*api.Resource
respResources []*api.Resource
err error
byFilters []store.By
by store.By
labels map[string]string
)
// andKind is set to true if the Extension filter is not the only filter
// being used. If this is the case, we do not have to compare by strings,
// which could be slow.
var andKind bool
if request.Filters != nil {
for _, name := range request.Filters.Names {
byFilters = append(byFilters, store.ByName(name))
}
for _, prefix := range request.Filters.NamePrefixes {
byFilters = append(byFilters, store.ByNamePrefix(prefix))
}
for _, prefix := range request.Filters.IDPrefixes {
byFilters = append(byFilters, store.ByIDPrefix(prefix))
}
labels = request.Filters.Labels
if request.Filters.Kind != "" {
// if we're filtering on Extensions, then set this to true. If Kind is
// the _only_ kind of filter, we'll set this to false below.
andKind = true
}
}
switch len(byFilters) {
case 0:
// NOTE(dperny): currently, filtering using store.ByKind would apply an
// Or operation, which means that filtering by kind would return a
// union. However, for Kind filters, we actually want the
// _intersection_; that is, _only_ objects of the specified kind. we
// could dig into the db code to figure out how to write and use an
// efficient And combinator, but I don't have the time nor expertise to
// do so at the moment. instead, we'll filter by kind after the fact.
// however, if there are no other kinds of filters, and we're ONLY
// listing by Kind, we can set that to be the only filter.
if andKind {
by = store.ByKind(request.Filters.Kind)
andKind = false
} else {
by = store.All
}
case 1:
by = byFilters[0]
default:
by = store.Or(byFilters...)
}
s.store.View(func(tx store.ReadTx) {
resources, err = store.FindResources(tx, by)
})
if err != nil {
return nil, err
}
// filter by label and extension
for _, resource := range resources {
if !filterMatchLabels(resource.Annotations.Labels, labels) {
continue
}
if andKind && resource.Kind != request.Filters.Kind {
continue
}
respResources = append(respResources, resource)
}
return &api.ListResourcesResponse{Resources: respResources}, nil
}
|
go
|
func (s *Server) ListResources(ctx context.Context, request *api.ListResourcesRequest) (*api.ListResourcesResponse, error) {
var (
resources []*api.Resource
respResources []*api.Resource
err error
byFilters []store.By
by store.By
labels map[string]string
)
// andKind is set to true if the Extension filter is not the only filter
// being used. If this is the case, we do not have to compare by strings,
// which could be slow.
var andKind bool
if request.Filters != nil {
for _, name := range request.Filters.Names {
byFilters = append(byFilters, store.ByName(name))
}
for _, prefix := range request.Filters.NamePrefixes {
byFilters = append(byFilters, store.ByNamePrefix(prefix))
}
for _, prefix := range request.Filters.IDPrefixes {
byFilters = append(byFilters, store.ByIDPrefix(prefix))
}
labels = request.Filters.Labels
if request.Filters.Kind != "" {
// if we're filtering on Extensions, then set this to true. If Kind is
// the _only_ kind of filter, we'll set this to false below.
andKind = true
}
}
switch len(byFilters) {
case 0:
// NOTE(dperny): currently, filtering using store.ByKind would apply an
// Or operation, which means that filtering by kind would return a
// union. However, for Kind filters, we actually want the
// _intersection_; that is, _only_ objects of the specified kind. we
// could dig into the db code to figure out how to write and use an
// efficient And combinator, but I don't have the time nor expertise to
// do so at the moment. instead, we'll filter by kind after the fact.
// however, if there are no other kinds of filters, and we're ONLY
// listing by Kind, we can set that to be the only filter.
if andKind {
by = store.ByKind(request.Filters.Kind)
andKind = false
} else {
by = store.All
}
case 1:
by = byFilters[0]
default:
by = store.Or(byFilters...)
}
s.store.View(func(tx store.ReadTx) {
resources, err = store.FindResources(tx, by)
})
if err != nil {
return nil, err
}
// filter by label and extension
for _, resource := range resources {
if !filterMatchLabels(resource.Annotations.Labels, labels) {
continue
}
if andKind && resource.Kind != request.Filters.Kind {
continue
}
respResources = append(respResources, resource)
}
return &api.ListResourcesResponse{Resources: respResources}, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"ListResources",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"ListResourcesRequest",
")",
"(",
"*",
"api",
".",
"ListResourcesResponse",
",",
"error",
")",
"{",
"var",
"(",
"resources",
"[",
"]",
"*",
"api",
".",
"Resource",
"\n",
"respResources",
"[",
"]",
"*",
"api",
".",
"Resource",
"\n",
"err",
"error",
"\n",
"byFilters",
"[",
"]",
"store",
".",
"By",
"\n",
"by",
"store",
".",
"By",
"\n",
"labels",
"map",
"[",
"string",
"]",
"string",
"\n",
")",
"\n\n",
"// andKind is set to true if the Extension filter is not the only filter",
"// being used. If this is the case, we do not have to compare by strings,",
"// which could be slow.",
"var",
"andKind",
"bool",
"\n\n",
"if",
"request",
".",
"Filters",
"!=",
"nil",
"{",
"for",
"_",
",",
"name",
":=",
"range",
"request",
".",
"Filters",
".",
"Names",
"{",
"byFilters",
"=",
"append",
"(",
"byFilters",
",",
"store",
".",
"ByName",
"(",
"name",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"prefix",
":=",
"range",
"request",
".",
"Filters",
".",
"NamePrefixes",
"{",
"byFilters",
"=",
"append",
"(",
"byFilters",
",",
"store",
".",
"ByNamePrefix",
"(",
"prefix",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"prefix",
":=",
"range",
"request",
".",
"Filters",
".",
"IDPrefixes",
"{",
"byFilters",
"=",
"append",
"(",
"byFilters",
",",
"store",
".",
"ByIDPrefix",
"(",
"prefix",
")",
")",
"\n",
"}",
"\n",
"labels",
"=",
"request",
".",
"Filters",
".",
"Labels",
"\n",
"if",
"request",
".",
"Filters",
".",
"Kind",
"!=",
"\"",
"\"",
"{",
"// if we're filtering on Extensions, then set this to true. If Kind is",
"// the _only_ kind of filter, we'll set this to false below.",
"andKind",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"switch",
"len",
"(",
"byFilters",
")",
"{",
"case",
"0",
":",
"// NOTE(dperny): currently, filtering using store.ByKind would apply an",
"// Or operation, which means that filtering by kind would return a",
"// union. However, for Kind filters, we actually want the",
"// _intersection_; that is, _only_ objects of the specified kind. we",
"// could dig into the db code to figure out how to write and use an",
"// efficient And combinator, but I don't have the time nor expertise to",
"// do so at the moment. instead, we'll filter by kind after the fact.",
"// however, if there are no other kinds of filters, and we're ONLY",
"// listing by Kind, we can set that to be the only filter.",
"if",
"andKind",
"{",
"by",
"=",
"store",
".",
"ByKind",
"(",
"request",
".",
"Filters",
".",
"Kind",
")",
"\n",
"andKind",
"=",
"false",
"\n",
"}",
"else",
"{",
"by",
"=",
"store",
".",
"All",
"\n",
"}",
"\n",
"case",
"1",
":",
"by",
"=",
"byFilters",
"[",
"0",
"]",
"\n",
"default",
":",
"by",
"=",
"store",
".",
"Or",
"(",
"byFilters",
"...",
")",
"\n",
"}",
"\n\n",
"s",
".",
"store",
".",
"View",
"(",
"func",
"(",
"tx",
"store",
".",
"ReadTx",
")",
"{",
"resources",
",",
"err",
"=",
"store",
".",
"FindResources",
"(",
"tx",
",",
"by",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// filter by label and extension",
"for",
"_",
",",
"resource",
":=",
"range",
"resources",
"{",
"if",
"!",
"filterMatchLabels",
"(",
"resource",
".",
"Annotations",
".",
"Labels",
",",
"labels",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"andKind",
"&&",
"resource",
".",
"Kind",
"!=",
"request",
".",
"Filters",
".",
"Kind",
"{",
"continue",
"\n",
"}",
"\n",
"respResources",
"=",
"append",
"(",
"respResources",
",",
"resource",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"ListResourcesResponse",
"{",
"Resources",
":",
"respResources",
"}",
",",
"nil",
"\n",
"}"
] |
// ListResources returns a `ListResourcesResponse` with a list of `Resource`s stored in the raft store,
// or all resources matching any name in `ListConfigsRequest.Names`, any
// name prefix in `ListResourcesRequest.NamePrefixes`, any id in
// `ListResourcesRequest.ResourceIDs`, or any id prefix in `ListResourcesRequest.IDPrefixes`.
// - Returns an error if listing fails.
|
[
"ListResources",
"returns",
"a",
"ListResourcesResponse",
"with",
"a",
"list",
"of",
"Resource",
"s",
"stored",
"in",
"the",
"raft",
"store",
"or",
"all",
"resources",
"matching",
"any",
"name",
"in",
"ListConfigsRequest",
".",
"Names",
"any",
"name",
"prefix",
"in",
"ListResourcesRequest",
".",
"NamePrefixes",
"any",
"id",
"in",
"ListResourcesRequest",
".",
"ResourceIDs",
"or",
"any",
"id",
"prefix",
"in",
"ListResourcesRequest",
".",
"IDPrefixes",
".",
"-",
"Returns",
"an",
"error",
"if",
"listing",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/resource.go#L110-L185
|
train
|
docker/swarmkit
|
manager/controlapi/resource.go
|
UpdateResource
|
func (s *Server) UpdateResource(ctx context.Context, request *api.UpdateResourceRequest) (*api.UpdateResourceResponse, error) {
if request.ResourceID == "" || request.ResourceVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, "must include ID and version")
}
var r *api.Resource
err := s.store.Update(func(tx store.Tx) error {
r = store.GetResource(tx, request.ResourceID)
if r == nil {
return status.Errorf(codes.NotFound, "resource %v not found", request.ResourceID)
}
if request.Annotations != nil {
if r.Annotations.Name != request.Annotations.Name {
return status.Errorf(codes.InvalidArgument, "cannot change resource name")
}
r.Annotations = *request.Annotations
}
r.Meta.Version = *request.ResourceVersion
// only alter the payload if the
if request.Payload != nil {
r.Payload = request.Payload
}
return store.UpdateResource(tx, r)
})
switch err {
case store.ErrSequenceConflict:
return nil, status.Errorf(codes.InvalidArgument, "update out of sequence")
case nil:
return &api.UpdateResourceResponse{
Resource: r,
}, nil
default:
return nil, err
}
}
|
go
|
func (s *Server) UpdateResource(ctx context.Context, request *api.UpdateResourceRequest) (*api.UpdateResourceResponse, error) {
if request.ResourceID == "" || request.ResourceVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, "must include ID and version")
}
var r *api.Resource
err := s.store.Update(func(tx store.Tx) error {
r = store.GetResource(tx, request.ResourceID)
if r == nil {
return status.Errorf(codes.NotFound, "resource %v not found", request.ResourceID)
}
if request.Annotations != nil {
if r.Annotations.Name != request.Annotations.Name {
return status.Errorf(codes.InvalidArgument, "cannot change resource name")
}
r.Annotations = *request.Annotations
}
r.Meta.Version = *request.ResourceVersion
// only alter the payload if the
if request.Payload != nil {
r.Payload = request.Payload
}
return store.UpdateResource(tx, r)
})
switch err {
case store.ErrSequenceConflict:
return nil, status.Errorf(codes.InvalidArgument, "update out of sequence")
case nil:
return &api.UpdateResourceResponse{
Resource: r,
}, nil
default:
return nil, err
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"UpdateResource",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"UpdateResourceRequest",
")",
"(",
"*",
"api",
".",
"UpdateResourceResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"ResourceID",
"==",
"\"",
"\"",
"||",
"request",
".",
"ResourceVersion",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"r",
"*",
"api",
".",
"Resource",
"\n",
"err",
":=",
"s",
".",
"store",
".",
"Update",
"(",
"func",
"(",
"tx",
"store",
".",
"Tx",
")",
"error",
"{",
"r",
"=",
"store",
".",
"GetResource",
"(",
"tx",
",",
"request",
".",
"ResourceID",
")",
"\n",
"if",
"r",
"==",
"nil",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"ResourceID",
")",
"\n",
"}",
"\n\n",
"if",
"request",
".",
"Annotations",
"!=",
"nil",
"{",
"if",
"r",
".",
"Annotations",
".",
"Name",
"!=",
"request",
".",
"Annotations",
".",
"Name",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
".",
"Annotations",
"=",
"*",
"request",
".",
"Annotations",
"\n",
"}",
"\n",
"r",
".",
"Meta",
".",
"Version",
"=",
"*",
"request",
".",
"ResourceVersion",
"\n",
"// only alter the payload if the",
"if",
"request",
".",
"Payload",
"!=",
"nil",
"{",
"r",
".",
"Payload",
"=",
"request",
".",
"Payload",
"\n",
"}",
"\n\n",
"return",
"store",
".",
"UpdateResource",
"(",
"tx",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"switch",
"err",
"{",
"case",
"store",
".",
"ErrSequenceConflict",
":",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"case",
"nil",
":",
"return",
"&",
"api",
".",
"UpdateResourceResponse",
"{",
"Resource",
":",
"r",
",",
"}",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// UpdateResource updates the resource with the given `UpdateResourceRequest.Resource.Id` using the given `UpdateResourceRequest.Resource` and returns a `UpdateResourceResponse`.
// - Returns `NotFound` if the Resource with the given `UpdateResourceRequest.Resource.Id` is not found.
// - Returns `InvalidArgument` if the UpdateResourceRequest.Resource.Id` is empty.
// - Returns an error if updating fails.
|
[
"UpdateResource",
"updates",
"the",
"resource",
"with",
"the",
"given",
"UpdateResourceRequest",
".",
"Resource",
".",
"Id",
"using",
"the",
"given",
"UpdateResourceRequest",
".",
"Resource",
"and",
"returns",
"a",
"UpdateResourceResponse",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Resource",
"with",
"the",
"given",
"UpdateResourceRequest",
".",
"Resource",
".",
"Id",
"is",
"not",
"found",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"UpdateResourceRequest",
".",
"Resource",
".",
"Id",
"is",
"empty",
".",
"-",
"Returns",
"an",
"error",
"if",
"updating",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/resource.go#L191-L226
|
train
|
docker/swarmkit
|
agent/configs/configs.go
|
Get
|
func (r *configs) Get(configID string) (*api.Config, error) {
r.mu.RLock()
defer r.mu.RUnlock()
if r, ok := r.m[configID]; ok {
return r, nil
}
return nil, fmt.Errorf("config %s not found", configID)
}
|
go
|
func (r *configs) Get(configID string) (*api.Config, error) {
r.mu.RLock()
defer r.mu.RUnlock()
if r, ok := r.m[configID]; ok {
return r, nil
}
return nil, fmt.Errorf("config %s not found", configID)
}
|
[
"func",
"(",
"r",
"*",
"configs",
")",
"Get",
"(",
"configID",
"string",
")",
"(",
"*",
"api",
".",
"Config",
",",
"error",
")",
"{",
"r",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"r",
",",
"ok",
":=",
"r",
".",
"m",
"[",
"configID",
"]",
";",
"ok",
"{",
"return",
"r",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"configID",
")",
"\n",
"}"
] |
// Get returns a config by ID. If the config doesn't exist, returns nil.
|
[
"Get",
"returns",
"a",
"config",
"by",
"ID",
".",
"If",
"the",
"config",
"doesn",
"t",
"exist",
"returns",
"nil",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/configs/configs.go#L26-L33
|
train
|
docker/swarmkit
|
agent/configs/configs.go
|
Add
|
func (r *configs) Add(configs ...api.Config) {
r.mu.Lock()
defer r.mu.Unlock()
for _, config := range configs {
r.m[config.ID] = config.Copy()
}
}
|
go
|
func (r *configs) Add(configs ...api.Config) {
r.mu.Lock()
defer r.mu.Unlock()
for _, config := range configs {
r.m[config.ID] = config.Copy()
}
}
|
[
"func",
"(",
"r",
"*",
"configs",
")",
"Add",
"(",
"configs",
"...",
"api",
".",
"Config",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"config",
":=",
"range",
"configs",
"{",
"r",
".",
"m",
"[",
"config",
".",
"ID",
"]",
"=",
"config",
".",
"Copy",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// Add adds one or more configs to the config map.
|
[
"Add",
"adds",
"one",
"or",
"more",
"configs",
"to",
"the",
"config",
"map",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/configs/configs.go#L36-L42
|
train
|
docker/swarmkit
|
agent/configs/configs.go
|
Remove
|
func (r *configs) Remove(configs []string) {
r.mu.Lock()
defer r.mu.Unlock()
for _, config := range configs {
delete(r.m, config)
}
}
|
go
|
func (r *configs) Remove(configs []string) {
r.mu.Lock()
defer r.mu.Unlock()
for _, config := range configs {
delete(r.m, config)
}
}
|
[
"func",
"(",
"r",
"*",
"configs",
")",
"Remove",
"(",
"configs",
"[",
"]",
"string",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"config",
":=",
"range",
"configs",
"{",
"delete",
"(",
"r",
".",
"m",
",",
"config",
")",
"\n",
"}",
"\n",
"}"
] |
// Remove removes one or more configs by ID from the config map. Succeeds
// whether or not the given IDs are in the map.
|
[
"Remove",
"removes",
"one",
"or",
"more",
"configs",
"by",
"ID",
"from",
"the",
"config",
"map",
".",
"Succeeds",
"whether",
"or",
"not",
"the",
"given",
"IDs",
"are",
"in",
"the",
"map",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/configs/configs.go#L46-L52
|
train
|
docker/swarmkit
|
agent/configs/configs.go
|
Reset
|
func (r *configs) Reset() {
r.mu.Lock()
defer r.mu.Unlock()
r.m = make(map[string]*api.Config)
}
|
go
|
func (r *configs) Reset() {
r.mu.Lock()
defer r.mu.Unlock()
r.m = make(map[string]*api.Config)
}
|
[
"func",
"(",
"r",
"*",
"configs",
")",
"Reset",
"(",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"r",
".",
"m",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Config",
")",
"\n",
"}"
] |
// Reset removes all the configs.
|
[
"Reset",
"removes",
"all",
"the",
"configs",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/configs/configs.go#L55-L59
|
train
|
docker/swarmkit
|
agent/configs/configs.go
|
Restrict
|
func Restrict(configs exec.ConfigGetter, t *api.Task) exec.ConfigGetter {
cids := map[string]struct{}{}
container := t.Spec.GetContainer()
if container != nil {
for _, configRef := range container.Configs {
cids[configRef.ConfigID] = struct{}{}
}
}
return &taskRestrictedConfigsProvider{configs: configs, configIDs: cids}
}
|
go
|
func Restrict(configs exec.ConfigGetter, t *api.Task) exec.ConfigGetter {
cids := map[string]struct{}{}
container := t.Spec.GetContainer()
if container != nil {
for _, configRef := range container.Configs {
cids[configRef.ConfigID] = struct{}{}
}
}
return &taskRestrictedConfigsProvider{configs: configs, configIDs: cids}
}
|
[
"func",
"Restrict",
"(",
"configs",
"exec",
".",
"ConfigGetter",
",",
"t",
"*",
"api",
".",
"Task",
")",
"exec",
".",
"ConfigGetter",
"{",
"cids",
":=",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"container",
":=",
"t",
".",
"Spec",
".",
"GetContainer",
"(",
")",
"\n",
"if",
"container",
"!=",
"nil",
"{",
"for",
"_",
",",
"configRef",
":=",
"range",
"container",
".",
"Configs",
"{",
"cids",
"[",
"configRef",
".",
"ConfigID",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"taskRestrictedConfigsProvider",
"{",
"configs",
":",
"configs",
",",
"configIDs",
":",
"cids",
"}",
"\n",
"}"
] |
// Restrict provides a getter that only allows access to the configs
// referenced by the task.
|
[
"Restrict",
"provides",
"a",
"getter",
"that",
"only",
"allows",
"access",
"to",
"the",
"configs",
"referenced",
"by",
"the",
"task",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/configs/configs.go#L77-L88
|
train
|
docker/swarmkit
|
manager/controlapi/server.go
|
NewServer
|
func NewServer(store *store.MemoryStore, raft *raft.Node, securityConfig *ca.SecurityConfig, pg plugingetter.PluginGetter, dr *drivers.DriverProvider) *Server {
return &Server{
store: store,
dr: dr,
raft: raft,
securityConfig: securityConfig,
pg: pg,
}
}
|
go
|
func NewServer(store *store.MemoryStore, raft *raft.Node, securityConfig *ca.SecurityConfig, pg plugingetter.PluginGetter, dr *drivers.DriverProvider) *Server {
return &Server{
store: store,
dr: dr,
raft: raft,
securityConfig: securityConfig,
pg: pg,
}
}
|
[
"func",
"NewServer",
"(",
"store",
"*",
"store",
".",
"MemoryStore",
",",
"raft",
"*",
"raft",
".",
"Node",
",",
"securityConfig",
"*",
"ca",
".",
"SecurityConfig",
",",
"pg",
"plugingetter",
".",
"PluginGetter",
",",
"dr",
"*",
"drivers",
".",
"DriverProvider",
")",
"*",
"Server",
"{",
"return",
"&",
"Server",
"{",
"store",
":",
"store",
",",
"dr",
":",
"dr",
",",
"raft",
":",
"raft",
",",
"securityConfig",
":",
"securityConfig",
",",
"pg",
":",
"pg",
",",
"}",
"\n",
"}"
] |
// NewServer creates a Cluster API server.
|
[
"NewServer",
"creates",
"a",
"Cluster",
"API",
"server",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/server.go#L27-L35
|
train
|
docker/swarmkit
|
manager/manager.go
|
BindControl
|
func (m *Manager) BindControl(addr string) error {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.ControlAPI != "" {
return errors.New("manager already has a control API address")
}
// don't create a socket directory if we're on windows. we used named pipe
if runtime.GOOS != "windows" {
err := os.MkdirAll(filepath.Dir(addr), 0700)
if err != nil {
return errors.Wrap(err, "failed to create socket directory")
}
}
l, err := xnet.ListenLocal(addr)
// A unix socket may fail to bind if the file already
// exists. Try replacing the file.
if runtime.GOOS != "windows" {
unwrappedErr := err
if op, ok := unwrappedErr.(*net.OpError); ok {
unwrappedErr = op.Err
}
if sys, ok := unwrappedErr.(*os.SyscallError); ok {
unwrappedErr = sys.Err
}
if unwrappedErr == syscall.EADDRINUSE {
os.Remove(addr)
l, err = xnet.ListenLocal(addr)
}
}
if err != nil {
return errors.Wrap(err, "failed to listen on control API address")
}
m.config.ControlAPI = addr
m.controlListener <- l
return nil
}
|
go
|
func (m *Manager) BindControl(addr string) error {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.ControlAPI != "" {
return errors.New("manager already has a control API address")
}
// don't create a socket directory if we're on windows. we used named pipe
if runtime.GOOS != "windows" {
err := os.MkdirAll(filepath.Dir(addr), 0700)
if err != nil {
return errors.Wrap(err, "failed to create socket directory")
}
}
l, err := xnet.ListenLocal(addr)
// A unix socket may fail to bind if the file already
// exists. Try replacing the file.
if runtime.GOOS != "windows" {
unwrappedErr := err
if op, ok := unwrappedErr.(*net.OpError); ok {
unwrappedErr = op.Err
}
if sys, ok := unwrappedErr.(*os.SyscallError); ok {
unwrappedErr = sys.Err
}
if unwrappedErr == syscall.EADDRINUSE {
os.Remove(addr)
l, err = xnet.ListenLocal(addr)
}
}
if err != nil {
return errors.Wrap(err, "failed to listen on control API address")
}
m.config.ControlAPI = addr
m.controlListener <- l
return nil
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"BindControl",
"(",
"addr",
"string",
")",
"error",
"{",
"m",
".",
"addrMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"addrMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"config",
".",
"ControlAPI",
"!=",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// don't create a socket directory if we're on windows. we used named pipe",
"if",
"runtime",
".",
"GOOS",
"!=",
"\"",
"\"",
"{",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Dir",
"(",
"addr",
")",
",",
"0700",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"l",
",",
"err",
":=",
"xnet",
".",
"ListenLocal",
"(",
"addr",
")",
"\n\n",
"// A unix socket may fail to bind if the file already",
"// exists. Try replacing the file.",
"if",
"runtime",
".",
"GOOS",
"!=",
"\"",
"\"",
"{",
"unwrappedErr",
":=",
"err",
"\n",
"if",
"op",
",",
"ok",
":=",
"unwrappedErr",
".",
"(",
"*",
"net",
".",
"OpError",
")",
";",
"ok",
"{",
"unwrappedErr",
"=",
"op",
".",
"Err",
"\n",
"}",
"\n",
"if",
"sys",
",",
"ok",
":=",
"unwrappedErr",
".",
"(",
"*",
"os",
".",
"SyscallError",
")",
";",
"ok",
"{",
"unwrappedErr",
"=",
"sys",
".",
"Err",
"\n",
"}",
"\n",
"if",
"unwrappedErr",
"==",
"syscall",
".",
"EADDRINUSE",
"{",
"os",
".",
"Remove",
"(",
"addr",
")",
"\n",
"l",
",",
"err",
"=",
"xnet",
".",
"ListenLocal",
"(",
"addr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
".",
"config",
".",
"ControlAPI",
"=",
"addr",
"\n",
"m",
".",
"controlListener",
"<-",
"l",
"\n",
"return",
"nil",
"\n",
"}"
] |
// BindControl binds a local socket for the control API.
|
[
"BindControl",
"binds",
"a",
"local",
"socket",
"for",
"the",
"control",
"API",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L318-L358
|
train
|
docker/swarmkit
|
manager/manager.go
|
BindRemote
|
func (m *Manager) BindRemote(ctx context.Context, addrs RemoteAddrs) error {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.RemoteAPI != nil {
return errors.New("manager already has remote API address")
}
// If an AdvertiseAddr was specified, we use that as our
// externally-reachable address.
advertiseAddr := addrs.AdvertiseAddr
var advertiseAddrPort string
if advertiseAddr == "" {
// Otherwise, we know we are joining an existing swarm. Use a
// wildcard address to trigger remote autodetection of our
// address.
var err error
_, advertiseAddrPort, err = net.SplitHostPort(addrs.ListenAddr)
if err != nil {
return fmt.Errorf("missing or invalid listen address %s", addrs.ListenAddr)
}
// Even with an IPv6 listening address, it's okay to use
// 0.0.0.0 here. Any "unspecified" (wildcard) IP will
// be substituted with the actual source address.
advertiseAddr = net.JoinHostPort("0.0.0.0", advertiseAddrPort)
}
l, err := net.Listen("tcp", addrs.ListenAddr)
if err != nil {
return errors.Wrap(err, "failed to listen on remote API address")
}
if advertiseAddrPort == "0" {
advertiseAddr = l.Addr().String()
addrs.ListenAddr = advertiseAddr
}
m.config.RemoteAPI = &addrs
m.raftNode.SetAddr(ctx, advertiseAddr)
m.remoteListener <- l
return nil
}
|
go
|
func (m *Manager) BindRemote(ctx context.Context, addrs RemoteAddrs) error {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.RemoteAPI != nil {
return errors.New("manager already has remote API address")
}
// If an AdvertiseAddr was specified, we use that as our
// externally-reachable address.
advertiseAddr := addrs.AdvertiseAddr
var advertiseAddrPort string
if advertiseAddr == "" {
// Otherwise, we know we are joining an existing swarm. Use a
// wildcard address to trigger remote autodetection of our
// address.
var err error
_, advertiseAddrPort, err = net.SplitHostPort(addrs.ListenAddr)
if err != nil {
return fmt.Errorf("missing or invalid listen address %s", addrs.ListenAddr)
}
// Even with an IPv6 listening address, it's okay to use
// 0.0.0.0 here. Any "unspecified" (wildcard) IP will
// be substituted with the actual source address.
advertiseAddr = net.JoinHostPort("0.0.0.0", advertiseAddrPort)
}
l, err := net.Listen("tcp", addrs.ListenAddr)
if err != nil {
return errors.Wrap(err, "failed to listen on remote API address")
}
if advertiseAddrPort == "0" {
advertiseAddr = l.Addr().String()
addrs.ListenAddr = advertiseAddr
}
m.config.RemoteAPI = &addrs
m.raftNode.SetAddr(ctx, advertiseAddr)
m.remoteListener <- l
return nil
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"BindRemote",
"(",
"ctx",
"context",
".",
"Context",
",",
"addrs",
"RemoteAddrs",
")",
"error",
"{",
"m",
".",
"addrMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"addrMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"config",
".",
"RemoteAPI",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// If an AdvertiseAddr was specified, we use that as our",
"// externally-reachable address.",
"advertiseAddr",
":=",
"addrs",
".",
"AdvertiseAddr",
"\n\n",
"var",
"advertiseAddrPort",
"string",
"\n",
"if",
"advertiseAddr",
"==",
"\"",
"\"",
"{",
"// Otherwise, we know we are joining an existing swarm. Use a",
"// wildcard address to trigger remote autodetection of our",
"// address.",
"var",
"err",
"error",
"\n",
"_",
",",
"advertiseAddrPort",
",",
"err",
"=",
"net",
".",
"SplitHostPort",
"(",
"addrs",
".",
"ListenAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"addrs",
".",
"ListenAddr",
")",
"\n",
"}",
"\n\n",
"// Even with an IPv6 listening address, it's okay to use",
"// 0.0.0.0 here. Any \"unspecified\" (wildcard) IP will",
"// be substituted with the actual source address.",
"advertiseAddr",
"=",
"net",
".",
"JoinHostPort",
"(",
"\"",
"\"",
",",
"advertiseAddrPort",
")",
"\n",
"}",
"\n\n",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addrs",
".",
"ListenAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"advertiseAddrPort",
"==",
"\"",
"\"",
"{",
"advertiseAddr",
"=",
"l",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
"\n",
"addrs",
".",
"ListenAddr",
"=",
"advertiseAddr",
"\n",
"}",
"\n\n",
"m",
".",
"config",
".",
"RemoteAPI",
"=",
"&",
"addrs",
"\n\n",
"m",
".",
"raftNode",
".",
"SetAddr",
"(",
"ctx",
",",
"advertiseAddr",
")",
"\n",
"m",
".",
"remoteListener",
"<-",
"l",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// BindRemote binds a port for the remote API.
|
[
"BindRemote",
"binds",
"a",
"port",
"for",
"the",
"remote",
"API",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L361-L405
|
train
|
docker/swarmkit
|
manager/manager.go
|
Addr
|
func (m *Manager) Addr() string {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.RemoteAPI == nil {
return ""
}
return m.config.RemoteAPI.ListenAddr
}
|
go
|
func (m *Manager) Addr() string {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.RemoteAPI == nil {
return ""
}
return m.config.RemoteAPI.ListenAddr
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"Addr",
"(",
")",
"string",
"{",
"m",
".",
"addrMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"addrMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"config",
".",
"RemoteAPI",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"m",
".",
"config",
".",
"RemoteAPI",
".",
"ListenAddr",
"\n",
"}"
] |
// Addr returns tcp address on which remote api listens.
|
[
"Addr",
"returns",
"tcp",
"address",
"on",
"which",
"remote",
"api",
"listens",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L414-L422
|
train
|
docker/swarmkit
|
manager/manager.go
|
Stop
|
func (m *Manager) Stop(ctx context.Context, clearData bool) {
log.G(ctx).Info("Stopping manager")
// It's not safe to start shutting down while the manager is still
// starting up.
<-m.started
// the mutex stops us from trying to stop while we're already stopping, or
// from returning before we've finished stopping.
m.mu.Lock()
defer m.mu.Unlock()
if m.stopped {
return
}
m.stopped = true
srvDone, localSrvDone := make(chan struct{}), make(chan struct{})
go func() {
m.server.GracefulStop()
close(srvDone)
}()
go func() {
m.localserver.GracefulStop()
close(localSrvDone)
}()
m.raftNode.Cancel()
if m.collector != nil {
m.collector.Stop()
}
// The following components are gRPC services that are
// registered when creating the manager and will need
// to be re-registered if they are recreated.
// For simplicity, they are not nilled out.
m.dispatcher.Stop()
m.logbroker.Stop()
m.watchServer.Stop()
m.caserver.Stop()
if m.allocator != nil {
m.allocator.Stop()
}
if m.replicatedOrchestrator != nil {
m.replicatedOrchestrator.Stop()
}
if m.globalOrchestrator != nil {
m.globalOrchestrator.Stop()
}
if m.taskReaper != nil {
m.taskReaper.Stop()
}
if m.constraintEnforcer != nil {
m.constraintEnforcer.Stop()
}
if m.scheduler != nil {
m.scheduler.Stop()
}
if m.roleManager != nil {
m.roleManager.Stop()
}
if m.keyManager != nil {
m.keyManager.Stop()
}
if clearData {
m.raftNode.ClearData()
}
m.cancelFunc()
<-m.raftNode.Done()
timer := time.AfterFunc(stopTimeout, func() {
m.server.Stop()
m.localserver.Stop()
})
defer timer.Stop()
// TODO: we're not waiting on ctx because it very well could be passed from Run,
// which is already cancelled here. We need to refactor that.
select {
case <-srvDone:
<-localSrvDone
case <-localSrvDone:
<-srvDone
}
log.G(ctx).Info("Manager shut down")
// mutex is released and Run can return now
}
|
go
|
func (m *Manager) Stop(ctx context.Context, clearData bool) {
log.G(ctx).Info("Stopping manager")
// It's not safe to start shutting down while the manager is still
// starting up.
<-m.started
// the mutex stops us from trying to stop while we're already stopping, or
// from returning before we've finished stopping.
m.mu.Lock()
defer m.mu.Unlock()
if m.stopped {
return
}
m.stopped = true
srvDone, localSrvDone := make(chan struct{}), make(chan struct{})
go func() {
m.server.GracefulStop()
close(srvDone)
}()
go func() {
m.localserver.GracefulStop()
close(localSrvDone)
}()
m.raftNode.Cancel()
if m.collector != nil {
m.collector.Stop()
}
// The following components are gRPC services that are
// registered when creating the manager and will need
// to be re-registered if they are recreated.
// For simplicity, they are not nilled out.
m.dispatcher.Stop()
m.logbroker.Stop()
m.watchServer.Stop()
m.caserver.Stop()
if m.allocator != nil {
m.allocator.Stop()
}
if m.replicatedOrchestrator != nil {
m.replicatedOrchestrator.Stop()
}
if m.globalOrchestrator != nil {
m.globalOrchestrator.Stop()
}
if m.taskReaper != nil {
m.taskReaper.Stop()
}
if m.constraintEnforcer != nil {
m.constraintEnforcer.Stop()
}
if m.scheduler != nil {
m.scheduler.Stop()
}
if m.roleManager != nil {
m.roleManager.Stop()
}
if m.keyManager != nil {
m.keyManager.Stop()
}
if clearData {
m.raftNode.ClearData()
}
m.cancelFunc()
<-m.raftNode.Done()
timer := time.AfterFunc(stopTimeout, func() {
m.server.Stop()
m.localserver.Stop()
})
defer timer.Stop()
// TODO: we're not waiting on ctx because it very well could be passed from Run,
// which is already cancelled here. We need to refactor that.
select {
case <-srvDone:
<-localSrvDone
case <-localSrvDone:
<-srvDone
}
log.G(ctx).Info("Manager shut down")
// mutex is released and Run can return now
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"Stop",
"(",
"ctx",
"context",
".",
"Context",
",",
"clearData",
"bool",
")",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"// It's not safe to start shutting down while the manager is still",
"// starting up.",
"<-",
"m",
".",
"started",
"\n\n",
"// the mutex stops us from trying to stop while we're already stopping, or",
"// from returning before we've finished stopping.",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"m",
".",
"stopped",
"{",
"return",
"\n",
"}",
"\n",
"m",
".",
"stopped",
"=",
"true",
"\n\n",
"srvDone",
",",
"localSrvDone",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"m",
".",
"server",
".",
"GracefulStop",
"(",
")",
"\n",
"close",
"(",
"srvDone",
")",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"m",
".",
"localserver",
".",
"GracefulStop",
"(",
")",
"\n",
"close",
"(",
"localSrvDone",
")",
"\n",
"}",
"(",
")",
"\n\n",
"m",
".",
"raftNode",
".",
"Cancel",
"(",
")",
"\n\n",
"if",
"m",
".",
"collector",
"!=",
"nil",
"{",
"m",
".",
"collector",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n\n",
"// The following components are gRPC services that are",
"// registered when creating the manager and will need",
"// to be re-registered if they are recreated.",
"// For simplicity, they are not nilled out.",
"m",
".",
"dispatcher",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"logbroker",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"watchServer",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"caserver",
".",
"Stop",
"(",
")",
"\n\n",
"if",
"m",
".",
"allocator",
"!=",
"nil",
"{",
"m",
".",
"allocator",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"replicatedOrchestrator",
"!=",
"nil",
"{",
"m",
".",
"replicatedOrchestrator",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"globalOrchestrator",
"!=",
"nil",
"{",
"m",
".",
"globalOrchestrator",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"taskReaper",
"!=",
"nil",
"{",
"m",
".",
"taskReaper",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"constraintEnforcer",
"!=",
"nil",
"{",
"m",
".",
"constraintEnforcer",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"scheduler",
"!=",
"nil",
"{",
"m",
".",
"scheduler",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"roleManager",
"!=",
"nil",
"{",
"m",
".",
"roleManager",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"keyManager",
"!=",
"nil",
"{",
"m",
".",
"keyManager",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"clearData",
"{",
"m",
".",
"raftNode",
".",
"ClearData",
"(",
")",
"\n",
"}",
"\n",
"m",
".",
"cancelFunc",
"(",
")",
"\n",
"<-",
"m",
".",
"raftNode",
".",
"Done",
"(",
")",
"\n\n",
"timer",
":=",
"time",
".",
"AfterFunc",
"(",
"stopTimeout",
",",
"func",
"(",
")",
"{",
"m",
".",
"server",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"localserver",
".",
"Stop",
"(",
")",
"\n",
"}",
")",
"\n",
"defer",
"timer",
".",
"Stop",
"(",
")",
"\n",
"// TODO: we're not waiting on ctx because it very well could be passed from Run,",
"// which is already cancelled here. We need to refactor that.",
"select",
"{",
"case",
"<-",
"srvDone",
":",
"<-",
"localSrvDone",
"\n",
"case",
"<-",
"localSrvDone",
":",
"<-",
"srvDone",
"\n",
"}",
"\n\n",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"// mutex is released and Run can return now",
"}"
] |
// Stop stops the manager. It immediately closes all open connections and
// active RPCs as well as stopping the manager's subsystems. If clearData is
// set, the raft logs, snapshots, and keys will be erased.
|
[
"Stop",
"stops",
"the",
"manager",
".",
"It",
"immediately",
"closes",
"all",
"open",
"connections",
"and",
"active",
"RPCs",
"as",
"well",
"as",
"stopping",
"the",
"manager",
"s",
"subsystems",
".",
"If",
"clearData",
"is",
"set",
"the",
"raft",
"logs",
"snapshots",
"and",
"keys",
"will",
"be",
"erased",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L634-L721
|
train
|
docker/swarmkit
|
manager/manager.go
|
handleLeadershipEvents
|
func (m *Manager) handleLeadershipEvents(ctx context.Context, leadershipCh chan events.Event) {
// get the current leader and save it for logging leadership changes in
// this loop
oldLeader := m.getLeaderNodeID()
for {
select {
case leadershipEvent := <-leadershipCh:
m.mu.Lock()
if m.stopped {
m.mu.Unlock()
return
}
newState := leadershipEvent.(raft.LeadershipState)
if newState == raft.IsLeader {
m.becomeLeader(ctx)
leaderMetric.Set(1)
} else if newState == raft.IsFollower {
m.becomeFollower()
leaderMetric.Set(0)
}
m.mu.Unlock()
newLeader := m.getLeaderNodeID()
// maybe we should use logrus fields for old and new leader, so
// that users are better able to ingest leadership changes into log
// aggregators?
log.G(ctx).Infof("leadership changed from %v to %v", oldLeader, newLeader)
case <-ctx.Done():
return
}
}
}
|
go
|
func (m *Manager) handleLeadershipEvents(ctx context.Context, leadershipCh chan events.Event) {
// get the current leader and save it for logging leadership changes in
// this loop
oldLeader := m.getLeaderNodeID()
for {
select {
case leadershipEvent := <-leadershipCh:
m.mu.Lock()
if m.stopped {
m.mu.Unlock()
return
}
newState := leadershipEvent.(raft.LeadershipState)
if newState == raft.IsLeader {
m.becomeLeader(ctx)
leaderMetric.Set(1)
} else if newState == raft.IsFollower {
m.becomeFollower()
leaderMetric.Set(0)
}
m.mu.Unlock()
newLeader := m.getLeaderNodeID()
// maybe we should use logrus fields for old and new leader, so
// that users are better able to ingest leadership changes into log
// aggregators?
log.G(ctx).Infof("leadership changed from %v to %v", oldLeader, newLeader)
case <-ctx.Done():
return
}
}
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"handleLeadershipEvents",
"(",
"ctx",
"context",
".",
"Context",
",",
"leadershipCh",
"chan",
"events",
".",
"Event",
")",
"{",
"// get the current leader and save it for logging leadership changes in",
"// this loop",
"oldLeader",
":=",
"m",
".",
"getLeaderNodeID",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"leadershipEvent",
":=",
"<-",
"leadershipCh",
":",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"m",
".",
"stopped",
"{",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"newState",
":=",
"leadershipEvent",
".",
"(",
"raft",
".",
"LeadershipState",
")",
"\n\n",
"if",
"newState",
"==",
"raft",
".",
"IsLeader",
"{",
"m",
".",
"becomeLeader",
"(",
"ctx",
")",
"\n",
"leaderMetric",
".",
"Set",
"(",
"1",
")",
"\n",
"}",
"else",
"if",
"newState",
"==",
"raft",
".",
"IsFollower",
"{",
"m",
".",
"becomeFollower",
"(",
")",
"\n",
"leaderMetric",
".",
"Set",
"(",
"0",
")",
"\n",
"}",
"\n",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"newLeader",
":=",
"m",
".",
"getLeaderNodeID",
"(",
")",
"\n",
"// maybe we should use logrus fields for old and new leader, so",
"// that users are better able to ingest leadership changes into log",
"// aggregators?",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"oldLeader",
",",
"newLeader",
")",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// handleLeadershipEvents handles the is leader event or is follower event.
|
[
"handleLeadershipEvents",
"handles",
"the",
"is",
"leader",
"event",
"or",
"is",
"follower",
"event",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L846-L878
|
train
|
docker/swarmkit
|
manager/manager.go
|
serveListener
|
func (m *Manager) serveListener(ctx context.Context, lCh <-chan net.Listener) {
var l net.Listener
select {
case l = <-lCh:
case <-ctx.Done():
return
}
ctx = log.WithLogger(ctx, log.G(ctx).WithFields(
logrus.Fields{
"proto": l.Addr().Network(),
"addr": l.Addr().String(),
}))
if _, ok := l.(*net.TCPListener); !ok {
log.G(ctx).Info("Listening for local connections")
// we need to disallow double closes because UnixListener.Close
// can delete unix-socket file of newer listener. grpc calls
// Close twice indeed: in Serve and in Stop.
m.errServe <- m.localserver.Serve(&closeOnceListener{Listener: l})
} else {
log.G(ctx).Info("Listening for connections")
m.errServe <- m.server.Serve(l)
}
}
|
go
|
func (m *Manager) serveListener(ctx context.Context, lCh <-chan net.Listener) {
var l net.Listener
select {
case l = <-lCh:
case <-ctx.Done():
return
}
ctx = log.WithLogger(ctx, log.G(ctx).WithFields(
logrus.Fields{
"proto": l.Addr().Network(),
"addr": l.Addr().String(),
}))
if _, ok := l.(*net.TCPListener); !ok {
log.G(ctx).Info("Listening for local connections")
// we need to disallow double closes because UnixListener.Close
// can delete unix-socket file of newer listener. grpc calls
// Close twice indeed: in Serve and in Stop.
m.errServe <- m.localserver.Serve(&closeOnceListener{Listener: l})
} else {
log.G(ctx).Info("Listening for connections")
m.errServe <- m.server.Serve(l)
}
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"serveListener",
"(",
"ctx",
"context",
".",
"Context",
",",
"lCh",
"<-",
"chan",
"net",
".",
"Listener",
")",
"{",
"var",
"l",
"net",
".",
"Listener",
"\n",
"select",
"{",
"case",
"l",
"=",
"<-",
"lCh",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"ctx",
"=",
"log",
".",
"WithLogger",
"(",
"ctx",
",",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"l",
".",
"Addr",
"(",
")",
".",
"Network",
"(",
")",
",",
"\"",
"\"",
":",
"l",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
",",
"}",
")",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"l",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
";",
"!",
"ok",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"// we need to disallow double closes because UnixListener.Close",
"// can delete unix-socket file of newer listener. grpc calls",
"// Close twice indeed: in Serve and in Stop.",
"m",
".",
"errServe",
"<-",
"m",
".",
"localserver",
".",
"Serve",
"(",
"&",
"closeOnceListener",
"{",
"Listener",
":",
"l",
"}",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"errServe",
"<-",
"m",
".",
"server",
".",
"Serve",
"(",
"l",
")",
"\n",
"}",
"\n",
"}"
] |
// serveListener serves a listener for local and non local connections.
|
[
"serveListener",
"serves",
"a",
"listener",
"for",
"local",
"and",
"non",
"local",
"connections",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L881-L903
|
train
|
docker/swarmkit
|
manager/manager.go
|
becomeFollower
|
func (m *Manager) becomeFollower() {
// The following components are gRPC services that are
// registered when creating the manager and will need
// to be re-registered if they are recreated.
// For simplicity, they are not nilled out.
m.dispatcher.Stop()
m.logbroker.Stop()
m.caserver.Stop()
if m.allocator != nil {
m.allocator.Stop()
m.allocator = nil
}
m.constraintEnforcer.Stop()
m.constraintEnforcer = nil
m.replicatedOrchestrator.Stop()
m.replicatedOrchestrator = nil
m.globalOrchestrator.Stop()
m.globalOrchestrator = nil
m.taskReaper.Stop()
m.taskReaper = nil
m.scheduler.Stop()
m.scheduler = nil
m.roleManager.Stop()
m.roleManager = nil
if m.keyManager != nil {
m.keyManager.Stop()
m.keyManager = nil
}
}
|
go
|
func (m *Manager) becomeFollower() {
// The following components are gRPC services that are
// registered when creating the manager and will need
// to be re-registered if they are recreated.
// For simplicity, they are not nilled out.
m.dispatcher.Stop()
m.logbroker.Stop()
m.caserver.Stop()
if m.allocator != nil {
m.allocator.Stop()
m.allocator = nil
}
m.constraintEnforcer.Stop()
m.constraintEnforcer = nil
m.replicatedOrchestrator.Stop()
m.replicatedOrchestrator = nil
m.globalOrchestrator.Stop()
m.globalOrchestrator = nil
m.taskReaper.Stop()
m.taskReaper = nil
m.scheduler.Stop()
m.scheduler = nil
m.roleManager.Stop()
m.roleManager = nil
if m.keyManager != nil {
m.keyManager.Stop()
m.keyManager = nil
}
}
|
[
"func",
"(",
"m",
"*",
"Manager",
")",
"becomeFollower",
"(",
")",
"{",
"// The following components are gRPC services that are",
"// registered when creating the manager and will need",
"// to be re-registered if they are recreated.",
"// For simplicity, they are not nilled out.",
"m",
".",
"dispatcher",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"logbroker",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"caserver",
".",
"Stop",
"(",
")",
"\n\n",
"if",
"m",
".",
"allocator",
"!=",
"nil",
"{",
"m",
".",
"allocator",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"allocator",
"=",
"nil",
"\n",
"}",
"\n\n",
"m",
".",
"constraintEnforcer",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"constraintEnforcer",
"=",
"nil",
"\n\n",
"m",
".",
"replicatedOrchestrator",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"replicatedOrchestrator",
"=",
"nil",
"\n\n",
"m",
".",
"globalOrchestrator",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"globalOrchestrator",
"=",
"nil",
"\n\n",
"m",
".",
"taskReaper",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"taskReaper",
"=",
"nil",
"\n\n",
"m",
".",
"scheduler",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"scheduler",
"=",
"nil",
"\n\n",
"m",
".",
"roleManager",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"roleManager",
"=",
"nil",
"\n\n",
"if",
"m",
".",
"keyManager",
"!=",
"nil",
"{",
"m",
".",
"keyManager",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"keyManager",
"=",
"nil",
"\n",
"}",
"\n",
"}"
] |
// becomeFollower shuts down the subsystems that are only run by the leader.
|
[
"becomeFollower",
"shuts",
"down",
"the",
"subsystems",
"that",
"are",
"only",
"run",
"by",
"the",
"leader",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L1103-L1139
|
train
|
docker/swarmkit
|
manager/manager.go
|
defaultClusterObject
|
func defaultClusterObject(
clusterID string,
initialCAConfig api.CAConfig,
raftCfg api.RaftConfig,
encryptionConfig api.EncryptionConfig,
initialUnlockKeys []*api.EncryptionKey,
rootCA *ca.RootCA,
fips bool,
defaultAddressPool []string,
subnetSize uint32,
vxlanUDPPort uint32) *api.Cluster {
var caKey []byte
if rcaSigner, err := rootCA.Signer(); err == nil {
caKey = rcaSigner.Key
}
return &api.Cluster{
ID: clusterID,
Spec: api.ClusterSpec{
Annotations: api.Annotations{
Name: store.DefaultClusterName,
},
Orchestration: api.OrchestrationConfig{
TaskHistoryRetentionLimit: defaultTaskHistoryRetentionLimit,
},
Dispatcher: api.DispatcherConfig{
HeartbeatPeriod: gogotypes.DurationProto(dispatcher.DefaultHeartBeatPeriod),
},
Raft: raftCfg,
CAConfig: initialCAConfig,
EncryptionConfig: encryptionConfig,
},
RootCA: api.RootCA{
CAKey: caKey,
CACert: rootCA.Certs,
CACertHash: rootCA.Digest.String(),
JoinTokens: api.JoinTokens{
Worker: ca.GenerateJoinToken(rootCA, fips),
Manager: ca.GenerateJoinToken(rootCA, fips),
},
},
UnlockKeys: initialUnlockKeys,
FIPS: fips,
DefaultAddressPool: defaultAddressPool,
SubnetSize: subnetSize,
VXLANUDPPort: vxlanUDPPort,
}
}
|
go
|
func defaultClusterObject(
clusterID string,
initialCAConfig api.CAConfig,
raftCfg api.RaftConfig,
encryptionConfig api.EncryptionConfig,
initialUnlockKeys []*api.EncryptionKey,
rootCA *ca.RootCA,
fips bool,
defaultAddressPool []string,
subnetSize uint32,
vxlanUDPPort uint32) *api.Cluster {
var caKey []byte
if rcaSigner, err := rootCA.Signer(); err == nil {
caKey = rcaSigner.Key
}
return &api.Cluster{
ID: clusterID,
Spec: api.ClusterSpec{
Annotations: api.Annotations{
Name: store.DefaultClusterName,
},
Orchestration: api.OrchestrationConfig{
TaskHistoryRetentionLimit: defaultTaskHistoryRetentionLimit,
},
Dispatcher: api.DispatcherConfig{
HeartbeatPeriod: gogotypes.DurationProto(dispatcher.DefaultHeartBeatPeriod),
},
Raft: raftCfg,
CAConfig: initialCAConfig,
EncryptionConfig: encryptionConfig,
},
RootCA: api.RootCA{
CAKey: caKey,
CACert: rootCA.Certs,
CACertHash: rootCA.Digest.String(),
JoinTokens: api.JoinTokens{
Worker: ca.GenerateJoinToken(rootCA, fips),
Manager: ca.GenerateJoinToken(rootCA, fips),
},
},
UnlockKeys: initialUnlockKeys,
FIPS: fips,
DefaultAddressPool: defaultAddressPool,
SubnetSize: subnetSize,
VXLANUDPPort: vxlanUDPPort,
}
}
|
[
"func",
"defaultClusterObject",
"(",
"clusterID",
"string",
",",
"initialCAConfig",
"api",
".",
"CAConfig",
",",
"raftCfg",
"api",
".",
"RaftConfig",
",",
"encryptionConfig",
"api",
".",
"EncryptionConfig",
",",
"initialUnlockKeys",
"[",
"]",
"*",
"api",
".",
"EncryptionKey",
",",
"rootCA",
"*",
"ca",
".",
"RootCA",
",",
"fips",
"bool",
",",
"defaultAddressPool",
"[",
"]",
"string",
",",
"subnetSize",
"uint32",
",",
"vxlanUDPPort",
"uint32",
")",
"*",
"api",
".",
"Cluster",
"{",
"var",
"caKey",
"[",
"]",
"byte",
"\n",
"if",
"rcaSigner",
",",
"err",
":=",
"rootCA",
".",
"Signer",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"caKey",
"=",
"rcaSigner",
".",
"Key",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"Cluster",
"{",
"ID",
":",
"clusterID",
",",
"Spec",
":",
"api",
".",
"ClusterSpec",
"{",
"Annotations",
":",
"api",
".",
"Annotations",
"{",
"Name",
":",
"store",
".",
"DefaultClusterName",
",",
"}",
",",
"Orchestration",
":",
"api",
".",
"OrchestrationConfig",
"{",
"TaskHistoryRetentionLimit",
":",
"defaultTaskHistoryRetentionLimit",
",",
"}",
",",
"Dispatcher",
":",
"api",
".",
"DispatcherConfig",
"{",
"HeartbeatPeriod",
":",
"gogotypes",
".",
"DurationProto",
"(",
"dispatcher",
".",
"DefaultHeartBeatPeriod",
")",
",",
"}",
",",
"Raft",
":",
"raftCfg",
",",
"CAConfig",
":",
"initialCAConfig",
",",
"EncryptionConfig",
":",
"encryptionConfig",
",",
"}",
",",
"RootCA",
":",
"api",
".",
"RootCA",
"{",
"CAKey",
":",
"caKey",
",",
"CACert",
":",
"rootCA",
".",
"Certs",
",",
"CACertHash",
":",
"rootCA",
".",
"Digest",
".",
"String",
"(",
")",
",",
"JoinTokens",
":",
"api",
".",
"JoinTokens",
"{",
"Worker",
":",
"ca",
".",
"GenerateJoinToken",
"(",
"rootCA",
",",
"fips",
")",
",",
"Manager",
":",
"ca",
".",
"GenerateJoinToken",
"(",
"rootCA",
",",
"fips",
")",
",",
"}",
",",
"}",
",",
"UnlockKeys",
":",
"initialUnlockKeys",
",",
"FIPS",
":",
"fips",
",",
"DefaultAddressPool",
":",
"defaultAddressPool",
",",
"SubnetSize",
":",
"subnetSize",
",",
"VXLANUDPPort",
":",
"vxlanUDPPort",
",",
"}",
"\n",
"}"
] |
// defaultClusterObject creates a default cluster.
|
[
"defaultClusterObject",
"creates",
"a",
"default",
"cluster",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L1142-L1189
|
train
|
docker/swarmkit
|
manager/manager.go
|
managerNode
|
func managerNode(nodeID string, availability api.NodeSpec_Availability, vxlanPort uint32) *api.Node {
return &api.Node{
ID: nodeID,
Certificate: api.Certificate{
CN: nodeID,
Role: api.NodeRoleManager,
Status: api.IssuanceStatus{
State: api.IssuanceStateIssued,
},
},
Spec: api.NodeSpec{
DesiredRole: api.NodeRoleManager,
Membership: api.NodeMembershipAccepted,
Availability: availability,
},
VXLANUDPPort: vxlanPort,
}
}
|
go
|
func managerNode(nodeID string, availability api.NodeSpec_Availability, vxlanPort uint32) *api.Node {
return &api.Node{
ID: nodeID,
Certificate: api.Certificate{
CN: nodeID,
Role: api.NodeRoleManager,
Status: api.IssuanceStatus{
State: api.IssuanceStateIssued,
},
},
Spec: api.NodeSpec{
DesiredRole: api.NodeRoleManager,
Membership: api.NodeMembershipAccepted,
Availability: availability,
},
VXLANUDPPort: vxlanPort,
}
}
|
[
"func",
"managerNode",
"(",
"nodeID",
"string",
",",
"availability",
"api",
".",
"NodeSpec_Availability",
",",
"vxlanPort",
"uint32",
")",
"*",
"api",
".",
"Node",
"{",
"return",
"&",
"api",
".",
"Node",
"{",
"ID",
":",
"nodeID",
",",
"Certificate",
":",
"api",
".",
"Certificate",
"{",
"CN",
":",
"nodeID",
",",
"Role",
":",
"api",
".",
"NodeRoleManager",
",",
"Status",
":",
"api",
".",
"IssuanceStatus",
"{",
"State",
":",
"api",
".",
"IssuanceStateIssued",
",",
"}",
",",
"}",
",",
"Spec",
":",
"api",
".",
"NodeSpec",
"{",
"DesiredRole",
":",
"api",
".",
"NodeRoleManager",
",",
"Membership",
":",
"api",
".",
"NodeMembershipAccepted",
",",
"Availability",
":",
"availability",
",",
"}",
",",
"VXLANUDPPort",
":",
"vxlanPort",
",",
"}",
"\n",
"}"
] |
// managerNode creates a new node with NodeRoleManager role.
|
[
"managerNode",
"creates",
"a",
"new",
"node",
"with",
"NodeRoleManager",
"role",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L1192-L1209
|
train
|
docker/swarmkit
|
manager/manager.go
|
newIngressNetwork
|
func newIngressNetwork() *api.Network {
return &api.Network{
ID: identity.NewID(),
Spec: api.NetworkSpec{
Ingress: true,
Annotations: api.Annotations{
Name: "ingress",
},
DriverConfig: &api.Driver{},
IPAM: &api.IPAMOptions{
Driver: &api.Driver{},
Configs: []*api.IPAMConfig{
{
Subnet: "10.255.0.0/16",
},
},
},
},
}
}
|
go
|
func newIngressNetwork() *api.Network {
return &api.Network{
ID: identity.NewID(),
Spec: api.NetworkSpec{
Ingress: true,
Annotations: api.Annotations{
Name: "ingress",
},
DriverConfig: &api.Driver{},
IPAM: &api.IPAMOptions{
Driver: &api.Driver{},
Configs: []*api.IPAMConfig{
{
Subnet: "10.255.0.0/16",
},
},
},
},
}
}
|
[
"func",
"newIngressNetwork",
"(",
")",
"*",
"api",
".",
"Network",
"{",
"return",
"&",
"api",
".",
"Network",
"{",
"ID",
":",
"identity",
".",
"NewID",
"(",
")",
",",
"Spec",
":",
"api",
".",
"NetworkSpec",
"{",
"Ingress",
":",
"true",
",",
"Annotations",
":",
"api",
".",
"Annotations",
"{",
"Name",
":",
"\"",
"\"",
",",
"}",
",",
"DriverConfig",
":",
"&",
"api",
".",
"Driver",
"{",
"}",
",",
"IPAM",
":",
"&",
"api",
".",
"IPAMOptions",
"{",
"Driver",
":",
"&",
"api",
".",
"Driver",
"{",
"}",
",",
"Configs",
":",
"[",
"]",
"*",
"api",
".",
"IPAMConfig",
"{",
"{",
"Subnet",
":",
"\"",
"\"",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] |
// newIngressNetwork returns the network object for the default ingress
// network, the network which provides the routing mesh. Caller will save to
// store this object once, at fresh cluster creation. It is expected to
// call this function inside a store update transaction.
|
[
"newIngressNetwork",
"returns",
"the",
"network",
"object",
"for",
"the",
"default",
"ingress",
"network",
"the",
"network",
"which",
"provides",
"the",
"routing",
"mesh",
".",
"Caller",
"will",
"save",
"to",
"store",
"this",
"object",
"once",
"at",
"fresh",
"cluster",
"creation",
".",
"It",
"is",
"expected",
"to",
"call",
"this",
"function",
"inside",
"a",
"store",
"update",
"transaction",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L1215-L1234
|
train
|
docker/swarmkit
|
manager/manager.go
|
newPredefinedNetwork
|
func newPredefinedNetwork(name, driver string) *api.Network {
return &api.Network{
ID: identity.NewID(),
Spec: api.NetworkSpec{
Annotations: api.Annotations{
Name: name,
Labels: map[string]string{
networkallocator.PredefinedLabel: "true",
},
},
DriverConfig: &api.Driver{Name: driver},
},
}
}
|
go
|
func newPredefinedNetwork(name, driver string) *api.Network {
return &api.Network{
ID: identity.NewID(),
Spec: api.NetworkSpec{
Annotations: api.Annotations{
Name: name,
Labels: map[string]string{
networkallocator.PredefinedLabel: "true",
},
},
DriverConfig: &api.Driver{Name: driver},
},
}
}
|
[
"func",
"newPredefinedNetwork",
"(",
"name",
",",
"driver",
"string",
")",
"*",
"api",
".",
"Network",
"{",
"return",
"&",
"api",
".",
"Network",
"{",
"ID",
":",
"identity",
".",
"NewID",
"(",
")",
",",
"Spec",
":",
"api",
".",
"NetworkSpec",
"{",
"Annotations",
":",
"api",
".",
"Annotations",
"{",
"Name",
":",
"name",
",",
"Labels",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"networkallocator",
".",
"PredefinedLabel",
":",
"\"",
"\"",
",",
"}",
",",
"}",
",",
"DriverConfig",
":",
"&",
"api",
".",
"Driver",
"{",
"Name",
":",
"driver",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] |
// Creates a network object representing one of the predefined networks
// known to be statically created on the cluster nodes. These objects
// are populated in the store at cluster creation solely in order to
// support running services on the nodes' predefined networks.
// External clients can filter these predefined networks by looking
// at the predefined label.
|
[
"Creates",
"a",
"network",
"object",
"representing",
"one",
"of",
"the",
"predefined",
"networks",
"known",
"to",
"be",
"statically",
"created",
"on",
"the",
"cluster",
"nodes",
".",
"These",
"objects",
"are",
"populated",
"in",
"the",
"store",
"at",
"cluster",
"creation",
"solely",
"in",
"order",
"to",
"support",
"running",
"services",
"on",
"the",
"nodes",
"predefined",
"networks",
".",
"External",
"clients",
"can",
"filter",
"these",
"predefined",
"networks",
"by",
"looking",
"at",
"the",
"predefined",
"label",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/manager.go#L1242-L1255
|
train
|
docker/swarmkit
|
manager/controlapi/config.go
|
GetConfig
|
func (s *Server) GetConfig(ctx context.Context, request *api.GetConfigRequest) (*api.GetConfigResponse, error) {
if request.ConfigID == "" {
return nil, status.Errorf(codes.InvalidArgument, "config ID must be provided")
}
var config *api.Config
s.store.View(func(tx store.ReadTx) {
config = store.GetConfig(tx, request.ConfigID)
})
if config == nil {
return nil, status.Errorf(codes.NotFound, "config %s not found", request.ConfigID)
}
return &api.GetConfigResponse{Config: config}, nil
}
|
go
|
func (s *Server) GetConfig(ctx context.Context, request *api.GetConfigRequest) (*api.GetConfigResponse, error) {
if request.ConfigID == "" {
return nil, status.Errorf(codes.InvalidArgument, "config ID must be provided")
}
var config *api.Config
s.store.View(func(tx store.ReadTx) {
config = store.GetConfig(tx, request.ConfigID)
})
if config == nil {
return nil, status.Errorf(codes.NotFound, "config %s not found", request.ConfigID)
}
return &api.GetConfigResponse{Config: config}, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"GetConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"GetConfigRequest",
")",
"(",
"*",
"api",
".",
"GetConfigResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"ConfigID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"config",
"*",
"api",
".",
"Config",
"\n",
"s",
".",
"store",
".",
"View",
"(",
"func",
"(",
"tx",
"store",
".",
"ReadTx",
")",
"{",
"config",
"=",
"store",
".",
"GetConfig",
"(",
"tx",
",",
"request",
".",
"ConfigID",
")",
"\n",
"}",
")",
"\n\n",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"ConfigID",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"GetConfigResponse",
"{",
"Config",
":",
"config",
"}",
",",
"nil",
"\n",
"}"
] |
// GetConfig returns a `GetConfigResponse` with a `Config` with the same
// id as `GetConfigRequest.ConfigID`
// - Returns `NotFound` if the Config with the given id is not found.
// - Returns `InvalidArgument` if the `GetConfigRequest.ConfigID` is empty.
// - Returns an error if getting fails.
|
[
"GetConfig",
"returns",
"a",
"GetConfigResponse",
"with",
"a",
"Config",
"with",
"the",
"same",
"id",
"as",
"GetConfigRequest",
".",
"ConfigID",
"-",
"Returns",
"NotFound",
"if",
"the",
"Config",
"with",
"the",
"given",
"id",
"is",
"not",
"found",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"GetConfigRequest",
".",
"ConfigID",
"is",
"empty",
".",
"-",
"Returns",
"an",
"error",
"if",
"getting",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/config.go#L33-L48
|
train
|
docker/swarmkit
|
manager/controlapi/config.go
|
UpdateConfig
|
func (s *Server) UpdateConfig(ctx context.Context, request *api.UpdateConfigRequest) (*api.UpdateConfigResponse, error) {
if request.ConfigID == "" || request.ConfigVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var config *api.Config
err := s.store.Update(func(tx store.Tx) error {
config = store.GetConfig(tx, request.ConfigID)
if config == nil {
return status.Errorf(codes.NotFound, "config %s not found", request.ConfigID)
}
// Check if the Name is different than the current name, or the config is non-nil and different
// than the current config
if config.Spec.Annotations.Name != request.Spec.Annotations.Name ||
(request.Spec.Data != nil && !bytes.Equal(request.Spec.Data, config.Spec.Data)) {
return status.Errorf(codes.InvalidArgument, "only updates to Labels are allowed")
}
// We only allow updating Labels
config.Meta.Version = *request.ConfigVersion
config.Spec.Annotations.Labels = request.Spec.Annotations.Labels
return store.UpdateConfig(tx, config)
})
if err != nil {
return nil, err
}
log.G(ctx).WithFields(logrus.Fields{
"config.ID": request.ConfigID,
"config.Name": request.Spec.Annotations.Name,
"method": "UpdateConfig",
}).Debugf("config updated")
return &api.UpdateConfigResponse{
Config: config,
}, nil
}
|
go
|
func (s *Server) UpdateConfig(ctx context.Context, request *api.UpdateConfigRequest) (*api.UpdateConfigResponse, error) {
if request.ConfigID == "" || request.ConfigVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var config *api.Config
err := s.store.Update(func(tx store.Tx) error {
config = store.GetConfig(tx, request.ConfigID)
if config == nil {
return status.Errorf(codes.NotFound, "config %s not found", request.ConfigID)
}
// Check if the Name is different than the current name, or the config is non-nil and different
// than the current config
if config.Spec.Annotations.Name != request.Spec.Annotations.Name ||
(request.Spec.Data != nil && !bytes.Equal(request.Spec.Data, config.Spec.Data)) {
return status.Errorf(codes.InvalidArgument, "only updates to Labels are allowed")
}
// We only allow updating Labels
config.Meta.Version = *request.ConfigVersion
config.Spec.Annotations.Labels = request.Spec.Annotations.Labels
return store.UpdateConfig(tx, config)
})
if err != nil {
return nil, err
}
log.G(ctx).WithFields(logrus.Fields{
"config.ID": request.ConfigID,
"config.Name": request.Spec.Annotations.Name,
"method": "UpdateConfig",
}).Debugf("config updated")
return &api.UpdateConfigResponse{
Config: config,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"UpdateConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"UpdateConfigRequest",
")",
"(",
"*",
"api",
".",
"UpdateConfigResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"ConfigID",
"==",
"\"",
"\"",
"||",
"request",
".",
"ConfigVersion",
"==",
"nil",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"errInvalidArgument",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"var",
"config",
"*",
"api",
".",
"Config",
"\n",
"err",
":=",
"s",
".",
"store",
".",
"Update",
"(",
"func",
"(",
"tx",
"store",
".",
"Tx",
")",
"error",
"{",
"config",
"=",
"store",
".",
"GetConfig",
"(",
"tx",
",",
"request",
".",
"ConfigID",
")",
"\n",
"if",
"config",
"==",
"nil",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"ConfigID",
")",
"\n",
"}",
"\n\n",
"// Check if the Name is different than the current name, or the config is non-nil and different",
"// than the current config",
"if",
"config",
".",
"Spec",
".",
"Annotations",
".",
"Name",
"!=",
"request",
".",
"Spec",
".",
"Annotations",
".",
"Name",
"||",
"(",
"request",
".",
"Spec",
".",
"Data",
"!=",
"nil",
"&&",
"!",
"bytes",
".",
"Equal",
"(",
"request",
".",
"Spec",
".",
"Data",
",",
"config",
".",
"Spec",
".",
"Data",
")",
")",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// We only allow updating Labels",
"config",
".",
"Meta",
".",
"Version",
"=",
"*",
"request",
".",
"ConfigVersion",
"\n",
"config",
".",
"Spec",
".",
"Annotations",
".",
"Labels",
"=",
"request",
".",
"Spec",
".",
"Annotations",
".",
"Labels",
"\n\n",
"return",
"store",
".",
"UpdateConfig",
"(",
"tx",
",",
"config",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"request",
".",
"ConfigID",
",",
"\"",
"\"",
":",
"request",
".",
"Spec",
".",
"Annotations",
".",
"Name",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
")",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"&",
"api",
".",
"UpdateConfigResponse",
"{",
"Config",
":",
"config",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// UpdateConfig updates a Config referenced by ConfigID with the given ConfigSpec.
// - Returns `NotFound` if the Config is not found.
// - Returns `InvalidArgument` if the ConfigSpec is malformed or anything other than Labels is changed
// - Returns an error if the update fails.
|
[
"UpdateConfig",
"updates",
"a",
"Config",
"referenced",
"by",
"ConfigID",
"with",
"the",
"given",
"ConfigSpec",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"Config",
"is",
"not",
"found",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"ConfigSpec",
"is",
"malformed",
"or",
"anything",
"other",
"than",
"Labels",
"is",
"changed",
"-",
"Returns",
"an",
"error",
"if",
"the",
"update",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/config.go#L54-L92
|
train
|
docker/swarmkit
|
manager/controlapi/config.go
|
ListConfigs
|
func (s *Server) ListConfigs(ctx context.Context, request *api.ListConfigsRequest) (*api.ListConfigsResponse, error) {
var (
configs []*api.Config
respConfigs []*api.Config
err error
byFilters []store.By
by store.By
labels map[string]string
)
// return all configs that match either any of the names or any of the name prefixes (why would you give both?)
if request.Filters != nil {
for _, name := range request.Filters.Names {
byFilters = append(byFilters, store.ByName(name))
}
for _, prefix := range request.Filters.NamePrefixes {
byFilters = append(byFilters, store.ByNamePrefix(prefix))
}
for _, prefix := range request.Filters.IDPrefixes {
byFilters = append(byFilters, store.ByIDPrefix(prefix))
}
labels = request.Filters.Labels
}
switch len(byFilters) {
case 0:
by = store.All
case 1:
by = byFilters[0]
default:
by = store.Or(byFilters...)
}
s.store.View(func(tx store.ReadTx) {
configs, err = store.FindConfigs(tx, by)
})
if err != nil {
return nil, err
}
// filter by label
for _, config := range configs {
if !filterMatchLabels(config.Spec.Annotations.Labels, labels) {
continue
}
respConfigs = append(respConfigs, config)
}
return &api.ListConfigsResponse{Configs: respConfigs}, nil
}
|
go
|
func (s *Server) ListConfigs(ctx context.Context, request *api.ListConfigsRequest) (*api.ListConfigsResponse, error) {
var (
configs []*api.Config
respConfigs []*api.Config
err error
byFilters []store.By
by store.By
labels map[string]string
)
// return all configs that match either any of the names or any of the name prefixes (why would you give both?)
if request.Filters != nil {
for _, name := range request.Filters.Names {
byFilters = append(byFilters, store.ByName(name))
}
for _, prefix := range request.Filters.NamePrefixes {
byFilters = append(byFilters, store.ByNamePrefix(prefix))
}
for _, prefix := range request.Filters.IDPrefixes {
byFilters = append(byFilters, store.ByIDPrefix(prefix))
}
labels = request.Filters.Labels
}
switch len(byFilters) {
case 0:
by = store.All
case 1:
by = byFilters[0]
default:
by = store.Or(byFilters...)
}
s.store.View(func(tx store.ReadTx) {
configs, err = store.FindConfigs(tx, by)
})
if err != nil {
return nil, err
}
// filter by label
for _, config := range configs {
if !filterMatchLabels(config.Spec.Annotations.Labels, labels) {
continue
}
respConfigs = append(respConfigs, config)
}
return &api.ListConfigsResponse{Configs: respConfigs}, nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"ListConfigs",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"ListConfigsRequest",
")",
"(",
"*",
"api",
".",
"ListConfigsResponse",
",",
"error",
")",
"{",
"var",
"(",
"configs",
"[",
"]",
"*",
"api",
".",
"Config",
"\n",
"respConfigs",
"[",
"]",
"*",
"api",
".",
"Config",
"\n",
"err",
"error",
"\n",
"byFilters",
"[",
"]",
"store",
".",
"By",
"\n",
"by",
"store",
".",
"By",
"\n",
"labels",
"map",
"[",
"string",
"]",
"string",
"\n",
")",
"\n\n",
"// return all configs that match either any of the names or any of the name prefixes (why would you give both?)",
"if",
"request",
".",
"Filters",
"!=",
"nil",
"{",
"for",
"_",
",",
"name",
":=",
"range",
"request",
".",
"Filters",
".",
"Names",
"{",
"byFilters",
"=",
"append",
"(",
"byFilters",
",",
"store",
".",
"ByName",
"(",
"name",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"prefix",
":=",
"range",
"request",
".",
"Filters",
".",
"NamePrefixes",
"{",
"byFilters",
"=",
"append",
"(",
"byFilters",
",",
"store",
".",
"ByNamePrefix",
"(",
"prefix",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"prefix",
":=",
"range",
"request",
".",
"Filters",
".",
"IDPrefixes",
"{",
"byFilters",
"=",
"append",
"(",
"byFilters",
",",
"store",
".",
"ByIDPrefix",
"(",
"prefix",
")",
")",
"\n",
"}",
"\n",
"labels",
"=",
"request",
".",
"Filters",
".",
"Labels",
"\n",
"}",
"\n\n",
"switch",
"len",
"(",
"byFilters",
")",
"{",
"case",
"0",
":",
"by",
"=",
"store",
".",
"All",
"\n",
"case",
"1",
":",
"by",
"=",
"byFilters",
"[",
"0",
"]",
"\n",
"default",
":",
"by",
"=",
"store",
".",
"Or",
"(",
"byFilters",
"...",
")",
"\n",
"}",
"\n\n",
"s",
".",
"store",
".",
"View",
"(",
"func",
"(",
"tx",
"store",
".",
"ReadTx",
")",
"{",
"configs",
",",
"err",
"=",
"store",
".",
"FindConfigs",
"(",
"tx",
",",
"by",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// filter by label",
"for",
"_",
",",
"config",
":=",
"range",
"configs",
"{",
"if",
"!",
"filterMatchLabels",
"(",
"config",
".",
"Spec",
".",
"Annotations",
".",
"Labels",
",",
"labels",
")",
"{",
"continue",
"\n",
"}",
"\n",
"respConfigs",
"=",
"append",
"(",
"respConfigs",
",",
"config",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"api",
".",
"ListConfigsResponse",
"{",
"Configs",
":",
"respConfigs",
"}",
",",
"nil",
"\n",
"}"
] |
// ListConfigs returns a `ListConfigResponse` with a list all non-internal `Config`s being
// managed, or all configs matching any name in `ListConfigsRequest.Names`, any
// name prefix in `ListConfigsRequest.NamePrefixes`, any id in
// `ListConfigsRequest.ConfigIDs`, or any id prefix in `ListConfigsRequest.IDPrefixes`.
// - Returns an error if listing fails.
|
[
"ListConfigs",
"returns",
"a",
"ListConfigResponse",
"with",
"a",
"list",
"all",
"non",
"-",
"internal",
"Config",
"s",
"being",
"managed",
"or",
"all",
"configs",
"matching",
"any",
"name",
"in",
"ListConfigsRequest",
".",
"Names",
"any",
"name",
"prefix",
"in",
"ListConfigsRequest",
".",
"NamePrefixes",
"any",
"id",
"in",
"ListConfigsRequest",
".",
"ConfigIDs",
"or",
"any",
"id",
"prefix",
"in",
"ListConfigsRequest",
".",
"IDPrefixes",
".",
"-",
"Returns",
"an",
"error",
"if",
"listing",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/config.go#L99-L148
|
train
|
docker/swarmkit
|
manager/controlapi/config.go
|
CreateConfig
|
func (s *Server) CreateConfig(ctx context.Context, request *api.CreateConfigRequest) (*api.CreateConfigResponse, error) {
if err := validateConfigSpec(request.Spec); err != nil {
return nil, err
}
config := configFromConfigSpec(request.Spec) // the store will handle name conflicts
err := s.store.Update(func(tx store.Tx) error {
return store.CreateConfig(tx, config)
})
switch err {
case store.ErrNameConflict:
return nil, status.Errorf(codes.AlreadyExists, "config %s already exists", request.Spec.Annotations.Name)
case nil:
log.G(ctx).WithFields(logrus.Fields{
"config.Name": request.Spec.Annotations.Name,
"method": "CreateConfig",
}).Debugf("config created")
return &api.CreateConfigResponse{Config: config}, nil
default:
return nil, err
}
}
|
go
|
func (s *Server) CreateConfig(ctx context.Context, request *api.CreateConfigRequest) (*api.CreateConfigResponse, error) {
if err := validateConfigSpec(request.Spec); err != nil {
return nil, err
}
config := configFromConfigSpec(request.Spec) // the store will handle name conflicts
err := s.store.Update(func(tx store.Tx) error {
return store.CreateConfig(tx, config)
})
switch err {
case store.ErrNameConflict:
return nil, status.Errorf(codes.AlreadyExists, "config %s already exists", request.Spec.Annotations.Name)
case nil:
log.G(ctx).WithFields(logrus.Fields{
"config.Name": request.Spec.Annotations.Name,
"method": "CreateConfig",
}).Debugf("config created")
return &api.CreateConfigResponse{Config: config}, nil
default:
return nil, err
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"CreateConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"CreateConfigRequest",
")",
"(",
"*",
"api",
".",
"CreateConfigResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"validateConfigSpec",
"(",
"request",
".",
"Spec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"config",
":=",
"configFromConfigSpec",
"(",
"request",
".",
"Spec",
")",
"// the store will handle name conflicts",
"\n",
"err",
":=",
"s",
".",
"store",
".",
"Update",
"(",
"func",
"(",
"tx",
"store",
".",
"Tx",
")",
"error",
"{",
"return",
"store",
".",
"CreateConfig",
"(",
"tx",
",",
"config",
")",
"\n",
"}",
")",
"\n\n",
"switch",
"err",
"{",
"case",
"store",
".",
"ErrNameConflict",
":",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"AlreadyExists",
",",
"\"",
"\"",
",",
"request",
".",
"Spec",
".",
"Annotations",
".",
"Name",
")",
"\n",
"case",
"nil",
":",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"request",
".",
"Spec",
".",
"Annotations",
".",
"Name",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
")",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"&",
"api",
".",
"CreateConfigResponse",
"{",
"Config",
":",
"config",
"}",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// CreateConfig creates and returns a `CreateConfigResponse` with a `Config` based
// on the provided `CreateConfigRequest.ConfigSpec`.
// - Returns `InvalidArgument` if the `CreateConfigRequest.ConfigSpec` is malformed,
// or if the config data is too long or contains invalid characters.
// - Returns an error if the creation fails.
|
[
"CreateConfig",
"creates",
"and",
"returns",
"a",
"CreateConfigResponse",
"with",
"a",
"Config",
"based",
"on",
"the",
"provided",
"CreateConfigRequest",
".",
"ConfigSpec",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"the",
"CreateConfigRequest",
".",
"ConfigSpec",
"is",
"malformed",
"or",
"if",
"the",
"config",
"data",
"is",
"too",
"long",
"or",
"contains",
"invalid",
"characters",
".",
"-",
"Returns",
"an",
"error",
"if",
"the",
"creation",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/config.go#L155-L178
|
train
|
docker/swarmkit
|
manager/controlapi/config.go
|
RemoveConfig
|
func (s *Server) RemoveConfig(ctx context.Context, request *api.RemoveConfigRequest) (*api.RemoveConfigResponse, error) {
if request.ConfigID == "" {
return nil, status.Errorf(codes.InvalidArgument, "config ID must be provided")
}
err := s.store.Update(func(tx store.Tx) error {
// Check if the config exists
config := store.GetConfig(tx, request.ConfigID)
if config == nil {
return status.Errorf(codes.NotFound, "could not find config %s", request.ConfigID)
}
// Check if any services currently reference this config, return error if so
services, err := store.FindServices(tx, store.ByReferencedConfigID(request.ConfigID))
if err != nil {
return status.Errorf(codes.Internal, "could not find services using config %s: %v", request.ConfigID, err)
}
if len(services) != 0 {
serviceNames := make([]string, 0, len(services))
for _, service := range services {
serviceNames = append(serviceNames, service.Spec.Annotations.Name)
}
configName := config.Spec.Annotations.Name
serviceNameStr := strings.Join(serviceNames, ", ")
serviceStr := "services"
if len(serviceNames) == 1 {
serviceStr = "service"
}
return status.Errorf(codes.InvalidArgument, "config '%s' is in use by the following %s: %v", configName, serviceStr, serviceNameStr)
}
return store.DeleteConfig(tx, request.ConfigID)
})
switch err {
case store.ErrNotExist:
return nil, status.Errorf(codes.NotFound, "config %s not found", request.ConfigID)
case nil:
log.G(ctx).WithFields(logrus.Fields{
"config.ID": request.ConfigID,
"method": "RemoveConfig",
}).Debugf("config removed")
return &api.RemoveConfigResponse{}, nil
default:
return nil, err
}
}
|
go
|
func (s *Server) RemoveConfig(ctx context.Context, request *api.RemoveConfigRequest) (*api.RemoveConfigResponse, error) {
if request.ConfigID == "" {
return nil, status.Errorf(codes.InvalidArgument, "config ID must be provided")
}
err := s.store.Update(func(tx store.Tx) error {
// Check if the config exists
config := store.GetConfig(tx, request.ConfigID)
if config == nil {
return status.Errorf(codes.NotFound, "could not find config %s", request.ConfigID)
}
// Check if any services currently reference this config, return error if so
services, err := store.FindServices(tx, store.ByReferencedConfigID(request.ConfigID))
if err != nil {
return status.Errorf(codes.Internal, "could not find services using config %s: %v", request.ConfigID, err)
}
if len(services) != 0 {
serviceNames := make([]string, 0, len(services))
for _, service := range services {
serviceNames = append(serviceNames, service.Spec.Annotations.Name)
}
configName := config.Spec.Annotations.Name
serviceNameStr := strings.Join(serviceNames, ", ")
serviceStr := "services"
if len(serviceNames) == 1 {
serviceStr = "service"
}
return status.Errorf(codes.InvalidArgument, "config '%s' is in use by the following %s: %v", configName, serviceStr, serviceNameStr)
}
return store.DeleteConfig(tx, request.ConfigID)
})
switch err {
case store.ErrNotExist:
return nil, status.Errorf(codes.NotFound, "config %s not found", request.ConfigID)
case nil:
log.G(ctx).WithFields(logrus.Fields{
"config.ID": request.ConfigID,
"method": "RemoveConfig",
}).Debugf("config removed")
return &api.RemoveConfigResponse{}, nil
default:
return nil, err
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"RemoveConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"request",
"*",
"api",
".",
"RemoveConfigRequest",
")",
"(",
"*",
"api",
".",
"RemoveConfigResponse",
",",
"error",
")",
"{",
"if",
"request",
".",
"ConfigID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"s",
".",
"store",
".",
"Update",
"(",
"func",
"(",
"tx",
"store",
".",
"Tx",
")",
"error",
"{",
"// Check if the config exists",
"config",
":=",
"store",
".",
"GetConfig",
"(",
"tx",
",",
"request",
".",
"ConfigID",
")",
"\n",
"if",
"config",
"==",
"nil",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"ConfigID",
")",
"\n",
"}",
"\n\n",
"// Check if any services currently reference this config, return error if so",
"services",
",",
"err",
":=",
"store",
".",
"FindServices",
"(",
"tx",
",",
"store",
".",
"ByReferencedConfigID",
"(",
"request",
".",
"ConfigID",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Internal",
",",
"\"",
"\"",
",",
"request",
".",
"ConfigID",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"services",
")",
"!=",
"0",
"{",
"serviceNames",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"services",
")",
")",
"\n",
"for",
"_",
",",
"service",
":=",
"range",
"services",
"{",
"serviceNames",
"=",
"append",
"(",
"serviceNames",
",",
"service",
".",
"Spec",
".",
"Annotations",
".",
"Name",
")",
"\n",
"}",
"\n\n",
"configName",
":=",
"config",
".",
"Spec",
".",
"Annotations",
".",
"Name",
"\n",
"serviceNameStr",
":=",
"strings",
".",
"Join",
"(",
"serviceNames",
",",
"\"",
"\"",
")",
"\n",
"serviceStr",
":=",
"\"",
"\"",
"\n",
"if",
"len",
"(",
"serviceNames",
")",
"==",
"1",
"{",
"serviceStr",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"\"",
"\"",
",",
"configName",
",",
"serviceStr",
",",
"serviceNameStr",
")",
"\n",
"}",
"\n\n",
"return",
"store",
".",
"DeleteConfig",
"(",
"tx",
",",
"request",
".",
"ConfigID",
")",
"\n",
"}",
")",
"\n",
"switch",
"err",
"{",
"case",
"store",
".",
"ErrNotExist",
":",
"return",
"nil",
",",
"status",
".",
"Errorf",
"(",
"codes",
".",
"NotFound",
",",
"\"",
"\"",
",",
"request",
".",
"ConfigID",
")",
"\n",
"case",
"nil",
":",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"request",
".",
"ConfigID",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
")",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"&",
"api",
".",
"RemoveConfigResponse",
"{",
"}",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// RemoveConfig removes the config referenced by `RemoveConfigRequest.ID`.
// - Returns `InvalidArgument` if `RemoveConfigRequest.ID` is empty.
// - Returns `NotFound` if the a config named `RemoveConfigRequest.ID` is not found.
// - Returns `ConfigInUse` if the config is currently in use
// - Returns an error if the deletion fails.
|
[
"RemoveConfig",
"removes",
"the",
"config",
"referenced",
"by",
"RemoveConfigRequest",
".",
"ID",
".",
"-",
"Returns",
"InvalidArgument",
"if",
"RemoveConfigRequest",
".",
"ID",
"is",
"empty",
".",
"-",
"Returns",
"NotFound",
"if",
"the",
"a",
"config",
"named",
"RemoveConfigRequest",
".",
"ID",
"is",
"not",
"found",
".",
"-",
"Returns",
"ConfigInUse",
"if",
"the",
"config",
"is",
"currently",
"in",
"use",
"-",
"Returns",
"an",
"error",
"if",
"the",
"deletion",
"fails",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/controlapi/config.go#L185-L234
|
train
|
docker/swarmkit
|
xnet/xnet_windows.go
|
ListenLocal
|
func ListenLocal(socket string) (net.Listener, error) {
// set up ACL for the named pipe
// allow Administrators and SYSTEM
sddl := "D:P(A;;GA;;;BA)(A;;GA;;;SY)"
c := winio.PipeConfig{
SecurityDescriptor: sddl,
MessageMode: true, // Use message mode so that CloseWrite() is supported
InputBufferSize: 65536, // Use 64KB buffers to improve performance
OutputBufferSize: 65536,
}
// on windows, our socket is actually a named pipe
return winio.ListenPipe(socket, &c)
}
|
go
|
func ListenLocal(socket string) (net.Listener, error) {
// set up ACL for the named pipe
// allow Administrators and SYSTEM
sddl := "D:P(A;;GA;;;BA)(A;;GA;;;SY)"
c := winio.PipeConfig{
SecurityDescriptor: sddl,
MessageMode: true, // Use message mode so that CloseWrite() is supported
InputBufferSize: 65536, // Use 64KB buffers to improve performance
OutputBufferSize: 65536,
}
// on windows, our socket is actually a named pipe
return winio.ListenPipe(socket, &c)
}
|
[
"func",
"ListenLocal",
"(",
"socket",
"string",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"// set up ACL for the named pipe",
"// allow Administrators and SYSTEM",
"sddl",
":=",
"\"",
"\"",
"\n",
"c",
":=",
"winio",
".",
"PipeConfig",
"{",
"SecurityDescriptor",
":",
"sddl",
",",
"MessageMode",
":",
"true",
",",
"// Use message mode so that CloseWrite() is supported",
"InputBufferSize",
":",
"65536",
",",
"// Use 64KB buffers to improve performance",
"OutputBufferSize",
":",
"65536",
",",
"}",
"\n",
"// on windows, our socket is actually a named pipe",
"return",
"winio",
".",
"ListenPipe",
"(",
"socket",
",",
"&",
"c",
")",
"\n",
"}"
] |
// ListenLocal opens a local socket for control communication
|
[
"ListenLocal",
"opens",
"a",
"local",
"socket",
"for",
"control",
"communication"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/xnet/xnet_windows.go#L13-L25
|
train
|
docker/swarmkit
|
manager/state/raft/util.go
|
dial
|
func dial(addr string, protocol string, creds credentials.TransportCredentials, timeout time.Duration) (*grpc.ClientConn, error) {
// gRPC dialer connects to proxy first. Provide a custom dialer here avoid that.
grpcOptions := []grpc.DialOption{
grpc.WithBackoffMaxDelay(2 * time.Second),
grpc.WithTransportCredentials(creds),
grpc.WithUnaryInterceptor(grpc_prometheus.UnaryClientInterceptor),
grpc.WithStreamInterceptor(grpc_prometheus.StreamClientInterceptor),
grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("tcp", addr, timeout)
}),
}
if timeout != 0 {
grpcOptions = append(grpcOptions, grpc.WithTimeout(timeout))
}
return grpc.Dial(addr, grpcOptions...)
}
|
go
|
func dial(addr string, protocol string, creds credentials.TransportCredentials, timeout time.Duration) (*grpc.ClientConn, error) {
// gRPC dialer connects to proxy first. Provide a custom dialer here avoid that.
grpcOptions := []grpc.DialOption{
grpc.WithBackoffMaxDelay(2 * time.Second),
grpc.WithTransportCredentials(creds),
grpc.WithUnaryInterceptor(grpc_prometheus.UnaryClientInterceptor),
grpc.WithStreamInterceptor(grpc_prometheus.StreamClientInterceptor),
grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("tcp", addr, timeout)
}),
}
if timeout != 0 {
grpcOptions = append(grpcOptions, grpc.WithTimeout(timeout))
}
return grpc.Dial(addr, grpcOptions...)
}
|
[
"func",
"dial",
"(",
"addr",
"string",
",",
"protocol",
"string",
",",
"creds",
"credentials",
".",
"TransportCredentials",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"grpc",
".",
"ClientConn",
",",
"error",
")",
"{",
"// gRPC dialer connects to proxy first. Provide a custom dialer here avoid that.",
"grpcOptions",
":=",
"[",
"]",
"grpc",
".",
"DialOption",
"{",
"grpc",
".",
"WithBackoffMaxDelay",
"(",
"2",
"*",
"time",
".",
"Second",
")",
",",
"grpc",
".",
"WithTransportCredentials",
"(",
"creds",
")",
",",
"grpc",
".",
"WithUnaryInterceptor",
"(",
"grpc_prometheus",
".",
"UnaryClientInterceptor",
")",
",",
"grpc",
".",
"WithStreamInterceptor",
"(",
"grpc_prometheus",
".",
"StreamClientInterceptor",
")",
",",
"grpc",
".",
"WithDialer",
"(",
"func",
"(",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"net",
".",
"DialTimeout",
"(",
"\"",
"\"",
",",
"addr",
",",
"timeout",
")",
"\n",
"}",
")",
",",
"}",
"\n\n",
"if",
"timeout",
"!=",
"0",
"{",
"grpcOptions",
"=",
"append",
"(",
"grpcOptions",
",",
"grpc",
".",
"WithTimeout",
"(",
"timeout",
")",
")",
"\n",
"}",
"\n\n",
"return",
"grpc",
".",
"Dial",
"(",
"addr",
",",
"grpcOptions",
"...",
")",
"\n",
"}"
] |
// dial returns a grpc client connection
|
[
"dial",
"returns",
"a",
"grpc",
"client",
"connection"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/util.go#L17-L34
|
train
|
docker/swarmkit
|
manager/state/raft/util.go
|
Register
|
func Register(server *grpc.Server, node *Node) {
api.RegisterRaftServer(server, node)
api.RegisterRaftMembershipServer(server, node)
}
|
go
|
func Register(server *grpc.Server, node *Node) {
api.RegisterRaftServer(server, node)
api.RegisterRaftMembershipServer(server, node)
}
|
[
"func",
"Register",
"(",
"server",
"*",
"grpc",
".",
"Server",
",",
"node",
"*",
"Node",
")",
"{",
"api",
".",
"RegisterRaftServer",
"(",
"server",
",",
"node",
")",
"\n",
"api",
".",
"RegisterRaftMembershipServer",
"(",
"server",
",",
"node",
")",
"\n",
"}"
] |
// Register registers the node raft server
|
[
"Register",
"registers",
"the",
"node",
"raft",
"server"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/util.go#L37-L40
|
train
|
docker/swarmkit
|
manager/state/raft/util.go
|
WaitForLeader
|
func WaitForLeader(ctx context.Context, n *Node) error {
_, err := n.Leader()
if err == nil {
return nil
}
ticker := time.NewTicker(50 * time.Millisecond)
defer ticker.Stop()
for err != nil {
select {
case <-ticker.C:
case <-ctx.Done():
return ctx.Err()
}
_, err = n.Leader()
}
return nil
}
|
go
|
func WaitForLeader(ctx context.Context, n *Node) error {
_, err := n.Leader()
if err == nil {
return nil
}
ticker := time.NewTicker(50 * time.Millisecond)
defer ticker.Stop()
for err != nil {
select {
case <-ticker.C:
case <-ctx.Done():
return ctx.Err()
}
_, err = n.Leader()
}
return nil
}
|
[
"func",
"WaitForLeader",
"(",
"ctx",
"context",
".",
"Context",
",",
"n",
"*",
"Node",
")",
"error",
"{",
"_",
",",
"err",
":=",
"n",
".",
"Leader",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"50",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"for",
"err",
"!=",
"nil",
"{",
"select",
"{",
"case",
"<-",
"ticker",
".",
"C",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"n",
".",
"Leader",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WaitForLeader waits until node observe some leader in cluster. It returns
// error if ctx was cancelled before leader appeared.
|
[
"WaitForLeader",
"waits",
"until",
"node",
"observe",
"some",
"leader",
"in",
"cluster",
".",
"It",
"returns",
"error",
"if",
"ctx",
"was",
"cancelled",
"before",
"leader",
"appeared",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/util.go#L44-L60
|
train
|
docker/swarmkit
|
manager/state/raft/util.go
|
WaitForCluster
|
func WaitForCluster(ctx context.Context, n *Node) (cluster *api.Cluster, err error) {
watch, cancel := state.Watch(n.MemoryStore().WatchQueue(), api.EventCreateCluster{})
defer cancel()
var clusters []*api.Cluster
n.MemoryStore().View(func(readTx store.ReadTx) {
clusters, err = store.FindClusters(readTx, store.ByName(store.DefaultClusterName))
})
if err != nil {
return nil, err
}
if len(clusters) == 1 {
cluster = clusters[0]
} else {
select {
case e := <-watch:
cluster = e.(api.EventCreateCluster).Cluster
case <-ctx.Done():
return nil, ctx.Err()
}
}
return cluster, nil
}
|
go
|
func WaitForCluster(ctx context.Context, n *Node) (cluster *api.Cluster, err error) {
watch, cancel := state.Watch(n.MemoryStore().WatchQueue(), api.EventCreateCluster{})
defer cancel()
var clusters []*api.Cluster
n.MemoryStore().View(func(readTx store.ReadTx) {
clusters, err = store.FindClusters(readTx, store.ByName(store.DefaultClusterName))
})
if err != nil {
return nil, err
}
if len(clusters) == 1 {
cluster = clusters[0]
} else {
select {
case e := <-watch:
cluster = e.(api.EventCreateCluster).Cluster
case <-ctx.Done():
return nil, ctx.Err()
}
}
return cluster, nil
}
|
[
"func",
"WaitForCluster",
"(",
"ctx",
"context",
".",
"Context",
",",
"n",
"*",
"Node",
")",
"(",
"cluster",
"*",
"api",
".",
"Cluster",
",",
"err",
"error",
")",
"{",
"watch",
",",
"cancel",
":=",
"state",
".",
"Watch",
"(",
"n",
".",
"MemoryStore",
"(",
")",
".",
"WatchQueue",
"(",
")",
",",
"api",
".",
"EventCreateCluster",
"{",
"}",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"var",
"clusters",
"[",
"]",
"*",
"api",
".",
"Cluster",
"\n",
"n",
".",
"MemoryStore",
"(",
")",
".",
"View",
"(",
"func",
"(",
"readTx",
"store",
".",
"ReadTx",
")",
"{",
"clusters",
",",
"err",
"=",
"store",
".",
"FindClusters",
"(",
"readTx",
",",
"store",
".",
"ByName",
"(",
"store",
".",
"DefaultClusterName",
")",
")",
"\n",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"clusters",
")",
"==",
"1",
"{",
"cluster",
"=",
"clusters",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"select",
"{",
"case",
"e",
":=",
"<-",
"watch",
":",
"cluster",
"=",
"e",
".",
"(",
"api",
".",
"EventCreateCluster",
")",
".",
"Cluster",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"cluster",
",",
"nil",
"\n",
"}"
] |
// WaitForCluster waits until node observes that the cluster wide config is
// committed to raft. This ensures that we can see and serve informations
// related to the cluster.
|
[
"WaitForCluster",
"waits",
"until",
"node",
"observes",
"that",
"the",
"cluster",
"wide",
"config",
"is",
"committed",
"to",
"raft",
".",
"This",
"ensures",
"that",
"we",
"can",
"see",
"and",
"serve",
"informations",
"related",
"to",
"the",
"cluster",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/util.go#L65-L90
|
train
|
docker/swarmkit
|
manager/dispatcher/nodes.go
|
checkSessionID
|
func (rn *registeredNode) checkSessionID(sessionID string) error {
rn.mu.Lock()
defer rn.mu.Unlock()
// Before each message send, we need to check the nodes sessionID hasn't
// changed. If it has, we will the stream and make the node
// re-register.
if sessionID == "" || rn.SessionID != sessionID {
return status.Errorf(codes.InvalidArgument, ErrSessionInvalid.Error())
}
return nil
}
|
go
|
func (rn *registeredNode) checkSessionID(sessionID string) error {
rn.mu.Lock()
defer rn.mu.Unlock()
// Before each message send, we need to check the nodes sessionID hasn't
// changed. If it has, we will the stream and make the node
// re-register.
if sessionID == "" || rn.SessionID != sessionID {
return status.Errorf(codes.InvalidArgument, ErrSessionInvalid.Error())
}
return nil
}
|
[
"func",
"(",
"rn",
"*",
"registeredNode",
")",
"checkSessionID",
"(",
"sessionID",
"string",
")",
"error",
"{",
"rn",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rn",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// Before each message send, we need to check the nodes sessionID hasn't",
"// changed. If it has, we will the stream and make the node",
"// re-register.",
"if",
"sessionID",
"==",
"\"",
"\"",
"||",
"rn",
".",
"SessionID",
"!=",
"sessionID",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"InvalidArgument",
",",
"ErrSessionInvalid",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// checkSessionID determines if the SessionID has changed and returns the
// appropriate GRPC error code.
//
// This may not belong here in the future.
|
[
"checkSessionID",
"determines",
"if",
"the",
"SessionID",
"has",
"changed",
"and",
"returns",
"the",
"appropriate",
"GRPC",
"error",
"code",
".",
"This",
"may",
"not",
"belong",
"here",
"in",
"the",
"future",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/dispatcher/nodes.go#L30-L42
|
train
|
docker/swarmkit
|
manager/dispatcher/nodes.go
|
CheckRateLimit
|
func (s *nodeStore) CheckRateLimit(id string) error {
s.mu.Lock()
defer s.mu.Unlock()
if existRn, ok := s.nodes[id]; ok {
if time.Since(existRn.Registered) > s.rateLimitPeriod {
existRn.Attempts = 0
}
existRn.Attempts++
if existRn.Attempts > rateLimitCount {
return status.Errorf(codes.Unavailable, "node %s exceeded rate limit count of registrations", id)
}
existRn.Registered = time.Now()
}
return nil
}
|
go
|
func (s *nodeStore) CheckRateLimit(id string) error {
s.mu.Lock()
defer s.mu.Unlock()
if existRn, ok := s.nodes[id]; ok {
if time.Since(existRn.Registered) > s.rateLimitPeriod {
existRn.Attempts = 0
}
existRn.Attempts++
if existRn.Attempts > rateLimitCount {
return status.Errorf(codes.Unavailable, "node %s exceeded rate limit count of registrations", id)
}
existRn.Registered = time.Now()
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"nodeStore",
")",
"CheckRateLimit",
"(",
"id",
"string",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"existRn",
",",
"ok",
":=",
"s",
".",
"nodes",
"[",
"id",
"]",
";",
"ok",
"{",
"if",
"time",
".",
"Since",
"(",
"existRn",
".",
"Registered",
")",
">",
"s",
".",
"rateLimitPeriod",
"{",
"existRn",
".",
"Attempts",
"=",
"0",
"\n",
"}",
"\n",
"existRn",
".",
"Attempts",
"++",
"\n",
"if",
"existRn",
".",
"Attempts",
">",
"rateLimitCount",
"{",
"return",
"status",
".",
"Errorf",
"(",
"codes",
".",
"Unavailable",
",",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n",
"existRn",
".",
"Registered",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckRateLimit returns error if node with specified id is allowed to re-register
// again.
|
[
"CheckRateLimit",
"returns",
"error",
"if",
"node",
"with",
"specified",
"id",
"is",
"allowed",
"to",
"re",
"-",
"register",
"again",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/dispatcher/nodes.go#L90-L104
|
train
|
docker/swarmkit
|
manager/dispatcher/nodes.go
|
Add
|
func (s *nodeStore) Add(n *api.Node, expireFunc func()) *registeredNode {
s.mu.Lock()
defer s.mu.Unlock()
var attempts int
var registered time.Time
if existRn, ok := s.nodes[n.ID]; ok {
attempts = existRn.Attempts
registered = existRn.Registered
existRn.Heartbeat.Stop()
delete(s.nodes, n.ID)
}
if registered.IsZero() {
registered = time.Now()
}
rn := ®isteredNode{
SessionID: identity.NewID(), // session ID is local to the dispatcher.
Node: n,
Registered: registered,
Attempts: attempts,
Disconnect: make(chan struct{}),
}
s.nodes[n.ID] = rn
rn.Heartbeat = heartbeat.New(s.periodChooser.Choose()*s.gracePeriodMultiplierNormal, expireFunc)
return rn
}
|
go
|
func (s *nodeStore) Add(n *api.Node, expireFunc func()) *registeredNode {
s.mu.Lock()
defer s.mu.Unlock()
var attempts int
var registered time.Time
if existRn, ok := s.nodes[n.ID]; ok {
attempts = existRn.Attempts
registered = existRn.Registered
existRn.Heartbeat.Stop()
delete(s.nodes, n.ID)
}
if registered.IsZero() {
registered = time.Now()
}
rn := ®isteredNode{
SessionID: identity.NewID(), // session ID is local to the dispatcher.
Node: n,
Registered: registered,
Attempts: attempts,
Disconnect: make(chan struct{}),
}
s.nodes[n.ID] = rn
rn.Heartbeat = heartbeat.New(s.periodChooser.Choose()*s.gracePeriodMultiplierNormal, expireFunc)
return rn
}
|
[
"func",
"(",
"s",
"*",
"nodeStore",
")",
"Add",
"(",
"n",
"*",
"api",
".",
"Node",
",",
"expireFunc",
"func",
"(",
")",
")",
"*",
"registeredNode",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"var",
"attempts",
"int",
"\n",
"var",
"registered",
"time",
".",
"Time",
"\n",
"if",
"existRn",
",",
"ok",
":=",
"s",
".",
"nodes",
"[",
"n",
".",
"ID",
"]",
";",
"ok",
"{",
"attempts",
"=",
"existRn",
".",
"Attempts",
"\n",
"registered",
"=",
"existRn",
".",
"Registered",
"\n",
"existRn",
".",
"Heartbeat",
".",
"Stop",
"(",
")",
"\n",
"delete",
"(",
"s",
".",
"nodes",
",",
"n",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"registered",
".",
"IsZero",
"(",
")",
"{",
"registered",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"rn",
":=",
"&",
"registeredNode",
"{",
"SessionID",
":",
"identity",
".",
"NewID",
"(",
")",
",",
"// session ID is local to the dispatcher.",
"Node",
":",
"n",
",",
"Registered",
":",
"registered",
",",
"Attempts",
":",
"attempts",
",",
"Disconnect",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"s",
".",
"nodes",
"[",
"n",
".",
"ID",
"]",
"=",
"rn",
"\n",
"rn",
".",
"Heartbeat",
"=",
"heartbeat",
".",
"New",
"(",
"s",
".",
"periodChooser",
".",
"Choose",
"(",
")",
"*",
"s",
".",
"gracePeriodMultiplierNormal",
",",
"expireFunc",
")",
"\n",
"return",
"rn",
"\n",
"}"
] |
// Add adds new node and returns it, it replaces existing without notification.
|
[
"Add",
"adds",
"new",
"node",
"and",
"returns",
"it",
"it",
"replaces",
"existing",
"without",
"notification",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/dispatcher/nodes.go#L107-L131
|
train
|
docker/swarmkit
|
manager/dispatcher/nodes.go
|
Clean
|
func (s *nodeStore) Clean() {
s.mu.Lock()
for _, rn := range s.nodes {
rn.Heartbeat.Stop()
}
s.nodes = make(map[string]*registeredNode)
s.mu.Unlock()
}
|
go
|
func (s *nodeStore) Clean() {
s.mu.Lock()
for _, rn := range s.nodes {
rn.Heartbeat.Stop()
}
s.nodes = make(map[string]*registeredNode)
s.mu.Unlock()
}
|
[
"func",
"(",
"s",
"*",
"nodeStore",
")",
"Clean",
"(",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"rn",
":=",
"range",
"s",
".",
"nodes",
"{",
"rn",
".",
"Heartbeat",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"s",
".",
"nodes",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"registeredNode",
")",
"\n",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Clean removes all nodes and stops their heartbeats.
// It's equivalent to invalidate all sessions.
|
[
"Clean",
"removes",
"all",
"nodes",
"and",
"stops",
"their",
"heartbeats",
".",
"It",
"s",
"equivalent",
"to",
"invalidate",
"all",
"sessions",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/dispatcher/nodes.go#L190-L197
|
train
|
docker/swarmkit
|
agent/exec/dockerapi/executor.go
|
Controller
|
func (e *executor) Controller(t *api.Task) (exec.Controller, error) {
// Get the node description from the executor field
e.mutex.Lock()
nodeDescription := e.node
e.mutex.Unlock()
ctlr, err := newController(e.client, nodeDescription, t, secrets.Restrict(e.secrets, t))
if err != nil {
return nil, err
}
return ctlr, nil
}
|
go
|
func (e *executor) Controller(t *api.Task) (exec.Controller, error) {
// Get the node description from the executor field
e.mutex.Lock()
nodeDescription := e.node
e.mutex.Unlock()
ctlr, err := newController(e.client, nodeDescription, t, secrets.Restrict(e.secrets, t))
if err != nil {
return nil, err
}
return ctlr, nil
}
|
[
"func",
"(",
"e",
"*",
"executor",
")",
"Controller",
"(",
"t",
"*",
"api",
".",
"Task",
")",
"(",
"exec",
".",
"Controller",
",",
"error",
")",
"{",
"// Get the node description from the executor field",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"nodeDescription",
":=",
"e",
".",
"node",
"\n",
"e",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"ctlr",
",",
"err",
":=",
"newController",
"(",
"e",
".",
"client",
",",
"nodeDescription",
",",
"t",
",",
"secrets",
".",
"Restrict",
"(",
"e",
".",
"secrets",
",",
"t",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"ctlr",
",",
"nil",
"\n",
"}"
] |
// Controller returns a docker container controller.
|
[
"Controller",
"returns",
"a",
"docker",
"container",
"controller",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/exec/dockerapi/executor.go#L131-L142
|
train
|
docker/swarmkit
|
watch/queue/queue.go
|
NewLimitQueue
|
func NewLimitQueue(dst events.Sink, limit uint64) *LimitQueue {
eq := LimitQueue{
dst: dst,
events: list.New(),
limit: limit,
full: make(chan struct{}),
}
eq.cond = sync.NewCond(&eq.mu)
go eq.run()
return &eq
}
|
go
|
func NewLimitQueue(dst events.Sink, limit uint64) *LimitQueue {
eq := LimitQueue{
dst: dst,
events: list.New(),
limit: limit,
full: make(chan struct{}),
}
eq.cond = sync.NewCond(&eq.mu)
go eq.run()
return &eq
}
|
[
"func",
"NewLimitQueue",
"(",
"dst",
"events",
".",
"Sink",
",",
"limit",
"uint64",
")",
"*",
"LimitQueue",
"{",
"eq",
":=",
"LimitQueue",
"{",
"dst",
":",
"dst",
",",
"events",
":",
"list",
".",
"New",
"(",
")",
",",
"limit",
":",
"limit",
",",
"full",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n\n",
"eq",
".",
"cond",
"=",
"sync",
".",
"NewCond",
"(",
"&",
"eq",
".",
"mu",
")",
"\n",
"go",
"eq",
".",
"run",
"(",
")",
"\n",
"return",
"&",
"eq",
"\n",
"}"
] |
// NewLimitQueue returns a queue to the provided Sink dst.
|
[
"NewLimitQueue",
"returns",
"a",
"queue",
"to",
"the",
"provided",
"Sink",
"dst",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/watch/queue/queue.go#L33-L44
|
train
|
docker/swarmkit
|
watch/queue/queue.go
|
Write
|
func (eq *LimitQueue) Write(event events.Event) error {
eq.mu.Lock()
defer eq.mu.Unlock()
if eq.closed {
return events.ErrSinkClosed
}
if eq.limit > 0 && uint64(eq.events.Len()) >= eq.limit {
// If the limit has been reached, don't write the event to the queue,
// and close the Full channel. This notifies listeners that the queue
// is now full, but the sink is still permitted to consume events. It's
// the responsibility of the listener to decide whether they want to
// live with dropped events or whether they want to Close() the
// LimitQueue
if !eq.fullClosed {
eq.fullClosed = true
close(eq.full)
}
return ErrQueueFull
}
eq.events.PushBack(event)
eq.cond.Signal() // signal waiters
return nil
}
|
go
|
func (eq *LimitQueue) Write(event events.Event) error {
eq.mu.Lock()
defer eq.mu.Unlock()
if eq.closed {
return events.ErrSinkClosed
}
if eq.limit > 0 && uint64(eq.events.Len()) >= eq.limit {
// If the limit has been reached, don't write the event to the queue,
// and close the Full channel. This notifies listeners that the queue
// is now full, but the sink is still permitted to consume events. It's
// the responsibility of the listener to decide whether they want to
// live with dropped events or whether they want to Close() the
// LimitQueue
if !eq.fullClosed {
eq.fullClosed = true
close(eq.full)
}
return ErrQueueFull
}
eq.events.PushBack(event)
eq.cond.Signal() // signal waiters
return nil
}
|
[
"func",
"(",
"eq",
"*",
"LimitQueue",
")",
"Write",
"(",
"event",
"events",
".",
"Event",
")",
"error",
"{",
"eq",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"eq",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"eq",
".",
"closed",
"{",
"return",
"events",
".",
"ErrSinkClosed",
"\n",
"}",
"\n\n",
"if",
"eq",
".",
"limit",
">",
"0",
"&&",
"uint64",
"(",
"eq",
".",
"events",
".",
"Len",
"(",
")",
")",
">=",
"eq",
".",
"limit",
"{",
"// If the limit has been reached, don't write the event to the queue,",
"// and close the Full channel. This notifies listeners that the queue",
"// is now full, but the sink is still permitted to consume events. It's",
"// the responsibility of the listener to decide whether they want to",
"// live with dropped events or whether they want to Close() the",
"// LimitQueue",
"if",
"!",
"eq",
".",
"fullClosed",
"{",
"eq",
".",
"fullClosed",
"=",
"true",
"\n",
"close",
"(",
"eq",
".",
"full",
")",
"\n",
"}",
"\n",
"return",
"ErrQueueFull",
"\n",
"}",
"\n\n",
"eq",
".",
"events",
".",
"PushBack",
"(",
"event",
")",
"\n",
"eq",
".",
"cond",
".",
"Signal",
"(",
")",
"// signal waiters",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Write accepts the events into the queue, only failing if the queue has
// been closed or has reached its size limit.
|
[
"Write",
"accepts",
"the",
"events",
"into",
"the",
"queue",
"only",
"failing",
"if",
"the",
"queue",
"has",
"been",
"closed",
"or",
"has",
"reached",
"its",
"size",
"limit",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/watch/queue/queue.go#L48-L74
|
train
|
docker/swarmkit
|
watch/queue/queue.go
|
Len
|
func (eq *LimitQueue) Len() int {
eq.mu.Lock()
defer eq.mu.Unlock()
return eq.events.Len()
}
|
go
|
func (eq *LimitQueue) Len() int {
eq.mu.Lock()
defer eq.mu.Unlock()
return eq.events.Len()
}
|
[
"func",
"(",
"eq",
"*",
"LimitQueue",
")",
"Len",
"(",
")",
"int",
"{",
"eq",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"eq",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"eq",
".",
"events",
".",
"Len",
"(",
")",
"\n",
"}"
] |
// Len returns the number of items that are currently stored in the queue and
// not consumed by its sink.
|
[
"Len",
"returns",
"the",
"number",
"of",
"items",
"that",
"are",
"currently",
"stored",
"in",
"the",
"queue",
"and",
"not",
"consumed",
"by",
"its",
"sink",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/watch/queue/queue.go#L125-L129
|
train
|
docker/swarmkit
|
ca/reconciler.go
|
IssuerFromAPIRootCA
|
func IssuerFromAPIRootCA(rootCA *api.RootCA) (*IssuerInfo, error) {
wantedIssuer := rootCA.CACert
if rootCA.RootRotation != nil {
wantedIssuer = rootCA.RootRotation.CACert
}
issuerCerts, err := helpers.ParseCertificatesPEM(wantedIssuer)
if err != nil {
return nil, errors.Wrap(err, "invalid certificate in cluster root CA object")
}
if len(issuerCerts) == 0 {
return nil, errors.New("invalid certificate in cluster root CA object")
}
return &IssuerInfo{
Subject: issuerCerts[0].RawSubject,
PublicKey: issuerCerts[0].RawSubjectPublicKeyInfo,
}, nil
}
|
go
|
func IssuerFromAPIRootCA(rootCA *api.RootCA) (*IssuerInfo, error) {
wantedIssuer := rootCA.CACert
if rootCA.RootRotation != nil {
wantedIssuer = rootCA.RootRotation.CACert
}
issuerCerts, err := helpers.ParseCertificatesPEM(wantedIssuer)
if err != nil {
return nil, errors.Wrap(err, "invalid certificate in cluster root CA object")
}
if len(issuerCerts) == 0 {
return nil, errors.New("invalid certificate in cluster root CA object")
}
return &IssuerInfo{
Subject: issuerCerts[0].RawSubject,
PublicKey: issuerCerts[0].RawSubjectPublicKeyInfo,
}, nil
}
|
[
"func",
"IssuerFromAPIRootCA",
"(",
"rootCA",
"*",
"api",
".",
"RootCA",
")",
"(",
"*",
"IssuerInfo",
",",
"error",
")",
"{",
"wantedIssuer",
":=",
"rootCA",
".",
"CACert",
"\n",
"if",
"rootCA",
".",
"RootRotation",
"!=",
"nil",
"{",
"wantedIssuer",
"=",
"rootCA",
".",
"RootRotation",
".",
"CACert",
"\n",
"}",
"\n",
"issuerCerts",
",",
"err",
":=",
"helpers",
".",
"ParseCertificatesPEM",
"(",
"wantedIssuer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"issuerCerts",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"IssuerInfo",
"{",
"Subject",
":",
"issuerCerts",
"[",
"0",
"]",
".",
"RawSubject",
",",
"PublicKey",
":",
"issuerCerts",
"[",
"0",
"]",
".",
"RawSubjectPublicKeyInfo",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// IssuerFromAPIRootCA returns the desired issuer given an API root CA object
|
[
"IssuerFromAPIRootCA",
"returns",
"the",
"desired",
"issuer",
"given",
"an",
"API",
"root",
"CA",
"object"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/reconciler.go#L50-L66
|
train
|
docker/swarmkit
|
ca/reconciler.go
|
finishRootRotation
|
func (r *rootRotationReconciler) finishRootRotation(tx store.Tx, expectedRootCA *api.RootCA) error {
cluster := store.GetCluster(tx, r.clusterID)
if cluster == nil {
return fmt.Errorf("unable to get cluster %s", r.clusterID)
}
// If the RootCA object has changed (because another root rotation was started or because some other node
// had finished the root rotation), we cannot finish the root rotation that we were working on.
if !equality.RootCAEqualStable(expectedRootCA, &cluster.RootCA) {
return errRootRotationChanged
}
var signerCert []byte
if len(cluster.RootCA.RootRotation.CAKey) > 0 {
signerCert = cluster.RootCA.RootRotation.CACert
}
// we don't actually have to parse out the default node expiration from the cluster - we are just using
// the ca.RootCA object to generate new tokens and the digest
updatedRootCA, err := NewRootCA(cluster.RootCA.RootRotation.CACert, signerCert, cluster.RootCA.RootRotation.CAKey,
DefaultNodeCertExpiration, nil)
if err != nil {
return errors.Wrap(err, "invalid cluster root rotation object")
}
cluster.RootCA = api.RootCA{
CACert: cluster.RootCA.RootRotation.CACert,
CAKey: cluster.RootCA.RootRotation.CAKey,
CACertHash: updatedRootCA.Digest.String(),
JoinTokens: api.JoinTokens{
Worker: GenerateJoinToken(&updatedRootCA, cluster.FIPS),
Manager: GenerateJoinToken(&updatedRootCA, cluster.FIPS),
},
LastForcedRotation: cluster.RootCA.LastForcedRotation,
}
return store.UpdateCluster(tx, cluster)
}
|
go
|
func (r *rootRotationReconciler) finishRootRotation(tx store.Tx, expectedRootCA *api.RootCA) error {
cluster := store.GetCluster(tx, r.clusterID)
if cluster == nil {
return fmt.Errorf("unable to get cluster %s", r.clusterID)
}
// If the RootCA object has changed (because another root rotation was started or because some other node
// had finished the root rotation), we cannot finish the root rotation that we were working on.
if !equality.RootCAEqualStable(expectedRootCA, &cluster.RootCA) {
return errRootRotationChanged
}
var signerCert []byte
if len(cluster.RootCA.RootRotation.CAKey) > 0 {
signerCert = cluster.RootCA.RootRotation.CACert
}
// we don't actually have to parse out the default node expiration from the cluster - we are just using
// the ca.RootCA object to generate new tokens and the digest
updatedRootCA, err := NewRootCA(cluster.RootCA.RootRotation.CACert, signerCert, cluster.RootCA.RootRotation.CAKey,
DefaultNodeCertExpiration, nil)
if err != nil {
return errors.Wrap(err, "invalid cluster root rotation object")
}
cluster.RootCA = api.RootCA{
CACert: cluster.RootCA.RootRotation.CACert,
CAKey: cluster.RootCA.RootRotation.CAKey,
CACertHash: updatedRootCA.Digest.String(),
JoinTokens: api.JoinTokens{
Worker: GenerateJoinToken(&updatedRootCA, cluster.FIPS),
Manager: GenerateJoinToken(&updatedRootCA, cluster.FIPS),
},
LastForcedRotation: cluster.RootCA.LastForcedRotation,
}
return store.UpdateCluster(tx, cluster)
}
|
[
"func",
"(",
"r",
"*",
"rootRotationReconciler",
")",
"finishRootRotation",
"(",
"tx",
"store",
".",
"Tx",
",",
"expectedRootCA",
"*",
"api",
".",
"RootCA",
")",
"error",
"{",
"cluster",
":=",
"store",
".",
"GetCluster",
"(",
"tx",
",",
"r",
".",
"clusterID",
")",
"\n",
"if",
"cluster",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"clusterID",
")",
"\n",
"}",
"\n\n",
"// If the RootCA object has changed (because another root rotation was started or because some other node",
"// had finished the root rotation), we cannot finish the root rotation that we were working on.",
"if",
"!",
"equality",
".",
"RootCAEqualStable",
"(",
"expectedRootCA",
",",
"&",
"cluster",
".",
"RootCA",
")",
"{",
"return",
"errRootRotationChanged",
"\n",
"}",
"\n\n",
"var",
"signerCert",
"[",
"]",
"byte",
"\n",
"if",
"len",
"(",
"cluster",
".",
"RootCA",
".",
"RootRotation",
".",
"CAKey",
")",
">",
"0",
"{",
"signerCert",
"=",
"cluster",
".",
"RootCA",
".",
"RootRotation",
".",
"CACert",
"\n",
"}",
"\n",
"// we don't actually have to parse out the default node expiration from the cluster - we are just using",
"// the ca.RootCA object to generate new tokens and the digest",
"updatedRootCA",
",",
"err",
":=",
"NewRootCA",
"(",
"cluster",
".",
"RootCA",
".",
"RootRotation",
".",
"CACert",
",",
"signerCert",
",",
"cluster",
".",
"RootCA",
".",
"RootRotation",
".",
"CAKey",
",",
"DefaultNodeCertExpiration",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"cluster",
".",
"RootCA",
"=",
"api",
".",
"RootCA",
"{",
"CACert",
":",
"cluster",
".",
"RootCA",
".",
"RootRotation",
".",
"CACert",
",",
"CAKey",
":",
"cluster",
".",
"RootCA",
".",
"RootRotation",
".",
"CAKey",
",",
"CACertHash",
":",
"updatedRootCA",
".",
"Digest",
".",
"String",
"(",
")",
",",
"JoinTokens",
":",
"api",
".",
"JoinTokens",
"{",
"Worker",
":",
"GenerateJoinToken",
"(",
"&",
"updatedRootCA",
",",
"cluster",
".",
"FIPS",
")",
",",
"Manager",
":",
"GenerateJoinToken",
"(",
"&",
"updatedRootCA",
",",
"cluster",
".",
"FIPS",
")",
",",
"}",
",",
"LastForcedRotation",
":",
"cluster",
".",
"RootCA",
".",
"LastForcedRotation",
",",
"}",
"\n",
"return",
"store",
".",
"UpdateCluster",
"(",
"tx",
",",
"cluster",
")",
"\n",
"}"
] |
// This function assumes that the expected root CA has root rotation. This is intended to be used by
// `reconcileNodeRootsAndCerts`, which uses the root CA from the `lastSeenClusterRootCA`, and checks
// that it has a root rotation before calling this function.
|
[
"This",
"function",
"assumes",
"that",
"the",
"expected",
"root",
"CA",
"has",
"root",
"rotation",
".",
"This",
"is",
"intended",
"to",
"be",
"used",
"by",
"reconcileNodeRootsAndCerts",
"which",
"uses",
"the",
"root",
"CA",
"from",
"the",
"lastSeenClusterRootCA",
"and",
"checks",
"that",
"it",
"has",
"a",
"root",
"rotation",
"before",
"calling",
"this",
"function",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/ca/reconciler.go#L204-L238
|
train
|
docker/swarmkit
|
agent/dependency.go
|
NewDependencyManager
|
func NewDependencyManager() exec.DependencyManager {
return &dependencyManager{
secrets: secrets.NewManager(),
configs: configs.NewManager(),
}
}
|
go
|
func NewDependencyManager() exec.DependencyManager {
return &dependencyManager{
secrets: secrets.NewManager(),
configs: configs.NewManager(),
}
}
|
[
"func",
"NewDependencyManager",
"(",
")",
"exec",
".",
"DependencyManager",
"{",
"return",
"&",
"dependencyManager",
"{",
"secrets",
":",
"secrets",
".",
"NewManager",
"(",
")",
",",
"configs",
":",
"configs",
".",
"NewManager",
"(",
")",
",",
"}",
"\n",
"}"
] |
// NewDependencyManager creates a dependency manager object that wraps
// objects which provide access to various dependency types.
|
[
"NewDependencyManager",
"creates",
"a",
"dependency",
"manager",
"object",
"that",
"wraps",
"objects",
"which",
"provide",
"access",
"to",
"various",
"dependency",
"types",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/dependency.go#L17-L22
|
train
|
docker/swarmkit
|
agent/dependency.go
|
Restrict
|
func Restrict(dependencies exec.DependencyManager, t *api.Task) exec.DependencyGetter {
return &dependencyGetter{
secrets: secrets.Restrict(dependencies.Secrets(), t),
configs: configs.Restrict(dependencies.Configs(), t),
}
}
|
go
|
func Restrict(dependencies exec.DependencyManager, t *api.Task) exec.DependencyGetter {
return &dependencyGetter{
secrets: secrets.Restrict(dependencies.Secrets(), t),
configs: configs.Restrict(dependencies.Configs(), t),
}
}
|
[
"func",
"Restrict",
"(",
"dependencies",
"exec",
".",
"DependencyManager",
",",
"t",
"*",
"api",
".",
"Task",
")",
"exec",
".",
"DependencyGetter",
"{",
"return",
"&",
"dependencyGetter",
"{",
"secrets",
":",
"secrets",
".",
"Restrict",
"(",
"dependencies",
".",
"Secrets",
"(",
")",
",",
"t",
")",
",",
"configs",
":",
"configs",
".",
"Restrict",
"(",
"dependencies",
".",
"Configs",
"(",
")",
",",
"t",
")",
",",
"}",
"\n",
"}"
] |
// Restrict provides getters that only allows access to the dependencies
// referenced by the task.
|
[
"Restrict",
"provides",
"getters",
"that",
"only",
"allows",
"access",
"to",
"the",
"dependencies",
"referenced",
"by",
"the",
"task",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/agent/dependency.go#L47-L52
|
train
|
docker/swarmkit
|
manager/scheduler/scheduler.go
|
New
|
func New(store *store.MemoryStore) *Scheduler {
return &Scheduler{
store: store,
unassignedTasks: make(map[string]*api.Task),
pendingPreassignedTasks: make(map[string]*api.Task),
preassignedTasks: make(map[string]struct{}),
allTasks: make(map[string]*api.Task),
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
pipeline: NewPipeline(),
}
}
|
go
|
func New(store *store.MemoryStore) *Scheduler {
return &Scheduler{
store: store,
unassignedTasks: make(map[string]*api.Task),
pendingPreassignedTasks: make(map[string]*api.Task),
preassignedTasks: make(map[string]struct{}),
allTasks: make(map[string]*api.Task),
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
pipeline: NewPipeline(),
}
}
|
[
"func",
"New",
"(",
"store",
"*",
"store",
".",
"MemoryStore",
")",
"*",
"Scheduler",
"{",
"return",
"&",
"Scheduler",
"{",
"store",
":",
"store",
",",
"unassignedTasks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Task",
")",
",",
"pendingPreassignedTasks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Task",
")",
",",
"preassignedTasks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
",",
"allTasks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Task",
")",
",",
"stopChan",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"doneChan",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"pipeline",
":",
"NewPipeline",
"(",
")",
",",
"}",
"\n",
"}"
] |
// New creates a new scheduler.
|
[
"New",
"creates",
"a",
"new",
"scheduler",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/scheduler/scheduler.go#L50-L61
|
train
|
docker/swarmkit
|
manager/scheduler/scheduler.go
|
Run
|
func (s *Scheduler) Run(ctx context.Context) error {
defer close(s.doneChan)
updates, cancel, err := store.ViewAndWatch(s.store, s.setupTasksList)
if err != nil {
log.G(ctx).WithError(err).Errorf("snapshot store update failed")
return err
}
defer cancel()
// Validate resource for tasks from preassigned tasks
// do this before other tasks because preassigned tasks like
// global service should start before other tasks
s.processPreassignedTasks(ctx)
// Queue all unassigned tasks before processing changes.
s.tick(ctx)
const (
// commitDebounceGap is the amount of time to wait between
// commit events to debounce them.
commitDebounceGap = 50 * time.Millisecond
// maxLatency is a time limit on the debouncing.
maxLatency = time.Second
)
var (
debouncingStarted time.Time
commitDebounceTimer *time.Timer
commitDebounceTimeout <-chan time.Time
)
tickRequired := false
schedule := func() {
if len(s.pendingPreassignedTasks) > 0 {
s.processPreassignedTasks(ctx)
}
if tickRequired {
s.tick(ctx)
tickRequired = false
}
}
// Watch for changes.
for {
select {
case event := <-updates:
switch v := event.(type) {
case api.EventCreateTask:
if s.createTask(ctx, v.Task) {
tickRequired = true
}
case api.EventUpdateTask:
if s.updateTask(ctx, v.Task) {
tickRequired = true
}
case api.EventDeleteTask:
if s.deleteTask(v.Task) {
// deleting tasks may free up node resource, pending tasks should be re-evaluated.
tickRequired = true
}
case api.EventCreateNode:
s.createOrUpdateNode(v.Node)
tickRequired = true
case api.EventUpdateNode:
s.createOrUpdateNode(v.Node)
tickRequired = true
case api.EventDeleteNode:
s.nodeSet.remove(v.Node.ID)
case state.EventCommit:
if commitDebounceTimer != nil {
if time.Since(debouncingStarted) > maxLatency {
commitDebounceTimer.Stop()
commitDebounceTimer = nil
commitDebounceTimeout = nil
schedule()
} else {
commitDebounceTimer.Reset(commitDebounceGap)
}
} else {
commitDebounceTimer = time.NewTimer(commitDebounceGap)
commitDebounceTimeout = commitDebounceTimer.C
debouncingStarted = time.Now()
}
}
case <-commitDebounceTimeout:
schedule()
commitDebounceTimer = nil
commitDebounceTimeout = nil
case <-s.stopChan:
return nil
}
}
}
|
go
|
func (s *Scheduler) Run(ctx context.Context) error {
defer close(s.doneChan)
updates, cancel, err := store.ViewAndWatch(s.store, s.setupTasksList)
if err != nil {
log.G(ctx).WithError(err).Errorf("snapshot store update failed")
return err
}
defer cancel()
// Validate resource for tasks from preassigned tasks
// do this before other tasks because preassigned tasks like
// global service should start before other tasks
s.processPreassignedTasks(ctx)
// Queue all unassigned tasks before processing changes.
s.tick(ctx)
const (
// commitDebounceGap is the amount of time to wait between
// commit events to debounce them.
commitDebounceGap = 50 * time.Millisecond
// maxLatency is a time limit on the debouncing.
maxLatency = time.Second
)
var (
debouncingStarted time.Time
commitDebounceTimer *time.Timer
commitDebounceTimeout <-chan time.Time
)
tickRequired := false
schedule := func() {
if len(s.pendingPreassignedTasks) > 0 {
s.processPreassignedTasks(ctx)
}
if tickRequired {
s.tick(ctx)
tickRequired = false
}
}
// Watch for changes.
for {
select {
case event := <-updates:
switch v := event.(type) {
case api.EventCreateTask:
if s.createTask(ctx, v.Task) {
tickRequired = true
}
case api.EventUpdateTask:
if s.updateTask(ctx, v.Task) {
tickRequired = true
}
case api.EventDeleteTask:
if s.deleteTask(v.Task) {
// deleting tasks may free up node resource, pending tasks should be re-evaluated.
tickRequired = true
}
case api.EventCreateNode:
s.createOrUpdateNode(v.Node)
tickRequired = true
case api.EventUpdateNode:
s.createOrUpdateNode(v.Node)
tickRequired = true
case api.EventDeleteNode:
s.nodeSet.remove(v.Node.ID)
case state.EventCommit:
if commitDebounceTimer != nil {
if time.Since(debouncingStarted) > maxLatency {
commitDebounceTimer.Stop()
commitDebounceTimer = nil
commitDebounceTimeout = nil
schedule()
} else {
commitDebounceTimer.Reset(commitDebounceGap)
}
} else {
commitDebounceTimer = time.NewTimer(commitDebounceGap)
commitDebounceTimeout = commitDebounceTimer.C
debouncingStarted = time.Now()
}
}
case <-commitDebounceTimeout:
schedule()
commitDebounceTimer = nil
commitDebounceTimeout = nil
case <-s.stopChan:
return nil
}
}
}
|
[
"func",
"(",
"s",
"*",
"Scheduler",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"defer",
"close",
"(",
"s",
".",
"doneChan",
")",
"\n\n",
"updates",
",",
"cancel",
",",
"err",
":=",
"store",
".",
"ViewAndWatch",
"(",
"s",
".",
"store",
",",
"s",
".",
"setupTasksList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"G",
"(",
"ctx",
")",
".",
"WithError",
"(",
"err",
")",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"// Validate resource for tasks from preassigned tasks",
"// do this before other tasks because preassigned tasks like",
"// global service should start before other tasks",
"s",
".",
"processPreassignedTasks",
"(",
"ctx",
")",
"\n\n",
"// Queue all unassigned tasks before processing changes.",
"s",
".",
"tick",
"(",
"ctx",
")",
"\n\n",
"const",
"(",
"// commitDebounceGap is the amount of time to wait between",
"// commit events to debounce them.",
"commitDebounceGap",
"=",
"50",
"*",
"time",
".",
"Millisecond",
"\n",
"// maxLatency is a time limit on the debouncing.",
"maxLatency",
"=",
"time",
".",
"Second",
"\n",
")",
"\n",
"var",
"(",
"debouncingStarted",
"time",
".",
"Time",
"\n",
"commitDebounceTimer",
"*",
"time",
".",
"Timer",
"\n",
"commitDebounceTimeout",
"<-",
"chan",
"time",
".",
"Time",
"\n",
")",
"\n\n",
"tickRequired",
":=",
"false",
"\n\n",
"schedule",
":=",
"func",
"(",
")",
"{",
"if",
"len",
"(",
"s",
".",
"pendingPreassignedTasks",
")",
">",
"0",
"{",
"s",
".",
"processPreassignedTasks",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"if",
"tickRequired",
"{",
"s",
".",
"tick",
"(",
"ctx",
")",
"\n",
"tickRequired",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Watch for changes.",
"for",
"{",
"select",
"{",
"case",
"event",
":=",
"<-",
"updates",
":",
"switch",
"v",
":=",
"event",
".",
"(",
"type",
")",
"{",
"case",
"api",
".",
"EventCreateTask",
":",
"if",
"s",
".",
"createTask",
"(",
"ctx",
",",
"v",
".",
"Task",
")",
"{",
"tickRequired",
"=",
"true",
"\n",
"}",
"\n",
"case",
"api",
".",
"EventUpdateTask",
":",
"if",
"s",
".",
"updateTask",
"(",
"ctx",
",",
"v",
".",
"Task",
")",
"{",
"tickRequired",
"=",
"true",
"\n",
"}",
"\n",
"case",
"api",
".",
"EventDeleteTask",
":",
"if",
"s",
".",
"deleteTask",
"(",
"v",
".",
"Task",
")",
"{",
"// deleting tasks may free up node resource, pending tasks should be re-evaluated.",
"tickRequired",
"=",
"true",
"\n",
"}",
"\n",
"case",
"api",
".",
"EventCreateNode",
":",
"s",
".",
"createOrUpdateNode",
"(",
"v",
".",
"Node",
")",
"\n",
"tickRequired",
"=",
"true",
"\n",
"case",
"api",
".",
"EventUpdateNode",
":",
"s",
".",
"createOrUpdateNode",
"(",
"v",
".",
"Node",
")",
"\n",
"tickRequired",
"=",
"true",
"\n",
"case",
"api",
".",
"EventDeleteNode",
":",
"s",
".",
"nodeSet",
".",
"remove",
"(",
"v",
".",
"Node",
".",
"ID",
")",
"\n",
"case",
"state",
".",
"EventCommit",
":",
"if",
"commitDebounceTimer",
"!=",
"nil",
"{",
"if",
"time",
".",
"Since",
"(",
"debouncingStarted",
")",
">",
"maxLatency",
"{",
"commitDebounceTimer",
".",
"Stop",
"(",
")",
"\n",
"commitDebounceTimer",
"=",
"nil",
"\n",
"commitDebounceTimeout",
"=",
"nil",
"\n",
"schedule",
"(",
")",
"\n",
"}",
"else",
"{",
"commitDebounceTimer",
".",
"Reset",
"(",
"commitDebounceGap",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"commitDebounceTimer",
"=",
"time",
".",
"NewTimer",
"(",
"commitDebounceGap",
")",
"\n",
"commitDebounceTimeout",
"=",
"commitDebounceTimer",
".",
"C",
"\n",
"debouncingStarted",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"<-",
"commitDebounceTimeout",
":",
"schedule",
"(",
")",
"\n",
"commitDebounceTimer",
"=",
"nil",
"\n",
"commitDebounceTimeout",
"=",
"nil",
"\n",
"case",
"<-",
"s",
".",
"stopChan",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Run is the scheduler event loop.
|
[
"Run",
"is",
"the",
"scheduler",
"event",
"loop",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/scheduler/scheduler.go#L105-L198
|
train
|
docker/swarmkit
|
manager/scheduler/scheduler.go
|
enqueue
|
func (s *Scheduler) enqueue(t *api.Task) {
s.unassignedTasks[t.ID] = t
}
|
go
|
func (s *Scheduler) enqueue(t *api.Task) {
s.unassignedTasks[t.ID] = t
}
|
[
"func",
"(",
"s",
"*",
"Scheduler",
")",
"enqueue",
"(",
"t",
"*",
"api",
".",
"Task",
")",
"{",
"s",
".",
"unassignedTasks",
"[",
"t",
".",
"ID",
"]",
"=",
"t",
"\n",
"}"
] |
// enqueue queues a task for scheduling.
|
[
"enqueue",
"queues",
"a",
"task",
"for",
"scheduling",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/scheduler/scheduler.go#L207-L209
|
train
|
docker/swarmkit
|
manager/scheduler/scheduler.go
|
tick
|
func (s *Scheduler) tick(ctx context.Context) {
type commonSpecKey struct {
serviceID string
specVersion api.Version
}
tasksByCommonSpec := make(map[commonSpecKey]map[string]*api.Task)
var oneOffTasks []*api.Task
schedulingDecisions := make(map[string]schedulingDecision, len(s.unassignedTasks))
for taskID, t := range s.unassignedTasks {
if t == nil || t.NodeID != "" {
// task deleted or already assigned
delete(s.unassignedTasks, taskID)
continue
}
// Group tasks with common specs
if t.SpecVersion != nil {
taskGroupKey := commonSpecKey{
serviceID: t.ServiceID,
specVersion: *t.SpecVersion,
}
if tasksByCommonSpec[taskGroupKey] == nil {
tasksByCommonSpec[taskGroupKey] = make(map[string]*api.Task)
}
tasksByCommonSpec[taskGroupKey][taskID] = t
} else {
// This task doesn't have a spec version. We have to
// schedule it as a one-off.
oneOffTasks = append(oneOffTasks, t)
}
delete(s.unassignedTasks, taskID)
}
for _, taskGroup := range tasksByCommonSpec {
s.scheduleTaskGroup(ctx, taskGroup, schedulingDecisions)
}
for _, t := range oneOffTasks {
s.scheduleTaskGroup(ctx, map[string]*api.Task{t.ID: t}, schedulingDecisions)
}
_, failed := s.applySchedulingDecisions(ctx, schedulingDecisions)
for _, decision := range failed {
s.allTasks[decision.old.ID] = decision.old
nodeInfo, err := s.nodeSet.nodeInfo(decision.new.NodeID)
if err == nil && nodeInfo.removeTask(decision.new) {
s.nodeSet.updateNode(nodeInfo)
}
// enqueue task for next scheduling attempt
s.enqueue(decision.old)
}
}
|
go
|
func (s *Scheduler) tick(ctx context.Context) {
type commonSpecKey struct {
serviceID string
specVersion api.Version
}
tasksByCommonSpec := make(map[commonSpecKey]map[string]*api.Task)
var oneOffTasks []*api.Task
schedulingDecisions := make(map[string]schedulingDecision, len(s.unassignedTasks))
for taskID, t := range s.unassignedTasks {
if t == nil || t.NodeID != "" {
// task deleted or already assigned
delete(s.unassignedTasks, taskID)
continue
}
// Group tasks with common specs
if t.SpecVersion != nil {
taskGroupKey := commonSpecKey{
serviceID: t.ServiceID,
specVersion: *t.SpecVersion,
}
if tasksByCommonSpec[taskGroupKey] == nil {
tasksByCommonSpec[taskGroupKey] = make(map[string]*api.Task)
}
tasksByCommonSpec[taskGroupKey][taskID] = t
} else {
// This task doesn't have a spec version. We have to
// schedule it as a one-off.
oneOffTasks = append(oneOffTasks, t)
}
delete(s.unassignedTasks, taskID)
}
for _, taskGroup := range tasksByCommonSpec {
s.scheduleTaskGroup(ctx, taskGroup, schedulingDecisions)
}
for _, t := range oneOffTasks {
s.scheduleTaskGroup(ctx, map[string]*api.Task{t.ID: t}, schedulingDecisions)
}
_, failed := s.applySchedulingDecisions(ctx, schedulingDecisions)
for _, decision := range failed {
s.allTasks[decision.old.ID] = decision.old
nodeInfo, err := s.nodeSet.nodeInfo(decision.new.NodeID)
if err == nil && nodeInfo.removeTask(decision.new) {
s.nodeSet.updateNode(nodeInfo)
}
// enqueue task for next scheduling attempt
s.enqueue(decision.old)
}
}
|
[
"func",
"(",
"s",
"*",
"Scheduler",
")",
"tick",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"type",
"commonSpecKey",
"struct",
"{",
"serviceID",
"string",
"\n",
"specVersion",
"api",
".",
"Version",
"\n",
"}",
"\n",
"tasksByCommonSpec",
":=",
"make",
"(",
"map",
"[",
"commonSpecKey",
"]",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Task",
")",
"\n",
"var",
"oneOffTasks",
"[",
"]",
"*",
"api",
".",
"Task",
"\n",
"schedulingDecisions",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"schedulingDecision",
",",
"len",
"(",
"s",
".",
"unassignedTasks",
")",
")",
"\n\n",
"for",
"taskID",
",",
"t",
":=",
"range",
"s",
".",
"unassignedTasks",
"{",
"if",
"t",
"==",
"nil",
"||",
"t",
".",
"NodeID",
"!=",
"\"",
"\"",
"{",
"// task deleted or already assigned",
"delete",
"(",
"s",
".",
"unassignedTasks",
",",
"taskID",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// Group tasks with common specs",
"if",
"t",
".",
"SpecVersion",
"!=",
"nil",
"{",
"taskGroupKey",
":=",
"commonSpecKey",
"{",
"serviceID",
":",
"t",
".",
"ServiceID",
",",
"specVersion",
":",
"*",
"t",
".",
"SpecVersion",
",",
"}",
"\n\n",
"if",
"tasksByCommonSpec",
"[",
"taskGroupKey",
"]",
"==",
"nil",
"{",
"tasksByCommonSpec",
"[",
"taskGroupKey",
"]",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Task",
")",
"\n",
"}",
"\n",
"tasksByCommonSpec",
"[",
"taskGroupKey",
"]",
"[",
"taskID",
"]",
"=",
"t",
"\n",
"}",
"else",
"{",
"// This task doesn't have a spec version. We have to",
"// schedule it as a one-off.",
"oneOffTasks",
"=",
"append",
"(",
"oneOffTasks",
",",
"t",
")",
"\n",
"}",
"\n",
"delete",
"(",
"s",
".",
"unassignedTasks",
",",
"taskID",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"taskGroup",
":=",
"range",
"tasksByCommonSpec",
"{",
"s",
".",
"scheduleTaskGroup",
"(",
"ctx",
",",
"taskGroup",
",",
"schedulingDecisions",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"oneOffTasks",
"{",
"s",
".",
"scheduleTaskGroup",
"(",
"ctx",
",",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Task",
"{",
"t",
".",
"ID",
":",
"t",
"}",
",",
"schedulingDecisions",
")",
"\n",
"}",
"\n\n",
"_",
",",
"failed",
":=",
"s",
".",
"applySchedulingDecisions",
"(",
"ctx",
",",
"schedulingDecisions",
")",
"\n",
"for",
"_",
",",
"decision",
":=",
"range",
"failed",
"{",
"s",
".",
"allTasks",
"[",
"decision",
".",
"old",
".",
"ID",
"]",
"=",
"decision",
".",
"old",
"\n\n",
"nodeInfo",
",",
"err",
":=",
"s",
".",
"nodeSet",
".",
"nodeInfo",
"(",
"decision",
".",
"new",
".",
"NodeID",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"nodeInfo",
".",
"removeTask",
"(",
"decision",
".",
"new",
")",
"{",
"s",
".",
"nodeSet",
".",
"updateNode",
"(",
"nodeInfo",
")",
"\n",
"}",
"\n\n",
"// enqueue task for next scheduling attempt",
"s",
".",
"enqueue",
"(",
"decision",
".",
"old",
")",
"\n",
"}",
"\n",
"}"
] |
// tick attempts to schedule the queue.
|
[
"tick",
"attempts",
"to",
"schedule",
"the",
"queue",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/scheduler/scheduler.go#L376-L430
|
train
|
docker/swarmkit
|
manager/scheduler/scheduler.go
|
taskFitNode
|
func (s *Scheduler) taskFitNode(ctx context.Context, t *api.Task, nodeID string) *api.Task {
nodeInfo, err := s.nodeSet.nodeInfo(nodeID)
if err != nil {
// node does not exist in set (it may have been deleted)
return nil
}
newT := *t
s.pipeline.SetTask(t)
if !s.pipeline.Process(&nodeInfo) {
// this node cannot accommodate this task
newT.Status.Timestamp = ptypes.MustTimestampProto(time.Now())
newT.Status.Err = s.pipeline.Explain()
s.allTasks[t.ID] = &newT
return &newT
}
newT.Status = api.TaskStatus{
State: api.TaskStateAssigned,
Timestamp: ptypes.MustTimestampProto(time.Now()),
Message: "scheduler confirmed task can run on preassigned node",
}
s.allTasks[t.ID] = &newT
if nodeInfo.addTask(&newT) {
s.nodeSet.updateNode(nodeInfo)
}
return &newT
}
|
go
|
func (s *Scheduler) taskFitNode(ctx context.Context, t *api.Task, nodeID string) *api.Task {
nodeInfo, err := s.nodeSet.nodeInfo(nodeID)
if err != nil {
// node does not exist in set (it may have been deleted)
return nil
}
newT := *t
s.pipeline.SetTask(t)
if !s.pipeline.Process(&nodeInfo) {
// this node cannot accommodate this task
newT.Status.Timestamp = ptypes.MustTimestampProto(time.Now())
newT.Status.Err = s.pipeline.Explain()
s.allTasks[t.ID] = &newT
return &newT
}
newT.Status = api.TaskStatus{
State: api.TaskStateAssigned,
Timestamp: ptypes.MustTimestampProto(time.Now()),
Message: "scheduler confirmed task can run on preassigned node",
}
s.allTasks[t.ID] = &newT
if nodeInfo.addTask(&newT) {
s.nodeSet.updateNode(nodeInfo)
}
return &newT
}
|
[
"func",
"(",
"s",
"*",
"Scheduler",
")",
"taskFitNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"t",
"*",
"api",
".",
"Task",
",",
"nodeID",
"string",
")",
"*",
"api",
".",
"Task",
"{",
"nodeInfo",
",",
"err",
":=",
"s",
".",
"nodeSet",
".",
"nodeInfo",
"(",
"nodeID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// node does not exist in set (it may have been deleted)",
"return",
"nil",
"\n",
"}",
"\n",
"newT",
":=",
"*",
"t",
"\n",
"s",
".",
"pipeline",
".",
"SetTask",
"(",
"t",
")",
"\n",
"if",
"!",
"s",
".",
"pipeline",
".",
"Process",
"(",
"&",
"nodeInfo",
")",
"{",
"// this node cannot accommodate this task",
"newT",
".",
"Status",
".",
"Timestamp",
"=",
"ptypes",
".",
"MustTimestampProto",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"newT",
".",
"Status",
".",
"Err",
"=",
"s",
".",
"pipeline",
".",
"Explain",
"(",
")",
"\n",
"s",
".",
"allTasks",
"[",
"t",
".",
"ID",
"]",
"=",
"&",
"newT",
"\n\n",
"return",
"&",
"newT",
"\n",
"}",
"\n",
"newT",
".",
"Status",
"=",
"api",
".",
"TaskStatus",
"{",
"State",
":",
"api",
".",
"TaskStateAssigned",
",",
"Timestamp",
":",
"ptypes",
".",
"MustTimestampProto",
"(",
"time",
".",
"Now",
"(",
")",
")",
",",
"Message",
":",
"\"",
"\"",
",",
"}",
"\n",
"s",
".",
"allTasks",
"[",
"t",
".",
"ID",
"]",
"=",
"&",
"newT",
"\n\n",
"if",
"nodeInfo",
".",
"addTask",
"(",
"&",
"newT",
")",
"{",
"s",
".",
"nodeSet",
".",
"updateNode",
"(",
"nodeInfo",
")",
"\n",
"}",
"\n",
"return",
"&",
"newT",
"\n",
"}"
] |
// taskFitNode checks if a node has enough resources to accommodate a task.
|
[
"taskFitNode",
"checks",
"if",
"a",
"node",
"has",
"enough",
"resources",
"to",
"accommodate",
"a",
"task",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/scheduler/scheduler.go#L502-L529
|
train
|
docker/swarmkit
|
manager/scheduler/scheduler.go
|
scheduleTaskGroup
|
func (s *Scheduler) scheduleTaskGroup(ctx context.Context, taskGroup map[string]*api.Task, schedulingDecisions map[string]schedulingDecision) {
// Pick at task at random from taskGroup to use for constraint
// evaluation. It doesn't matter which one we pick because all the
// tasks in the group are equal in terms of the fields the constraint
// filters consider.
var t *api.Task
for _, t = range taskGroup {
break
}
s.pipeline.SetTask(t)
now := time.Now()
nodeLess := func(a *NodeInfo, b *NodeInfo) bool {
// If either node has at least maxFailures recent failures,
// that's the deciding factor.
recentFailuresA := a.countRecentFailures(now, t)
recentFailuresB := b.countRecentFailures(now, t)
if recentFailuresA >= maxFailures || recentFailuresB >= maxFailures {
if recentFailuresA > recentFailuresB {
return false
}
if recentFailuresB > recentFailuresA {
return true
}
}
tasksByServiceA := a.ActiveTasksCountByService[t.ServiceID]
tasksByServiceB := b.ActiveTasksCountByService[t.ServiceID]
if tasksByServiceA < tasksByServiceB {
return true
}
if tasksByServiceA > tasksByServiceB {
return false
}
// Total number of tasks breaks ties.
return a.ActiveTasksCount < b.ActiveTasksCount
}
var prefs []*api.PlacementPreference
if t.Spec.Placement != nil {
prefs = t.Spec.Placement.Preferences
}
tree := s.nodeSet.tree(t.ServiceID, prefs, len(taskGroup), s.pipeline.Process, nodeLess)
s.scheduleNTasksOnSubtree(ctx, len(taskGroup), taskGroup, &tree, schedulingDecisions, nodeLess)
if len(taskGroup) != 0 {
s.noSuitableNode(ctx, taskGroup, schedulingDecisions)
}
}
|
go
|
func (s *Scheduler) scheduleTaskGroup(ctx context.Context, taskGroup map[string]*api.Task, schedulingDecisions map[string]schedulingDecision) {
// Pick at task at random from taskGroup to use for constraint
// evaluation. It doesn't matter which one we pick because all the
// tasks in the group are equal in terms of the fields the constraint
// filters consider.
var t *api.Task
for _, t = range taskGroup {
break
}
s.pipeline.SetTask(t)
now := time.Now()
nodeLess := func(a *NodeInfo, b *NodeInfo) bool {
// If either node has at least maxFailures recent failures,
// that's the deciding factor.
recentFailuresA := a.countRecentFailures(now, t)
recentFailuresB := b.countRecentFailures(now, t)
if recentFailuresA >= maxFailures || recentFailuresB >= maxFailures {
if recentFailuresA > recentFailuresB {
return false
}
if recentFailuresB > recentFailuresA {
return true
}
}
tasksByServiceA := a.ActiveTasksCountByService[t.ServiceID]
tasksByServiceB := b.ActiveTasksCountByService[t.ServiceID]
if tasksByServiceA < tasksByServiceB {
return true
}
if tasksByServiceA > tasksByServiceB {
return false
}
// Total number of tasks breaks ties.
return a.ActiveTasksCount < b.ActiveTasksCount
}
var prefs []*api.PlacementPreference
if t.Spec.Placement != nil {
prefs = t.Spec.Placement.Preferences
}
tree := s.nodeSet.tree(t.ServiceID, prefs, len(taskGroup), s.pipeline.Process, nodeLess)
s.scheduleNTasksOnSubtree(ctx, len(taskGroup), taskGroup, &tree, schedulingDecisions, nodeLess)
if len(taskGroup) != 0 {
s.noSuitableNode(ctx, taskGroup, schedulingDecisions)
}
}
|
[
"func",
"(",
"s",
"*",
"Scheduler",
")",
"scheduleTaskGroup",
"(",
"ctx",
"context",
".",
"Context",
",",
"taskGroup",
"map",
"[",
"string",
"]",
"*",
"api",
".",
"Task",
",",
"schedulingDecisions",
"map",
"[",
"string",
"]",
"schedulingDecision",
")",
"{",
"// Pick at task at random from taskGroup to use for constraint",
"// evaluation. It doesn't matter which one we pick because all the",
"// tasks in the group are equal in terms of the fields the constraint",
"// filters consider.",
"var",
"t",
"*",
"api",
".",
"Task",
"\n",
"for",
"_",
",",
"t",
"=",
"range",
"taskGroup",
"{",
"break",
"\n",
"}",
"\n\n",
"s",
".",
"pipeline",
".",
"SetTask",
"(",
"t",
")",
"\n\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"nodeLess",
":=",
"func",
"(",
"a",
"*",
"NodeInfo",
",",
"b",
"*",
"NodeInfo",
")",
"bool",
"{",
"// If either node has at least maxFailures recent failures,",
"// that's the deciding factor.",
"recentFailuresA",
":=",
"a",
".",
"countRecentFailures",
"(",
"now",
",",
"t",
")",
"\n",
"recentFailuresB",
":=",
"b",
".",
"countRecentFailures",
"(",
"now",
",",
"t",
")",
"\n\n",
"if",
"recentFailuresA",
">=",
"maxFailures",
"||",
"recentFailuresB",
">=",
"maxFailures",
"{",
"if",
"recentFailuresA",
">",
"recentFailuresB",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"recentFailuresB",
">",
"recentFailuresA",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"tasksByServiceA",
":=",
"a",
".",
"ActiveTasksCountByService",
"[",
"t",
".",
"ServiceID",
"]",
"\n",
"tasksByServiceB",
":=",
"b",
".",
"ActiveTasksCountByService",
"[",
"t",
".",
"ServiceID",
"]",
"\n\n",
"if",
"tasksByServiceA",
"<",
"tasksByServiceB",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"tasksByServiceA",
">",
"tasksByServiceB",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// Total number of tasks breaks ties.",
"return",
"a",
".",
"ActiveTasksCount",
"<",
"b",
".",
"ActiveTasksCount",
"\n",
"}",
"\n\n",
"var",
"prefs",
"[",
"]",
"*",
"api",
".",
"PlacementPreference",
"\n",
"if",
"t",
".",
"Spec",
".",
"Placement",
"!=",
"nil",
"{",
"prefs",
"=",
"t",
".",
"Spec",
".",
"Placement",
".",
"Preferences",
"\n",
"}",
"\n\n",
"tree",
":=",
"s",
".",
"nodeSet",
".",
"tree",
"(",
"t",
".",
"ServiceID",
",",
"prefs",
",",
"len",
"(",
"taskGroup",
")",
",",
"s",
".",
"pipeline",
".",
"Process",
",",
"nodeLess",
")",
"\n\n",
"s",
".",
"scheduleNTasksOnSubtree",
"(",
"ctx",
",",
"len",
"(",
"taskGroup",
")",
",",
"taskGroup",
",",
"&",
"tree",
",",
"schedulingDecisions",
",",
"nodeLess",
")",
"\n",
"if",
"len",
"(",
"taskGroup",
")",
"!=",
"0",
"{",
"s",
".",
"noSuitableNode",
"(",
"ctx",
",",
"taskGroup",
",",
"schedulingDecisions",
")",
"\n",
"}",
"\n",
"}"
] |
// scheduleTaskGroup schedules a batch of tasks that are part of the same
// service and share the same version of the spec.
|
[
"scheduleTaskGroup",
"schedules",
"a",
"batch",
"of",
"tasks",
"that",
"are",
"part",
"of",
"the",
"same",
"service",
"and",
"share",
"the",
"same",
"version",
"of",
"the",
"spec",
"."
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/scheduler/scheduler.go#L533-L587
|
train
|
docker/swarmkit
|
manager/state/raft/storage/snapwrap.go
|
NewSnapFactory
|
func NewSnapFactory(encrypter encryption.Encrypter, decrypter encryption.Decrypter) SnapFactory {
return snapCryptor{
encrypter: encrypter,
decrypter: decrypter,
}
}
|
go
|
func NewSnapFactory(encrypter encryption.Encrypter, decrypter encryption.Decrypter) SnapFactory {
return snapCryptor{
encrypter: encrypter,
decrypter: decrypter,
}
}
|
[
"func",
"NewSnapFactory",
"(",
"encrypter",
"encryption",
".",
"Encrypter",
",",
"decrypter",
"encryption",
".",
"Decrypter",
")",
"SnapFactory",
"{",
"return",
"snapCryptor",
"{",
"encrypter",
":",
"encrypter",
",",
"decrypter",
":",
"decrypter",
",",
"}",
"\n",
"}"
] |
// NewSnapFactory returns a new object that can read from and write to encrypted
// snapshots on disk
|
[
"NewSnapFactory",
"returns",
"a",
"new",
"object",
"that",
"can",
"read",
"from",
"and",
"write",
"to",
"encrypted",
"snapshots",
"on",
"disk"
] |
59163bf75df38489d4a10392265d27156dc473c5
|
https://github.com/docker/swarmkit/blob/59163bf75df38489d4a10392265d27156dc473c5/manager/state/raft/storage/snapwrap.go#L81-L86
|
train
|
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.