repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
siddontang/ledisdb | ledis/t_hash.go | HGetAll | func (db *DB) HGetAll(key []byte) ([]FVPair, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.hEncodeStartKey(key)
stop := db.hEncodeStopKey(key)
v := make([]FVPair, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Valid(); it.Next() {
_, f, err := db.hDecodeHashKey(it.Key())
if err != nil {
return nil, err
}
v = append(v, FVPair{Field: f, Value: it.Value()})
}
return v, nil
} | go | func (db *DB) HGetAll(key []byte) ([]FVPair, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.hEncodeStartKey(key)
stop := db.hEncodeStopKey(key)
v := make([]FVPair, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Valid(); it.Next() {
_, f, err := db.hDecodeHashKey(it.Key())
if err != nil {
return nil, err
}
v = append(v, FVPair{Field: f, Value: it.Value()})
}
return v, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HGetAll",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"FVPair",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"... | // HGetAll returns all field-values. | [
"HGetAll",
"returns",
"all",
"field",
"-",
"values",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L378-L401 | train |
siddontang/ledisdb | ledis/t_hash.go | HClear | func (db *DB) HClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
num := db.hDelete(t, key)
db.rmExpire(t, HashType, key)
err := t.Commit()
return num, err
} | go | func (db *DB) HClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
num := db.hDelete(t, key)
db.rmExpire(t, HashType, key)
err := t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n"... | // HClear clears the data. | [
"HClear",
"clears",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L455-L469 | train |
siddontang/ledisdb | ledis/t_hash.go | HMclear | func (db *DB) HMclear(keys ...[]byte) (int64, error) {
t := db.hashBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.hDelete(t, key)
db.rmExpire(t, HashType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) HMclear(keys ...[]byte) (int64, error) {
t := db.hashBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.hDelete(t, key)
db.rmExpire(t, HashType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
... | // HMclear cleans multi data. | [
"HMclear",
"cleans",
"multi",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L472-L488 | train |
siddontang/ledisdb | ledis/t_hash.go | HExpire | func (db *DB) HExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.hExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) HExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.hExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n",
"return",
"d... | // HExpire expires the data with duration. | [
"HExpire",
"expires",
"the",
"data",
"with",
"duration",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L500-L506 | train |
siddontang/ledisdb | ledis/t_hash.go | HExpireAt | func (db *DB) HExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.hExpireAt(key, when)
} | go | func (db *DB) HExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.hExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
... | // HExpireAt expires the data at time when. | [
"HExpireAt",
"expires",
"the",
"data",
"at",
"time",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L509-L515 | train |
siddontang/ledisdb | ledis/t_hash.go | HTTL | func (db *DB) HTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(HashType, key)
} | go | func (db *DB) HTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(HashType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HTTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
... | // HTTL gets the TTL of data. | [
"HTTL",
"gets",
"the",
"TTL",
"of",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L518-L524 | train |
siddontang/ledisdb | ledis/t_hash.go | HPersist | func (db *DB) HPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, HashType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) HPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, HashType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\... | // HPersist removes the TTL of data. | [
"HPersist",
"removes",
"the",
"TTL",
"of",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L527-L543 | train |
siddontang/ledisdb | ledis/t_hash.go | HKeyExists | func (db *DB) HKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.hEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) HKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.hEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HKeyExists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
... | // HKeyExists checks whether data exists or not. | [
"HKeyExists",
"checks",
"whether",
"data",
"exists",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L546-L556 | train |
maxence-charriere/app | dom.go | Contains | func (e *domEngine) Contains(c Compo) bool {
e.mutex.RLock()
defer e.mutex.RUnlock()
_, ok := e.compos[c]
return ok
} | go | func (e *domEngine) Contains(c Compo) bool {
e.mutex.RLock()
defer e.mutex.RUnlock()
_, ok := e.compos[c]
return ok
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"Contains",
"(",
"c",
"Compo",
")",
"bool",
"{",
"e",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"_",
",",
"ok",
":=",
"e",
".",
"compos",
"... | // Contains reports whether the given component is in the dom. | [
"Contains",
"reports",
"whether",
"the",
"given",
"component",
"is",
"in",
"the",
"dom",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L60-L66 | train |
maxence-charriere/app | dom.go | CompoByID | func (e *domEngine) CompoByID(id string) (Compo, error) {
e.mutex.RLock()
defer e.mutex.RUnlock()
c, ok := e.compoIDs[id]
if !ok {
return nil, ErrCompoNotMounted
}
return c.Compo, nil
} | go | func (e *domEngine) CompoByID(id string) (Compo, error) {
e.mutex.RLock()
defer e.mutex.RUnlock()
c, ok := e.compoIDs[id]
if !ok {
return nil, ErrCompoNotMounted
}
return c.Compo, nil
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"CompoByID",
"(",
"id",
"string",
")",
"(",
"Compo",
",",
"error",
")",
"{",
"e",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"c",
",",
"ok",
... | // CompoByID returns the component with the given identifier. | [
"CompoByID",
"returns",
"the",
"component",
"with",
"the",
"given",
"identifier",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L69-L79 | train |
maxence-charriere/app | dom.go | New | func (e *domEngine) New(c Compo) error {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
if err := e.render(c); err != nil {
return err
}
ic := e.compos[c]
e.rootID = ic.ID
e.changes = append(e.changes, change{
Action: setRoot,
NodeID: ic.ID,
})
return e.sync()
} | go | func (e *domEngine) New(c Compo) error {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
if err := e.render(c); err != nil {
return err
}
ic := e.compos[c]
e.rootID = ic.ID
e.changes = append(e.changes, change{
Action: setRoot,
NodeID: ic.ID,
})
return e.sync()
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"New",
"(",
"c",
"Compo",
")",
"error",
"{",
"e",
".",
"once",
".",
"Do",
"(",
"e",
".",
"init",
")",
"\n",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"Unlock",
... | // New renders the given component and set it as the dom root. | [
"New",
"renders",
"the",
"given",
"component",
"and",
"set",
"it",
"as",
"the",
"dom",
"root",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L82-L102 | train |
maxence-charriere/app | dom.go | Close | func (e *domEngine) Close() {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
} | go | func (e *domEngine) Close() {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"Close",
"(",
")",
"{",
"e",
".",
"once",
".",
"Do",
"(",
"e",
".",
"init",
")",
"\n",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"e",
... | // Close deletes the components and nodes from the dom. | [
"Close",
"deletes",
"the",
"components",
"and",
"nodes",
"from",
"the",
"dom",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L105-L111 | train |
maxence-charriere/app | internal/http/cache.go | CacheHandler | func CacheHandler(h http.Handler, webDir string) http.Handler {
return &cacheHandler{
Handler: h,
webDir: webDir,
}
} | go | func CacheHandler(h http.Handler, webDir string) http.Handler {
return &cacheHandler{
Handler: h,
webDir: webDir,
}
} | [
"func",
"CacheHandler",
"(",
"h",
"http",
".",
"Handler",
",",
"webDir",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"&",
"cacheHandler",
"{",
"Handler",
":",
"h",
",",
"webDir",
":",
"webDir",
",",
"}",
"\n",
"}"
] | // CacheHandler returns a decorated version of the given cache that injects
// cache related headers. | [
"CacheHandler",
"returns",
"a",
"decorated",
"version",
"of",
"the",
"given",
"cache",
"that",
"injects",
"cache",
"related",
"headers",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L15-L20 | train |
maxence-charriere/app | internal/http/cache.go | GenerateEtag | func GenerateEtag() string {
t := time.Now().UTC().String()
return fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
} | go | func GenerateEtag() string {
t := time.Now().UTC().String()
return fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
} | [
"func",
"GenerateEtag",
"(",
")",
"string",
"{",
"t",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"String",
"(",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"`%x`",
",",
"sha1",
".",
"Sum",
"(",
"[",
"]",
"byte",
"(",
... | // GenerateEtag generates an etag. | [
"GenerateEtag",
"generates",
"an",
"etag",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L63-L66 | train |
maxence-charriere/app | internal/http/cache.go | GetEtag | func GetEtag(webDir string) string {
filename := filepath.Join(webDir, ".etag")
etag, err := ioutil.ReadFile(filename)
if err != nil {
return ""
}
return string(etag)
} | go | func GetEtag(webDir string) string {
filename := filepath.Join(webDir, ".etag")
etag, err := ioutil.ReadFile(filename)
if err != nil {
return ""
}
return string(etag)
} | [
"func",
"GetEtag",
"(",
"webDir",
"string",
")",
"string",
"{",
"filename",
":=",
"filepath",
".",
"Join",
"(",
"webDir",
",",
"\".etag\"",
")",
"\n",
"etag",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
... | // GetEtag returns the etag for the given web directory. | [
"GetEtag",
"returns",
"the",
"etag",
"for",
"the",
"given",
"web",
"directory",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L69-L77 | train |
maxence-charriere/app | attr.go | jsToGoHandler | func jsToGoHandler(name, value string) (string, string) {
if !strings.HasPrefix(name, "on") {
return name, value
}
if strings.HasPrefix(value, "js:") {
return name, strings.TrimPrefix(value, "js:")
}
return name, fmt.Sprintf("callCompoHandler(this, event, '%s')", value)
} | go | func jsToGoHandler(name, value string) (string, string) {
if !strings.HasPrefix(name, "on") {
return name, value
}
if strings.HasPrefix(value, "js:") {
return name, strings.TrimPrefix(value, "js:")
}
return name, fmt.Sprintf("callCompoHandler(this, event, '%s')", value)
} | [
"func",
"jsToGoHandler",
"(",
"name",
",",
"value",
"string",
")",
"(",
"string",
",",
"string",
")",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"name",
",",
"\"on\"",
")",
"{",
"return",
"name",
",",
"value",
"\n",
"}",
"\n",
"if",
"strings",... | // jsToGoHandler convert a javascript handler to a go component handler. | [
"jsToGoHandler",
"convert",
"a",
"javascript",
"handler",
"to",
"a",
"go",
"component",
"handler",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/attr.go#L12-L22 | train |
maxence-charriere/app | app.go | Import | func Import(c ...Compo) {
for _, compo := range c {
if _, err := components.register(compo); err != nil {
Panicf("import component failed: %s", err)
}
}
} | go | func Import(c ...Compo) {
for _, compo := range c {
if _, err := components.register(compo); err != nil {
Panicf("import component failed: %s", err)
}
}
} | [
"func",
"Import",
"(",
"c",
"...",
"Compo",
")",
"{",
"for",
"_",
",",
"compo",
":=",
"range",
"c",
"{",
"if",
"_",
",",
"err",
":=",
"components",
".",
"register",
"(",
"compo",
")",
";",
"err",
"!=",
"nil",
"{",
"Panicf",
"(",
"\"import component... | // Import imports the given components into the app.
// Components must be imported in order the be used by the app package.
// This allows components to be created dynamically when they are found into
// markup. | [
"Import",
"imports",
"the",
"given",
"components",
"into",
"the",
"app",
".",
"Components",
"must",
"be",
"imported",
"in",
"order",
"the",
"be",
"used",
"by",
"the",
"app",
"package",
".",
"This",
"allows",
"components",
"to",
"be",
"created",
"dynamically"... | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L77-L83 | train |
maxence-charriere/app | app.go | Log | func Log(a ...interface{}) {
format := ""
for range a {
format += "%v "
}
format = format[:len(format)-1]
Logger(format, a...)
} | go | func Log(a ...interface{}) {
format := ""
for range a {
format += "%v "
}
format = format[:len(format)-1]
Logger(format, a...)
} | [
"func",
"Log",
"(",
"a",
"...",
"interface",
"{",
"}",
")",
"{",
"format",
":=",
"\"\"",
"\n",
"for",
"range",
"a",
"{",
"format",
"+=",
"\"%v \"",
"\n",
"}",
"\n",
"format",
"=",
"format",
"[",
":",
"len",
"(",
"format",
")",
"-",
"1",
"]",
"\... | // Log formats using the default formats for its operands and logs the resulting
// string.
// Spaces are always added between operands and a newline is appended. | [
"Log",
"formats",
"using",
"the",
"default",
"formats",
"for",
"its",
"operands",
"and",
"logs",
"the",
"resulting",
"string",
".",
"Spaces",
"are",
"always",
"added",
"between",
"operands",
"and",
"a",
"newline",
"is",
"appended",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L88-L97 | train |
maxence-charriere/app | app.go | Render | func Render(c Compo) {
WhenDebug(func() {
Logf("rendering %T")
})
if err := render(c); err != nil {
Log(err)
}
} | go | func Render(c Compo) {
WhenDebug(func() {
Logf("rendering %T")
})
if err := render(c); err != nil {
Log(err)
}
} | [
"func",
"Render",
"(",
"c",
"Compo",
")",
"{",
"WhenDebug",
"(",
"func",
"(",
")",
"{",
"Logf",
"(",
"\"rendering %T\"",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
":=",
"render",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"Log",
"(",
"err",
")"... | // Render renders the given component.
// It should be called whenever a component is modified.
//
// It panics if called before Run. | [
"Render",
"renders",
"the",
"given",
"component",
".",
"It",
"should",
"be",
"called",
"whenever",
"a",
"component",
"is",
"modified",
".",
"It",
"panics",
"if",
"called",
"before",
"Run",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L167-L175 | train |
maxence-charriere/app | mapping.go | Map | func (m *mapping) Map(c Compo) (f func(), err error) {
if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
return nil, err
}
return m.mapTo(reflect.ValueOf(c))
} | go | func (m *mapping) Map(c Compo) (f func(), err error) {
if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
return nil, err
}
return m.mapTo(reflect.ValueOf(c))
} | [
"func",
"(",
"m",
"*",
"mapping",
")",
"Map",
"(",
"c",
"Compo",
")",
"(",
"f",
"func",
"(",
")",
",",
"err",
"error",
")",
"{",
"if",
"m",
".",
"pipeline",
",",
"err",
"=",
"pipeline",
"(",
"m",
".",
"FieldOrMethod",
")",
";",
"err",
"!=",
"... | // Map performs the mapping to the given component. | [
"Map",
"performs",
"the",
"mapping",
"to",
"the",
"given",
"component",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/mapping.go#L91-L97 | train |
maxence-charriere/app | demo/cmd/demo-wasm/hello.go | OnMenuClick | func (h *Hello) OnMenuClick() {
app.NewContextMenu(
app.MenuItem{
Label: "Reload",
Keys: "cmdorctrl+r",
OnClick: app.Reload},
app.MenuItem{Separator: true},
app.MenuItem{
Label: "Go to repository",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app")
}},
app.MenuItem{
Label: "Source code",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app/blob/master/demo/cmd/demo-wasm/hello.go")
}},
)
} | go | func (h *Hello) OnMenuClick() {
app.NewContextMenu(
app.MenuItem{
Label: "Reload",
Keys: "cmdorctrl+r",
OnClick: app.Reload},
app.MenuItem{Separator: true},
app.MenuItem{
Label: "Go to repository",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app")
}},
app.MenuItem{
Label: "Source code",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app/blob/master/demo/cmd/demo-wasm/hello.go")
}},
)
} | [
"func",
"(",
"h",
"*",
"Hello",
")",
"OnMenuClick",
"(",
")",
"{",
"app",
".",
"NewContextMenu",
"(",
"app",
".",
"MenuItem",
"{",
"Label",
":",
"\"Reload\"",
",",
"Keys",
":",
"\"cmdorctrl+r\"",
",",
"OnClick",
":",
"app",
".",
"Reload",
"}",
",",
"... | // OnMenuClick creates a context menu when the menu button is clicked. | [
"OnMenuClick",
"creates",
"a",
"context",
"menu",
"when",
"the",
"menu",
"button",
"is",
"clicked",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/demo/cmd/demo-wasm/hello.go#L37-L55 | train |
maxence-charriere/app | internal/http/file.go | FileHandler | func FileHandler(webDir string) http.Handler {
return http.FileServer(http.Dir(webDir))
} | go | func FileHandler(webDir string) http.Handler {
return http.FileServer(http.Dir(webDir))
} | [
"func",
"FileHandler",
"(",
"webDir",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"FileServer",
"(",
"http",
".",
"Dir",
"(",
"webDir",
")",
")",
"\n",
"}"
] | // FileHandler returns a handler that serves files located in the web directory. | [
"FileHandler",
"returns",
"a",
"handler",
"that",
"serves",
"files",
"located",
"in",
"the",
"web",
"directory",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/file.go#L6-L8 | train |
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... | // 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",
"for",
"_"... | // 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",
"(",
")",
"{",
"app",
".",
"Import",
"(",
"&",
"Hello",
"{",
"}",
")",
"\n",
"app",
".",
"DefaultPath",
"=",
"\"/hello\"",
"\n",
"if",
"err",
":=",
"app",
".",
"Run",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
... | // 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"... | // 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",
"{",
"retu... | // 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",
"if",
"t",
".",
"stopped",
"{",
"return",
"error... | // 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",
"if",
"t",
".",
"stopped"... | // 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",
"if",
"t",
".",
"stop... | // 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",
"... | // 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",
":=",
... | // 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",
... | // 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... | // 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",
"}",
"\... | // 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",
"defe... | // 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",
".",
"Extensi... | // 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",
"{",
"if",
"tx",
".",
"lookup",
"(",
"tableExtension",
",",
"indexName",
",",
"strings",
".",
"ToLower",
"(",
"e",
".",
"Annotations",
".",
"Name",
")",
... | // 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",
"resources",
",",
"... | // 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",
"re... | // 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",
")",
"{",
... | // 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",
"==",
"\"... | // 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",
"=... | // 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",
"malfor... | 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",
":",
... | // 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",... | // 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",
",",
"\"keymanager\"",
")",
"\n",
"var",
"("... | // 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",
"."... | // 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",
... | // 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",
")... | // 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",
",... | // 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",
... | // 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",
... | 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",
"{",
"hosts",
":=",
"[",
"]",
"string",
"{",
"ou",
",",
"cn",
"}",
"\n",
"if",
"ou",
"==",
"ManagerRole",
"{",... | // 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",
... | // 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",
... | // 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",
")",
"{",
"parsedCerts",
",",
"err... | // 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",
... | 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",
... | // 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",
")",
"{",
"cert",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"paths",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
... | // 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",
")",
"{",
"insecureCreds",
":=",
"credentials",
".",
"NewTLS",
"("... | // 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",
")",
"{",
"req",
":=",
"cfcsr",
".",
"CertificateRequest",
"{",
"CN",
":",
"rootCN",
",",
"KeyRequest",
":",
"&",
"cfcsr",
".",
"BasicKeyRequest",
"{",
"A",
":",
"RootKeyA... | // 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",
"cert",
",",
"_",
",",
"err",
":=",
"kr",
".",
"Read",
"(",
")",
"\... | // 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",
"{",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Dir",
"(",
"paths",
".",
"Cert",
")",
",",
"0755",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"re... | // 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",
"csr... | // 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",
".",
"Dec... | // 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",
... | 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",
... | // 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",
".",
"A... | // 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",
... | 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... | // 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",
".... | 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",
".",
"R... | // 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"... | 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",
"[... | // 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",
... | 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",
".",
"R... | // 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",
"Not... | 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",... | // 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"... | // 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",
"con... | // 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",
".... | // 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",
"container",
":=",
"t",
".",
"Sp... | // 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",
".",
"DriverProv... | // 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",
"if",
"m",
".",
"config",
".",
"ControlAP... | // 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",... | // 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",
"if",
"m",
".",
"config",
".",
"RemoteAPI",
"==",
"nil",
"{",
... | // 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",
"(",
"\"Stopping manager\"",
")",
"\n",
"<-",
"m",
".",
"started",
"\n",
"m",
... | // 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",
"... | 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",
")",
"{",
"oldLeader",
":=",
"m",
".",
"getLeaderNodeID",
"(",
")",
"\n",
"for",
"{",
"select",
"... | // 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",
":",
... | // 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",
"(",
")",
"{",
"m",
".",
"dispatcher",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"logbroker",
".",
"Stop",
"(",
")",
"\n",
"m",
".",
"caserver",
".",
"Stop",
"(",
")",
"\n",
"if",
"m",
".",
... | // 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",
".",
"E... | // 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",
":",
... | // 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",
",",
"Annotati... | // 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",
"... | 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",
"{",
"A... | // 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"... | 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",
"==... | // 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",
".",
"-",
... | 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",
".",
"ConfigI... | // 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... | 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",
"[",
"]"... | // 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",
"i... | 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",
":=",
"validateCo... | // 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",
... | 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",
".",
"ConfigI... | // 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",... | 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",
")",
"{",
"sddl",
":=",
"\"D:P(A;;GA;;;BA)(A;;GA;;;SY)\"",
"\n",
"c",
":=",
"winio",
".",
"PipeConfig",
"{",
"SecurityDescriptor",
":",
"sddl",
",",
"MessageMode",
... | // 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",
")",
"{",
"grpcOptions",
":=",
"[",... | // 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.