repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
docker/cli | cli/config/config.go | LegacyLoadFromReader | func LegacyLoadFromReader(configData io.Reader) (*configfile.ConfigFile, error) {
configFile := configfile.ConfigFile{
AuthConfigs: make(map[string]types.AuthConfig),
}
err := configFile.LegacyLoadFromReader(configData)
return &configFile, err
} | go | func LegacyLoadFromReader(configData io.Reader) (*configfile.ConfigFile, error) {
configFile := configfile.ConfigFile{
AuthConfigs: make(map[string]types.AuthConfig),
}
err := configFile.LegacyLoadFromReader(configData)
return &configFile, err
} | [
"func",
"LegacyLoadFromReader",
"(",
"configData",
"io",
".",
"Reader",
")",
"(",
"*",
"configfile",
".",
"ConfigFile",
",",
"error",
")",
"{",
"configFile",
":=",
"configfile",
".",
"ConfigFile",
"{",
"AuthConfigs",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"types",
".",
"AuthConfig",
")",
",",
"}",
"\n",
"err",
":=",
"configFile",
".",
"LegacyLoadFromReader",
"(",
"configData",
")",
"\n",
"return",
"&",
"configFile",
",",
"err",
"\n",
"}"
] | // LegacyLoadFromReader is a convenience function that creates a ConfigFile object from
// a non-nested reader | [
"LegacyLoadFromReader",
"is",
"a",
"convenience",
"function",
"that",
"creates",
"a",
"ConfigFile",
"object",
"from",
"a",
"non",
"-",
"nested",
"reader"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/config/config.go#L61-L67 | train |
docker/cli | cli/config/config.go | LoadDefaultConfigFile | func LoadDefaultConfigFile(stderr io.Writer) *configfile.ConfigFile {
configFile, err := Load(Dir())
if err != nil {
fmt.Fprintf(stderr, "WARNING: Error loading config file: %v\n", err)
}
if !configFile.ContainsAuth() {
configFile.CredentialsStore = credentials.DetectDefaultStore(configFile.CredentialsStore)
}
return configFile
} | go | func LoadDefaultConfigFile(stderr io.Writer) *configfile.ConfigFile {
configFile, err := Load(Dir())
if err != nil {
fmt.Fprintf(stderr, "WARNING: Error loading config file: %v\n", err)
}
if !configFile.ContainsAuth() {
configFile.CredentialsStore = credentials.DetectDefaultStore(configFile.CredentialsStore)
}
return configFile
} | [
"func",
"LoadDefaultConfigFile",
"(",
"stderr",
"io",
".",
"Writer",
")",
"*",
"configfile",
".",
"ConfigFile",
"{",
"configFile",
",",
"err",
":=",
"Load",
"(",
"Dir",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"stderr",
",",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"configFile",
".",
"ContainsAuth",
"(",
")",
"{",
"configFile",
".",
"CredentialsStore",
"=",
"credentials",
".",
"DetectDefaultStore",
"(",
"configFile",
".",
"CredentialsStore",
")",
"\n",
"}",
"\n",
"return",
"configFile",
"\n",
"}"
] | // LoadDefaultConfigFile attempts to load the default config file and returns
// an initialized ConfigFile struct if none is found. | [
"LoadDefaultConfigFile",
"attempts",
"to",
"load",
"the",
"default",
"config",
"file",
"and",
"returns",
"an",
"initialized",
"ConfigFile",
"struct",
"if",
"none",
"is",
"found",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/config/config.go#L127-L136 | train |
docker/cli | cli/command/trust/helpers.go | notaryRoleToSigner | func notaryRoleToSigner(tufRole data.RoleName) string {
// don't show a signer for "targets" or "targets/releases"
if isReleasedTarget(data.RoleName(tufRole.String())) {
return releasedRoleName
}
return strings.TrimPrefix(tufRole.String(), "targets/")
} | go | func notaryRoleToSigner(tufRole data.RoleName) string {
// don't show a signer for "targets" or "targets/releases"
if isReleasedTarget(data.RoleName(tufRole.String())) {
return releasedRoleName
}
return strings.TrimPrefix(tufRole.String(), "targets/")
} | [
"func",
"notaryRoleToSigner",
"(",
"tufRole",
"data",
".",
"RoleName",
")",
"string",
"{",
"// don't show a signer for \"targets\" or \"targets/releases\"",
"if",
"isReleasedTarget",
"(",
"data",
".",
"RoleName",
"(",
"tufRole",
".",
"String",
"(",
")",
")",
")",
"{",
"return",
"releasedRoleName",
"\n",
"}",
"\n",
"return",
"strings",
".",
"TrimPrefix",
"(",
"tufRole",
".",
"String",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // notaryRoleToSigner converts TUF role name to a human-understandable signer name | [
"notaryRoleToSigner",
"converts",
"TUF",
"role",
"name",
"to",
"a",
"human",
"-",
"understandable",
"signer",
"name"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/trust/helpers.go#L21-L27 | train |
docker/cli | cli/command/trust/helpers.go | clearChangeList | func clearChangeList(notaryRepo client.Repository) error {
cl, err := notaryRepo.GetChangelist()
if err != nil {
return err
}
return cl.Clear("")
} | go | func clearChangeList(notaryRepo client.Repository) error {
cl, err := notaryRepo.GetChangelist()
if err != nil {
return err
}
return cl.Clear("")
} | [
"func",
"clearChangeList",
"(",
"notaryRepo",
"client",
".",
"Repository",
")",
"error",
"{",
"cl",
",",
"err",
":=",
"notaryRepo",
".",
"GetChangelist",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"cl",
".",
"Clear",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // clearChangelist clears the notary staging changelist. | [
"clearChangelist",
"clears",
"the",
"notary",
"staging",
"changelist",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/trust/helpers.go#L30-L36 | train |
docker/cli | cli/command/trust/helpers.go | getOrGenerateRootKeyAndInitRepo | func getOrGenerateRootKeyAndInitRepo(notaryRepo client.Repository) error {
rootKey, err := getOrGenerateNotaryKey(notaryRepo, data.CanonicalRootRole)
if err != nil {
return err
}
return notaryRepo.Initialize([]string{rootKey.ID()}, data.CanonicalSnapshotRole)
} | go | func getOrGenerateRootKeyAndInitRepo(notaryRepo client.Repository) error {
rootKey, err := getOrGenerateNotaryKey(notaryRepo, data.CanonicalRootRole)
if err != nil {
return err
}
return notaryRepo.Initialize([]string{rootKey.ID()}, data.CanonicalSnapshotRole)
} | [
"func",
"getOrGenerateRootKeyAndInitRepo",
"(",
"notaryRepo",
"client",
".",
"Repository",
")",
"error",
"{",
"rootKey",
",",
"err",
":=",
"getOrGenerateNotaryKey",
"(",
"notaryRepo",
",",
"data",
".",
"CanonicalRootRole",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"notaryRepo",
".",
"Initialize",
"(",
"[",
"]",
"string",
"{",
"rootKey",
".",
"ID",
"(",
")",
"}",
",",
"data",
".",
"CanonicalSnapshotRole",
")",
"\n",
"}"
] | // getOrGenerateRootKeyAndInitRepo initializes the notary repository
// with a remotely managed snapshot key. The initialization will use
// an existing root key if one is found, else a new one will be generated. | [
"getOrGenerateRootKeyAndInitRepo",
"initializes",
"the",
"notary",
"repository",
"with",
"a",
"remotely",
"managed",
"snapshot",
"key",
".",
"The",
"initialization",
"will",
"use",
"an",
"existing",
"root",
"key",
"if",
"one",
"is",
"found",
"else",
"a",
"new",
"one",
"will",
"be",
"generated",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/trust/helpers.go#L41-L47 | train |
docker/cli | cli/context/docker/load.go | tlsConfig | func (c *Endpoint) tlsConfig() (*tls.Config, error) {
if c.TLSData == nil && !c.SkipTLSVerify {
// there is no specific tls config
return nil, nil
}
var tlsOpts []func(*tls.Config)
if c.TLSData != nil && c.TLSData.CA != nil {
certPool := x509.NewCertPool()
if !certPool.AppendCertsFromPEM(c.TLSData.CA) {
return nil, errors.New("failed to retrieve context tls info: ca.pem seems invalid")
}
tlsOpts = append(tlsOpts, func(cfg *tls.Config) {
cfg.RootCAs = certPool
})
}
if c.TLSData != nil && c.TLSData.Key != nil && c.TLSData.Cert != nil {
keyBytes := c.TLSData.Key
pemBlock, _ := pem.Decode(keyBytes)
if pemBlock == nil {
return nil, fmt.Errorf("no valid private key found")
}
var err error
if x509.IsEncryptedPEMBlock(pemBlock) {
keyBytes, err = x509.DecryptPEMBlock(pemBlock, []byte(c.TLSPassword))
if err != nil {
return nil, errors.Wrap(err, "private key is encrypted, but could not decrypt it")
}
keyBytes = pem.EncodeToMemory(&pem.Block{Type: pemBlock.Type, Bytes: keyBytes})
}
x509cert, err := tls.X509KeyPair(c.TLSData.Cert, keyBytes)
if err != nil {
return nil, errors.Wrap(err, "failed to retrieve context tls info")
}
tlsOpts = append(tlsOpts, func(cfg *tls.Config) {
cfg.Certificates = []tls.Certificate{x509cert}
})
}
if c.SkipTLSVerify {
tlsOpts = append(tlsOpts, func(cfg *tls.Config) {
cfg.InsecureSkipVerify = true
})
}
return tlsconfig.ClientDefault(tlsOpts...), nil
} | go | func (c *Endpoint) tlsConfig() (*tls.Config, error) {
if c.TLSData == nil && !c.SkipTLSVerify {
// there is no specific tls config
return nil, nil
}
var tlsOpts []func(*tls.Config)
if c.TLSData != nil && c.TLSData.CA != nil {
certPool := x509.NewCertPool()
if !certPool.AppendCertsFromPEM(c.TLSData.CA) {
return nil, errors.New("failed to retrieve context tls info: ca.pem seems invalid")
}
tlsOpts = append(tlsOpts, func(cfg *tls.Config) {
cfg.RootCAs = certPool
})
}
if c.TLSData != nil && c.TLSData.Key != nil && c.TLSData.Cert != nil {
keyBytes := c.TLSData.Key
pemBlock, _ := pem.Decode(keyBytes)
if pemBlock == nil {
return nil, fmt.Errorf("no valid private key found")
}
var err error
if x509.IsEncryptedPEMBlock(pemBlock) {
keyBytes, err = x509.DecryptPEMBlock(pemBlock, []byte(c.TLSPassword))
if err != nil {
return nil, errors.Wrap(err, "private key is encrypted, but could not decrypt it")
}
keyBytes = pem.EncodeToMemory(&pem.Block{Type: pemBlock.Type, Bytes: keyBytes})
}
x509cert, err := tls.X509KeyPair(c.TLSData.Cert, keyBytes)
if err != nil {
return nil, errors.Wrap(err, "failed to retrieve context tls info")
}
tlsOpts = append(tlsOpts, func(cfg *tls.Config) {
cfg.Certificates = []tls.Certificate{x509cert}
})
}
if c.SkipTLSVerify {
tlsOpts = append(tlsOpts, func(cfg *tls.Config) {
cfg.InsecureSkipVerify = true
})
}
return tlsconfig.ClientDefault(tlsOpts...), nil
} | [
"func",
"(",
"c",
"*",
"Endpoint",
")",
"tlsConfig",
"(",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"if",
"c",
".",
"TLSData",
"==",
"nil",
"&&",
"!",
"c",
".",
"SkipTLSVerify",
"{",
"// there is no specific tls config",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"var",
"tlsOpts",
"[",
"]",
"func",
"(",
"*",
"tls",
".",
"Config",
")",
"\n",
"if",
"c",
".",
"TLSData",
"!=",
"nil",
"&&",
"c",
".",
"TLSData",
".",
"CA",
"!=",
"nil",
"{",
"certPool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"if",
"!",
"certPool",
".",
"AppendCertsFromPEM",
"(",
"c",
".",
"TLSData",
".",
"CA",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tlsOpts",
"=",
"append",
"(",
"tlsOpts",
",",
"func",
"(",
"cfg",
"*",
"tls",
".",
"Config",
")",
"{",
"cfg",
".",
"RootCAs",
"=",
"certPool",
"\n",
"}",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"TLSData",
"!=",
"nil",
"&&",
"c",
".",
"TLSData",
".",
"Key",
"!=",
"nil",
"&&",
"c",
".",
"TLSData",
".",
"Cert",
"!=",
"nil",
"{",
"keyBytes",
":=",
"c",
".",
"TLSData",
".",
"Key",
"\n",
"pemBlock",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"keyBytes",
")",
"\n",
"if",
"pemBlock",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"if",
"x509",
".",
"IsEncryptedPEMBlock",
"(",
"pemBlock",
")",
"{",
"keyBytes",
",",
"err",
"=",
"x509",
".",
"DecryptPEMBlock",
"(",
"pemBlock",
",",
"[",
"]",
"byte",
"(",
"c",
".",
"TLSPassword",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"keyBytes",
"=",
"pem",
".",
"EncodeToMemory",
"(",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"pemBlock",
".",
"Type",
",",
"Bytes",
":",
"keyBytes",
"}",
")",
"\n",
"}",
"\n\n",
"x509cert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"c",
".",
"TLSData",
".",
"Cert",
",",
"keyBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tlsOpts",
"=",
"append",
"(",
"tlsOpts",
",",
"func",
"(",
"cfg",
"*",
"tls",
".",
"Config",
")",
"{",
"cfg",
".",
"Certificates",
"=",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"x509cert",
"}",
"\n",
"}",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"SkipTLSVerify",
"{",
"tlsOpts",
"=",
"append",
"(",
"tlsOpts",
",",
"func",
"(",
"cfg",
"*",
"tls",
".",
"Config",
")",
"{",
"cfg",
".",
"InsecureSkipVerify",
"=",
"true",
"\n",
"}",
")",
"\n",
"}",
"\n",
"return",
"tlsconfig",
".",
"ClientDefault",
"(",
"tlsOpts",
"...",
")",
",",
"nil",
"\n",
"}"
] | // tlsConfig extracts a context docker endpoint TLS config | [
"tlsConfig",
"extracts",
"a",
"context",
"docker",
"endpoint",
"TLS",
"config"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/context/docker/load.go#L46-L91 | train |
docker/cli | cli/context/docker/load.go | ClientOpts | func (c *Endpoint) ClientOpts() ([]client.Opt, error) {
var result []client.Opt
if c.Host != "" {
helper, err := connhelper.GetConnectionHelper(c.Host)
if err != nil {
return nil, err
}
if helper == nil {
tlsConfig, err := c.tlsConfig()
if err != nil {
return nil, err
}
result = append(result,
client.WithHost(c.Host),
withHTTPClient(tlsConfig),
)
} else {
httpClient := &http.Client{
// No tls
// No proxy
Transport: &http.Transport{
DialContext: helper.Dialer,
},
}
result = append(result,
client.WithHTTPClient(httpClient),
client.WithHost(helper.Host),
client.WithDialContext(helper.Dialer),
)
}
}
version := os.Getenv("DOCKER_API_VERSION")
if version != "" {
result = append(result, client.WithVersion(version))
}
return result, nil
} | go | func (c *Endpoint) ClientOpts() ([]client.Opt, error) {
var result []client.Opt
if c.Host != "" {
helper, err := connhelper.GetConnectionHelper(c.Host)
if err != nil {
return nil, err
}
if helper == nil {
tlsConfig, err := c.tlsConfig()
if err != nil {
return nil, err
}
result = append(result,
client.WithHost(c.Host),
withHTTPClient(tlsConfig),
)
} else {
httpClient := &http.Client{
// No tls
// No proxy
Transport: &http.Transport{
DialContext: helper.Dialer,
},
}
result = append(result,
client.WithHTTPClient(httpClient),
client.WithHost(helper.Host),
client.WithDialContext(helper.Dialer),
)
}
}
version := os.Getenv("DOCKER_API_VERSION")
if version != "" {
result = append(result, client.WithVersion(version))
}
return result, nil
} | [
"func",
"(",
"c",
"*",
"Endpoint",
")",
"ClientOpts",
"(",
")",
"(",
"[",
"]",
"client",
".",
"Opt",
",",
"error",
")",
"{",
"var",
"result",
"[",
"]",
"client",
".",
"Opt",
"\n",
"if",
"c",
".",
"Host",
"!=",
"\"",
"\"",
"{",
"helper",
",",
"err",
":=",
"connhelper",
".",
"GetConnectionHelper",
"(",
"c",
".",
"Host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"helper",
"==",
"nil",
"{",
"tlsConfig",
",",
"err",
":=",
"c",
".",
"tlsConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"result",
"=",
"append",
"(",
"result",
",",
"client",
".",
"WithHost",
"(",
"c",
".",
"Host",
")",
",",
"withHTTPClient",
"(",
"tlsConfig",
")",
",",
")",
"\n\n",
"}",
"else",
"{",
"httpClient",
":=",
"&",
"http",
".",
"Client",
"{",
"// No tls",
"// No proxy",
"Transport",
":",
"&",
"http",
".",
"Transport",
"{",
"DialContext",
":",
"helper",
".",
"Dialer",
",",
"}",
",",
"}",
"\n",
"result",
"=",
"append",
"(",
"result",
",",
"client",
".",
"WithHTTPClient",
"(",
"httpClient",
")",
",",
"client",
".",
"WithHost",
"(",
"helper",
".",
"Host",
")",
",",
"client",
".",
"WithDialContext",
"(",
"helper",
".",
"Dialer",
")",
",",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"version",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"version",
"!=",
"\"",
"\"",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"client",
".",
"WithVersion",
"(",
"version",
")",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // ClientOpts returns a slice of Client options to configure an API client with this endpoint | [
"ClientOpts",
"returns",
"a",
"slice",
"of",
"Client",
"options",
"to",
"configure",
"an",
"API",
"client",
"with",
"this",
"endpoint"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/context/docker/load.go#L94-L132 | train |
docker/cli | cli/context/docker/load.go | EndpointFromContext | func EndpointFromContext(metadata store.Metadata) (EndpointMeta, error) {
ep, ok := metadata.Endpoints[DockerEndpoint]
if !ok {
return EndpointMeta{}, errors.New("cannot find docker endpoint in context")
}
typed, ok := ep.(EndpointMeta)
if !ok {
return EndpointMeta{}, errors.Errorf("endpoint %q is not of type EndpointMeta", DockerEndpoint)
}
return typed, nil
} | go | func EndpointFromContext(metadata store.Metadata) (EndpointMeta, error) {
ep, ok := metadata.Endpoints[DockerEndpoint]
if !ok {
return EndpointMeta{}, errors.New("cannot find docker endpoint in context")
}
typed, ok := ep.(EndpointMeta)
if !ok {
return EndpointMeta{}, errors.Errorf("endpoint %q is not of type EndpointMeta", DockerEndpoint)
}
return typed, nil
} | [
"func",
"EndpointFromContext",
"(",
"metadata",
"store",
".",
"Metadata",
")",
"(",
"EndpointMeta",
",",
"error",
")",
"{",
"ep",
",",
"ok",
":=",
"metadata",
".",
"Endpoints",
"[",
"DockerEndpoint",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"EndpointMeta",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"typed",
",",
"ok",
":=",
"ep",
".",
"(",
"EndpointMeta",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"EndpointMeta",
"{",
"}",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"DockerEndpoint",
")",
"\n",
"}",
"\n",
"return",
"typed",
",",
"nil",
"\n",
"}"
] | // EndpointFromContext parses a context docker endpoint metadata into a typed EndpointMeta structure | [
"EndpointFromContext",
"parses",
"a",
"context",
"docker",
"endpoint",
"metadata",
"into",
"a",
"typed",
"EndpointMeta",
"structure"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/context/docker/load.go#L156-L166 | train |
docker/cli | cli/command/container/top.go | NewTopCommand | func NewTopCommand(dockerCli command.Cli) *cobra.Command {
var opts topOptions
cmd := &cobra.Command{
Use: "top CONTAINER [ps OPTIONS]",
Short: "Display the running processes of a container",
Args: cli.RequiresMinArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
opts.container = args[0]
opts.args = args[1:]
return runTop(dockerCli, &opts)
},
}
flags := cmd.Flags()
flags.SetInterspersed(false)
return cmd
} | go | func NewTopCommand(dockerCli command.Cli) *cobra.Command {
var opts topOptions
cmd := &cobra.Command{
Use: "top CONTAINER [ps OPTIONS]",
Short: "Display the running processes of a container",
Args: cli.RequiresMinArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
opts.container = args[0]
opts.args = args[1:]
return runTop(dockerCli, &opts)
},
}
flags := cmd.Flags()
flags.SetInterspersed(false)
return cmd
} | [
"func",
"NewTopCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"opts",
"topOptions",
"\n\n",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Args",
":",
"cli",
".",
"RequiresMinArgs",
"(",
"1",
")",
",",
"RunE",
":",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"opts",
".",
"container",
"=",
"args",
"[",
"0",
"]",
"\n",
"opts",
".",
"args",
"=",
"args",
"[",
"1",
":",
"]",
"\n",
"return",
"runTop",
"(",
"dockerCli",
",",
"&",
"opts",
")",
"\n",
"}",
",",
"}",
"\n\n",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n",
"flags",
".",
"SetInterspersed",
"(",
"false",
")",
"\n\n",
"return",
"cmd",
"\n",
"}"
] | // NewTopCommand creates a new cobra.Command for `docker top` | [
"NewTopCommand",
"creates",
"a",
"new",
"cobra",
".",
"Command",
"for",
"docker",
"top"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/container/top.go#L21-L39 | train |
docker/cli | cli/command/stack/kubernetes/ps.go | RunPS | func RunPS(dockerCli *KubeCli, options options.PS) error {
filters := options.Filter.Value()
if err := filters.Validate(supportedPSFilters); err != nil {
return err
}
client, err := dockerCli.composeClient()
if err != nil {
return err
}
stacks, err := client.Stacks(false)
if err != nil {
return err
}
stackName := options.Namespace
_, err = stacks.Get(stackName)
if apierrs.IsNotFound(err) {
return fmt.Errorf("nothing found in stack: %s", stackName)
}
if err != nil {
return err
}
pods, err := fetchPods(stackName, client.Pods(), filters)
if err != nil {
return err
}
if len(pods) == 0 {
return fmt.Errorf("nothing found in stack: %s", stackName)
}
return printTasks(dockerCli, options, stackName, client, pods)
} | go | func RunPS(dockerCli *KubeCli, options options.PS) error {
filters := options.Filter.Value()
if err := filters.Validate(supportedPSFilters); err != nil {
return err
}
client, err := dockerCli.composeClient()
if err != nil {
return err
}
stacks, err := client.Stacks(false)
if err != nil {
return err
}
stackName := options.Namespace
_, err = stacks.Get(stackName)
if apierrs.IsNotFound(err) {
return fmt.Errorf("nothing found in stack: %s", stackName)
}
if err != nil {
return err
}
pods, err := fetchPods(stackName, client.Pods(), filters)
if err != nil {
return err
}
if len(pods) == 0 {
return fmt.Errorf("nothing found in stack: %s", stackName)
}
return printTasks(dockerCli, options, stackName, client, pods)
} | [
"func",
"RunPS",
"(",
"dockerCli",
"*",
"KubeCli",
",",
"options",
"options",
".",
"PS",
")",
"error",
"{",
"filters",
":=",
"options",
".",
"Filter",
".",
"Value",
"(",
")",
"\n",
"if",
"err",
":=",
"filters",
".",
"Validate",
"(",
"supportedPSFilters",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"dockerCli",
".",
"composeClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"stacks",
",",
"err",
":=",
"client",
".",
"Stacks",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"stackName",
":=",
"options",
".",
"Namespace",
"\n",
"_",
",",
"err",
"=",
"stacks",
".",
"Get",
"(",
"stackName",
")",
"\n",
"if",
"apierrs",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"stackName",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"pods",
",",
"err",
":=",
"fetchPods",
"(",
"stackName",
",",
"client",
".",
"Pods",
"(",
")",
",",
"filters",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"pods",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"stackName",
")",
"\n",
"}",
"\n",
"return",
"printTasks",
"(",
"dockerCli",
",",
"options",
",",
"stackName",
",",
"client",
",",
"pods",
")",
"\n",
"}"
] | // RunPS is the kubernetes implementation of docker stack ps | [
"RunPS",
"is",
"the",
"kubernetes",
"implementation",
"of",
"docker",
"stack",
"ps"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/stack/kubernetes/ps.go#L25-L54 | train |
docker/cli | cli/command/stack/swarm/list.go | GetStacks | func GetStacks(dockerCli command.Cli) ([]*formatter.Stack, error) {
services, err := dockerCli.Client().ServiceList(
context.Background(),
types.ServiceListOptions{Filters: getAllStacksFilter()})
if err != nil {
return nil, err
}
m := make(map[string]*formatter.Stack)
for _, service := range services {
labels := service.Spec.Labels
name, ok := labels[convert.LabelNamespace]
if !ok {
return nil, errors.Errorf("cannot get label %s for service %s",
convert.LabelNamespace, service.ID)
}
ztack, ok := m[name]
if !ok {
m[name] = &formatter.Stack{
Name: name,
Services: 1,
Orchestrator: "Swarm",
}
} else {
ztack.Services++
}
}
var stacks []*formatter.Stack
for _, stack := range m {
stacks = append(stacks, stack)
}
return stacks, nil
} | go | func GetStacks(dockerCli command.Cli) ([]*formatter.Stack, error) {
services, err := dockerCli.Client().ServiceList(
context.Background(),
types.ServiceListOptions{Filters: getAllStacksFilter()})
if err != nil {
return nil, err
}
m := make(map[string]*formatter.Stack)
for _, service := range services {
labels := service.Spec.Labels
name, ok := labels[convert.LabelNamespace]
if !ok {
return nil, errors.Errorf("cannot get label %s for service %s",
convert.LabelNamespace, service.ID)
}
ztack, ok := m[name]
if !ok {
m[name] = &formatter.Stack{
Name: name,
Services: 1,
Orchestrator: "Swarm",
}
} else {
ztack.Services++
}
}
var stacks []*formatter.Stack
for _, stack := range m {
stacks = append(stacks, stack)
}
return stacks, nil
} | [
"func",
"GetStacks",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"(",
"[",
"]",
"*",
"formatter",
".",
"Stack",
",",
"error",
")",
"{",
"services",
",",
"err",
":=",
"dockerCli",
".",
"Client",
"(",
")",
".",
"ServiceList",
"(",
"context",
".",
"Background",
"(",
")",
",",
"types",
".",
"ServiceListOptions",
"{",
"Filters",
":",
"getAllStacksFilter",
"(",
")",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"formatter",
".",
"Stack",
")",
"\n",
"for",
"_",
",",
"service",
":=",
"range",
"services",
"{",
"labels",
":=",
"service",
".",
"Spec",
".",
"Labels",
"\n",
"name",
",",
"ok",
":=",
"labels",
"[",
"convert",
".",
"LabelNamespace",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"convert",
".",
"LabelNamespace",
",",
"service",
".",
"ID",
")",
"\n",
"}",
"\n",
"ztack",
",",
"ok",
":=",
"m",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"m",
"[",
"name",
"]",
"=",
"&",
"formatter",
".",
"Stack",
"{",
"Name",
":",
"name",
",",
"Services",
":",
"1",
",",
"Orchestrator",
":",
"\"",
"\"",
",",
"}",
"\n",
"}",
"else",
"{",
"ztack",
".",
"Services",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"stacks",
"[",
"]",
"*",
"formatter",
".",
"Stack",
"\n",
"for",
"_",
",",
"stack",
":=",
"range",
"m",
"{",
"stacks",
"=",
"append",
"(",
"stacks",
",",
"stack",
")",
"\n",
"}",
"\n",
"return",
"stacks",
",",
"nil",
"\n",
"}"
] | // GetStacks lists the swarm stacks. | [
"GetStacks",
"lists",
"the",
"swarm",
"stacks",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/stack/swarm/list.go#L14-L45 | train |
docker/cli | cli/command/formatter/image.go | NewImageFormat | func NewImageFormat(source string, quiet bool, digest bool) Format {
switch source {
case TableFormatKey:
switch {
case quiet:
return DefaultQuietFormat
case digest:
return defaultImageTableFormatWithDigest
default:
return defaultImageTableFormat
}
case RawFormatKey:
switch {
case quiet:
return `image_id: {{.ID}}`
case digest:
return `repository: {{ .Repository }}
tag: {{.Tag}}
digest: {{.Digest}}
image_id: {{.ID}}
created_at: {{.CreatedAt}}
virtual_size: {{.Size}}
`
default:
return `repository: {{ .Repository }}
tag: {{.Tag}}
image_id: {{.ID}}
created_at: {{.CreatedAt}}
virtual_size: {{.Size}}
`
}
}
format := Format(source)
if format.IsTable() && digest && !format.Contains("{{.Digest}}") {
format += "\t{{.Digest}}"
}
return format
} | go | func NewImageFormat(source string, quiet bool, digest bool) Format {
switch source {
case TableFormatKey:
switch {
case quiet:
return DefaultQuietFormat
case digest:
return defaultImageTableFormatWithDigest
default:
return defaultImageTableFormat
}
case RawFormatKey:
switch {
case quiet:
return `image_id: {{.ID}}`
case digest:
return `repository: {{ .Repository }}
tag: {{.Tag}}
digest: {{.Digest}}
image_id: {{.ID}}
created_at: {{.CreatedAt}}
virtual_size: {{.Size}}
`
default:
return `repository: {{ .Repository }}
tag: {{.Tag}}
image_id: {{.ID}}
created_at: {{.CreatedAt}}
virtual_size: {{.Size}}
`
}
}
format := Format(source)
if format.IsTable() && digest && !format.Contains("{{.Digest}}") {
format += "\t{{.Digest}}"
}
return format
} | [
"func",
"NewImageFormat",
"(",
"source",
"string",
",",
"quiet",
"bool",
",",
"digest",
"bool",
")",
"Format",
"{",
"switch",
"source",
"{",
"case",
"TableFormatKey",
":",
"switch",
"{",
"case",
"quiet",
":",
"return",
"DefaultQuietFormat",
"\n",
"case",
"digest",
":",
"return",
"defaultImageTableFormatWithDigest",
"\n",
"default",
":",
"return",
"defaultImageTableFormat",
"\n",
"}",
"\n",
"case",
"RawFormatKey",
":",
"switch",
"{",
"case",
"quiet",
":",
"return",
"`image_id: {{.ID}}`",
"\n",
"case",
"digest",
":",
"return",
"`repository: {{ .Repository }}\ntag: {{.Tag}}\ndigest: {{.Digest}}\nimage_id: {{.ID}}\ncreated_at: {{.CreatedAt}}\nvirtual_size: {{.Size}}\n`",
"\n",
"default",
":",
"return",
"`repository: {{ .Repository }}\ntag: {{.Tag}}\nimage_id: {{.ID}}\ncreated_at: {{.CreatedAt}}\nvirtual_size: {{.Size}}\n`",
"\n",
"}",
"\n",
"}",
"\n\n",
"format",
":=",
"Format",
"(",
"source",
")",
"\n",
"if",
"format",
".",
"IsTable",
"(",
")",
"&&",
"digest",
"&&",
"!",
"format",
".",
"Contains",
"(",
"\"",
"\"",
")",
"{",
"format",
"+=",
"\"",
"\\t",
"\"",
"\n",
"}",
"\n",
"return",
"format",
"\n",
"}"
] | // NewImageFormat returns a format for rendering an ImageContext | [
"NewImageFormat",
"returns",
"a",
"format",
"for",
"rendering",
"an",
"ImageContext"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/formatter/image.go#L34-L72 | train |
docker/cli | cli/command/formatter/image.go | ImageWrite | func ImageWrite(ctx ImageContext, images []types.ImageSummary) error {
render := func(format func(subContext SubContext) error) error {
return imageFormat(ctx, images, format)
}
return ctx.Write(newImageContext(), render)
} | go | func ImageWrite(ctx ImageContext, images []types.ImageSummary) error {
render := func(format func(subContext SubContext) error) error {
return imageFormat(ctx, images, format)
}
return ctx.Write(newImageContext(), render)
} | [
"func",
"ImageWrite",
"(",
"ctx",
"ImageContext",
",",
"images",
"[",
"]",
"types",
".",
"ImageSummary",
")",
"error",
"{",
"render",
":=",
"func",
"(",
"format",
"func",
"(",
"subContext",
"SubContext",
")",
"error",
")",
"error",
"{",
"return",
"imageFormat",
"(",
"ctx",
",",
"images",
",",
"format",
")",
"\n",
"}",
"\n",
"return",
"ctx",
".",
"Write",
"(",
"newImageContext",
"(",
")",
",",
"render",
")",
"\n",
"}"
] | // ImageWrite writes the formatter images using the ImageContext | [
"ImageWrite",
"writes",
"the",
"formatter",
"images",
"using",
"the",
"ImageContext"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/formatter/image.go#L75-L80 | train |
docker/cli | cli/config/credentials/file_store.go | Erase | func (c *fileStore) Erase(serverAddress string) error {
delete(c.file.GetAuthConfigs(), serverAddress)
return c.file.Save()
} | go | func (c *fileStore) Erase(serverAddress string) error {
delete(c.file.GetAuthConfigs(), serverAddress)
return c.file.Save()
} | [
"func",
"(",
"c",
"*",
"fileStore",
")",
"Erase",
"(",
"serverAddress",
"string",
")",
"error",
"{",
"delete",
"(",
"c",
".",
"file",
".",
"GetAuthConfigs",
"(",
")",
",",
"serverAddress",
")",
"\n",
"return",
"c",
".",
"file",
".",
"Save",
"(",
")",
"\n",
"}"
] | // Erase removes the given credentials from the file store. | [
"Erase",
"removes",
"the",
"given",
"credentials",
"from",
"the",
"file",
"store",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/config/credentials/file_store.go#L27-L30 | train |
docker/cli | cli/config/credentials/file_store.go | Get | func (c *fileStore) Get(serverAddress string) (types.AuthConfig, error) {
authConfig, ok := c.file.GetAuthConfigs()[serverAddress]
if !ok {
// Maybe they have a legacy config file, we will iterate the keys converting
// them to the new format and testing
for r, ac := range c.file.GetAuthConfigs() {
if serverAddress == ConvertToHostname(r) {
return ac, nil
}
}
authConfig = types.AuthConfig{}
}
return authConfig, nil
} | go | func (c *fileStore) Get(serverAddress string) (types.AuthConfig, error) {
authConfig, ok := c.file.GetAuthConfigs()[serverAddress]
if !ok {
// Maybe they have a legacy config file, we will iterate the keys converting
// them to the new format and testing
for r, ac := range c.file.GetAuthConfigs() {
if serverAddress == ConvertToHostname(r) {
return ac, nil
}
}
authConfig = types.AuthConfig{}
}
return authConfig, nil
} | [
"func",
"(",
"c",
"*",
"fileStore",
")",
"Get",
"(",
"serverAddress",
"string",
")",
"(",
"types",
".",
"AuthConfig",
",",
"error",
")",
"{",
"authConfig",
",",
"ok",
":=",
"c",
".",
"file",
".",
"GetAuthConfigs",
"(",
")",
"[",
"serverAddress",
"]",
"\n",
"if",
"!",
"ok",
"{",
"// Maybe they have a legacy config file, we will iterate the keys converting",
"// them to the new format and testing",
"for",
"r",
",",
"ac",
":=",
"range",
"c",
".",
"file",
".",
"GetAuthConfigs",
"(",
")",
"{",
"if",
"serverAddress",
"==",
"ConvertToHostname",
"(",
"r",
")",
"{",
"return",
"ac",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"authConfig",
"=",
"types",
".",
"AuthConfig",
"{",
"}",
"\n",
"}",
"\n",
"return",
"authConfig",
",",
"nil",
"\n",
"}"
] | // Get retrieves credentials for a specific server from the file store. | [
"Get",
"retrieves",
"credentials",
"for",
"a",
"specific",
"server",
"from",
"the",
"file",
"store",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/config/credentials/file_store.go#L33-L47 | train |
docker/cli | cli/command/service/generic_resource_opts.go | ParseGenericResources | func ParseGenericResources(value []string) ([]swarm.GenericResource, error) {
if len(value) == 0 {
return nil, nil
}
resources, err := genericresource.Parse(value)
if err != nil {
return nil, errors.Wrapf(err, "invalid generic resource specification")
}
swarmResources := genericResourcesFromGRPC(resources)
for _, res := range swarmResources {
if res.NamedResourceSpec != nil {
return nil, fmt.Errorf("invalid generic-resource request `%s=%s`, Named Generic Resources is not supported for service create or update", res.NamedResourceSpec.Kind, res.NamedResourceSpec.Value)
}
}
return swarmResources, nil
} | go | func ParseGenericResources(value []string) ([]swarm.GenericResource, error) {
if len(value) == 0 {
return nil, nil
}
resources, err := genericresource.Parse(value)
if err != nil {
return nil, errors.Wrapf(err, "invalid generic resource specification")
}
swarmResources := genericResourcesFromGRPC(resources)
for _, res := range swarmResources {
if res.NamedResourceSpec != nil {
return nil, fmt.Errorf("invalid generic-resource request `%s=%s`, Named Generic Resources is not supported for service create or update", res.NamedResourceSpec.Kind, res.NamedResourceSpec.Value)
}
}
return swarmResources, nil
} | [
"func",
"ParseGenericResources",
"(",
"value",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"swarm",
".",
"GenericResource",
",",
"error",
")",
"{",
"if",
"len",
"(",
"value",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"resources",
",",
"err",
":=",
"genericresource",
".",
"Parse",
"(",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"swarmResources",
":=",
"genericResourcesFromGRPC",
"(",
"resources",
")",
"\n",
"for",
"_",
",",
"res",
":=",
"range",
"swarmResources",
"{",
"if",
"res",
".",
"NamedResourceSpec",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"NamedResourceSpec",
".",
"Kind",
",",
"res",
".",
"NamedResourceSpec",
".",
"Value",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"swarmResources",
",",
"nil",
"\n",
"}"
] | // ParseGenericResources parses an array of Generic resourceResources
// Requesting Named Generic Resources for a service is not supported this
// is filtered here. | [
"ParseGenericResources",
"parses",
"an",
"array",
"of",
"Generic",
"resourceResources",
"Requesting",
"Named",
"Generic",
"Resources",
"for",
"a",
"service",
"is",
"not",
"supported",
"this",
"is",
"filtered",
"here",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/service/generic_resource_opts.go#L33-L51 | train |
docker/cli | cli/command/service/generic_resource_opts.go | genericResourcesFromGRPC | func genericResourcesFromGRPC(genericRes []*swarmapi.GenericResource) []swarm.GenericResource {
var generic []swarm.GenericResource
for _, res := range genericRes {
var current swarm.GenericResource
switch r := res.Resource.(type) {
case *swarmapi.GenericResource_DiscreteResourceSpec:
current.DiscreteResourceSpec = &swarm.DiscreteGenericResource{
Kind: r.DiscreteResourceSpec.Kind,
Value: r.DiscreteResourceSpec.Value,
}
case *swarmapi.GenericResource_NamedResourceSpec:
current.NamedResourceSpec = &swarm.NamedGenericResource{
Kind: r.NamedResourceSpec.Kind,
Value: r.NamedResourceSpec.Value,
}
}
generic = append(generic, current)
}
return generic
} | go | func genericResourcesFromGRPC(genericRes []*swarmapi.GenericResource) []swarm.GenericResource {
var generic []swarm.GenericResource
for _, res := range genericRes {
var current swarm.GenericResource
switch r := res.Resource.(type) {
case *swarmapi.GenericResource_DiscreteResourceSpec:
current.DiscreteResourceSpec = &swarm.DiscreteGenericResource{
Kind: r.DiscreteResourceSpec.Kind,
Value: r.DiscreteResourceSpec.Value,
}
case *swarmapi.GenericResource_NamedResourceSpec:
current.NamedResourceSpec = &swarm.NamedGenericResource{
Kind: r.NamedResourceSpec.Kind,
Value: r.NamedResourceSpec.Value,
}
}
generic = append(generic, current)
}
return generic
} | [
"func",
"genericResourcesFromGRPC",
"(",
"genericRes",
"[",
"]",
"*",
"swarmapi",
".",
"GenericResource",
")",
"[",
"]",
"swarm",
".",
"GenericResource",
"{",
"var",
"generic",
"[",
"]",
"swarm",
".",
"GenericResource",
"\n",
"for",
"_",
",",
"res",
":=",
"range",
"genericRes",
"{",
"var",
"current",
"swarm",
".",
"GenericResource",
"\n\n",
"switch",
"r",
":=",
"res",
".",
"Resource",
".",
"(",
"type",
")",
"{",
"case",
"*",
"swarmapi",
".",
"GenericResource_DiscreteResourceSpec",
":",
"current",
".",
"DiscreteResourceSpec",
"=",
"&",
"swarm",
".",
"DiscreteGenericResource",
"{",
"Kind",
":",
"r",
".",
"DiscreteResourceSpec",
".",
"Kind",
",",
"Value",
":",
"r",
".",
"DiscreteResourceSpec",
".",
"Value",
",",
"}",
"\n",
"case",
"*",
"swarmapi",
".",
"GenericResource_NamedResourceSpec",
":",
"current",
".",
"NamedResourceSpec",
"=",
"&",
"swarm",
".",
"NamedGenericResource",
"{",
"Kind",
":",
"r",
".",
"NamedResourceSpec",
".",
"Kind",
",",
"Value",
":",
"r",
".",
"NamedResourceSpec",
".",
"Value",
",",
"}",
"\n",
"}",
"\n\n",
"generic",
"=",
"append",
"(",
"generic",
",",
"current",
")",
"\n",
"}",
"\n\n",
"return",
"generic",
"\n",
"}"
] | // genericResourcesFromGRPC converts a GRPC GenericResource to a GenericResource | [
"genericResourcesFromGRPC",
"converts",
"a",
"GRPC",
"GenericResource",
"to",
"a",
"GenericResource"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/service/generic_resource_opts.go#L54-L76 | train |
docker/cli | cli/context/kubernetes/load.go | KubernetesConfig | func (c *Endpoint) KubernetesConfig() clientcmd.ClientConfig {
cfg := clientcmdapi.NewConfig()
cluster := clientcmdapi.NewCluster()
cluster.Server = c.Host
cluster.InsecureSkipTLSVerify = c.SkipTLSVerify
authInfo := clientcmdapi.NewAuthInfo()
if c.TLSData != nil {
cluster.CertificateAuthorityData = c.TLSData.CA
authInfo.ClientCertificateData = c.TLSData.Cert
authInfo.ClientKeyData = c.TLSData.Key
}
authInfo.AuthProvider = c.AuthProvider
authInfo.Exec = c.Exec
cfg.Clusters["cluster"] = cluster
cfg.AuthInfos["authInfo"] = authInfo
ctx := clientcmdapi.NewContext()
ctx.AuthInfo = "authInfo"
ctx.Cluster = "cluster"
ctx.Namespace = c.DefaultNamespace
cfg.Contexts["context"] = ctx
cfg.CurrentContext = "context"
return clientcmd.NewDefaultClientConfig(*cfg, &clientcmd.ConfigOverrides{})
} | go | func (c *Endpoint) KubernetesConfig() clientcmd.ClientConfig {
cfg := clientcmdapi.NewConfig()
cluster := clientcmdapi.NewCluster()
cluster.Server = c.Host
cluster.InsecureSkipTLSVerify = c.SkipTLSVerify
authInfo := clientcmdapi.NewAuthInfo()
if c.TLSData != nil {
cluster.CertificateAuthorityData = c.TLSData.CA
authInfo.ClientCertificateData = c.TLSData.Cert
authInfo.ClientKeyData = c.TLSData.Key
}
authInfo.AuthProvider = c.AuthProvider
authInfo.Exec = c.Exec
cfg.Clusters["cluster"] = cluster
cfg.AuthInfos["authInfo"] = authInfo
ctx := clientcmdapi.NewContext()
ctx.AuthInfo = "authInfo"
ctx.Cluster = "cluster"
ctx.Namespace = c.DefaultNamespace
cfg.Contexts["context"] = ctx
cfg.CurrentContext = "context"
return clientcmd.NewDefaultClientConfig(*cfg, &clientcmd.ConfigOverrides{})
} | [
"func",
"(",
"c",
"*",
"Endpoint",
")",
"KubernetesConfig",
"(",
")",
"clientcmd",
".",
"ClientConfig",
"{",
"cfg",
":=",
"clientcmdapi",
".",
"NewConfig",
"(",
")",
"\n",
"cluster",
":=",
"clientcmdapi",
".",
"NewCluster",
"(",
")",
"\n",
"cluster",
".",
"Server",
"=",
"c",
".",
"Host",
"\n",
"cluster",
".",
"InsecureSkipTLSVerify",
"=",
"c",
".",
"SkipTLSVerify",
"\n",
"authInfo",
":=",
"clientcmdapi",
".",
"NewAuthInfo",
"(",
")",
"\n",
"if",
"c",
".",
"TLSData",
"!=",
"nil",
"{",
"cluster",
".",
"CertificateAuthorityData",
"=",
"c",
".",
"TLSData",
".",
"CA",
"\n",
"authInfo",
".",
"ClientCertificateData",
"=",
"c",
".",
"TLSData",
".",
"Cert",
"\n",
"authInfo",
".",
"ClientKeyData",
"=",
"c",
".",
"TLSData",
".",
"Key",
"\n",
"}",
"\n",
"authInfo",
".",
"AuthProvider",
"=",
"c",
".",
"AuthProvider",
"\n",
"authInfo",
".",
"Exec",
"=",
"c",
".",
"Exec",
"\n",
"cfg",
".",
"Clusters",
"[",
"\"",
"\"",
"]",
"=",
"cluster",
"\n",
"cfg",
".",
"AuthInfos",
"[",
"\"",
"\"",
"]",
"=",
"authInfo",
"\n",
"ctx",
":=",
"clientcmdapi",
".",
"NewContext",
"(",
")",
"\n",
"ctx",
".",
"AuthInfo",
"=",
"\"",
"\"",
"\n",
"ctx",
".",
"Cluster",
"=",
"\"",
"\"",
"\n",
"ctx",
".",
"Namespace",
"=",
"c",
".",
"DefaultNamespace",
"\n",
"cfg",
".",
"Contexts",
"[",
"\"",
"\"",
"]",
"=",
"ctx",
"\n",
"cfg",
".",
"CurrentContext",
"=",
"\"",
"\"",
"\n",
"return",
"clientcmd",
".",
"NewDefaultClientConfig",
"(",
"*",
"cfg",
",",
"&",
"clientcmd",
".",
"ConfigOverrides",
"{",
"}",
")",
"\n",
"}"
] | // KubernetesConfig creates the kubernetes client config from the endpoint | [
"KubernetesConfig",
"creates",
"the",
"kubernetes",
"client",
"config",
"from",
"the",
"endpoint"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/context/kubernetes/load.go#L40-L62 | train |
docker/cli | cli/context/kubernetes/load.go | EndpointFromContext | func EndpointFromContext(metadata store.Metadata) *EndpointMeta {
ep, ok := metadata.Endpoints[KubernetesEndpoint]
if !ok {
return nil
}
typed, ok := ep.(EndpointMeta)
if !ok {
return nil
}
return &typed
} | go | func EndpointFromContext(metadata store.Metadata) *EndpointMeta {
ep, ok := metadata.Endpoints[KubernetesEndpoint]
if !ok {
return nil
}
typed, ok := ep.(EndpointMeta)
if !ok {
return nil
}
return &typed
} | [
"func",
"EndpointFromContext",
"(",
"metadata",
"store",
".",
"Metadata",
")",
"*",
"EndpointMeta",
"{",
"ep",
",",
"ok",
":=",
"metadata",
".",
"Endpoints",
"[",
"KubernetesEndpoint",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"typed",
",",
"ok",
":=",
"ep",
".",
"(",
"EndpointMeta",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"typed",
"\n",
"}"
] | // EndpointFromContext extracts kubernetes endpoint info from current context | [
"EndpointFromContext",
"extracts",
"kubernetes",
"endpoint",
"info",
"from",
"current",
"context"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/context/kubernetes/load.go#L65-L75 | train |
docker/cli | cli/context/kubernetes/load.go | ConfigFromContext | func ConfigFromContext(name string, s store.Reader) (clientcmd.ClientConfig, error) {
ctxMeta, err := s.GetMetadata(name)
if err != nil {
return nil, err
}
epMeta := EndpointFromContext(ctxMeta)
if epMeta != nil {
ep, err := epMeta.WithTLSData(s, name)
if err != nil {
return nil, err
}
return ep.KubernetesConfig(), nil
}
// context has no kubernetes endpoint
return kubernetes.NewKubernetesConfig(""), nil
} | go | func ConfigFromContext(name string, s store.Reader) (clientcmd.ClientConfig, error) {
ctxMeta, err := s.GetMetadata(name)
if err != nil {
return nil, err
}
epMeta := EndpointFromContext(ctxMeta)
if epMeta != nil {
ep, err := epMeta.WithTLSData(s, name)
if err != nil {
return nil, err
}
return ep.KubernetesConfig(), nil
}
// context has no kubernetes endpoint
return kubernetes.NewKubernetesConfig(""), nil
} | [
"func",
"ConfigFromContext",
"(",
"name",
"string",
",",
"s",
"store",
".",
"Reader",
")",
"(",
"clientcmd",
".",
"ClientConfig",
",",
"error",
")",
"{",
"ctxMeta",
",",
"err",
":=",
"s",
".",
"GetMetadata",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"epMeta",
":=",
"EndpointFromContext",
"(",
"ctxMeta",
")",
"\n",
"if",
"epMeta",
"!=",
"nil",
"{",
"ep",
",",
"err",
":=",
"epMeta",
".",
"WithTLSData",
"(",
"s",
",",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"ep",
".",
"KubernetesConfig",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"// context has no kubernetes endpoint",
"return",
"kubernetes",
".",
"NewKubernetesConfig",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // ConfigFromContext resolves a kubernetes client config for the specified context.
// If kubeconfigOverride is specified, use this config file instead of the context defaults.ConfigFromContext
// if command.ContextDockerHost is specified as the context name, fallsback to the default user's kubeconfig file | [
"ConfigFromContext",
"resolves",
"a",
"kubernetes",
"client",
"config",
"for",
"the",
"specified",
"context",
".",
"If",
"kubeconfigOverride",
"is",
"specified",
"use",
"this",
"config",
"file",
"instead",
"of",
"the",
"context",
"defaults",
".",
"ConfigFromContext",
"if",
"command",
".",
"ContextDockerHost",
"is",
"specified",
"as",
"the",
"context",
"name",
"fallsback",
"to",
"the",
"default",
"user",
"s",
"kubeconfig",
"file"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/context/kubernetes/load.go#L80-L95 | train |
docker/cli | cli/connhelper/ssh/ssh.go | ParseURL | func ParseURL(daemonURL string) (*Spec, error) {
u, err := url.Parse(daemonURL)
if err != nil {
return nil, err
}
if u.Scheme != "ssh" {
return nil, errors.Errorf("expected scheme ssh, got %q", u.Scheme)
}
var sp Spec
if u.User != nil {
sp.User = u.User.Username()
if _, ok := u.User.Password(); ok {
return nil, errors.New("plain-text password is not supported")
}
}
sp.Host = u.Hostname()
if sp.Host == "" {
return nil, errors.Errorf("no host specified")
}
sp.Port = u.Port()
if u.Path != "" {
return nil, errors.Errorf("extra path after the host: %q", u.Path)
}
if u.RawQuery != "" {
return nil, errors.Errorf("extra query after the host: %q", u.RawQuery)
}
if u.Fragment != "" {
return nil, errors.Errorf("extra fragment after the host: %q", u.Fragment)
}
return &sp, err
} | go | func ParseURL(daemonURL string) (*Spec, error) {
u, err := url.Parse(daemonURL)
if err != nil {
return nil, err
}
if u.Scheme != "ssh" {
return nil, errors.Errorf("expected scheme ssh, got %q", u.Scheme)
}
var sp Spec
if u.User != nil {
sp.User = u.User.Username()
if _, ok := u.User.Password(); ok {
return nil, errors.New("plain-text password is not supported")
}
}
sp.Host = u.Hostname()
if sp.Host == "" {
return nil, errors.Errorf("no host specified")
}
sp.Port = u.Port()
if u.Path != "" {
return nil, errors.Errorf("extra path after the host: %q", u.Path)
}
if u.RawQuery != "" {
return nil, errors.Errorf("extra query after the host: %q", u.RawQuery)
}
if u.Fragment != "" {
return nil, errors.Errorf("extra fragment after the host: %q", u.Fragment)
}
return &sp, err
} | [
"func",
"ParseURL",
"(",
"daemonURL",
"string",
")",
"(",
"*",
"Spec",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"daemonURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"u",
".",
"Scheme",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"u",
".",
"Scheme",
")",
"\n",
"}",
"\n\n",
"var",
"sp",
"Spec",
"\n\n",
"if",
"u",
".",
"User",
"!=",
"nil",
"{",
"sp",
".",
"User",
"=",
"u",
".",
"User",
".",
"Username",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"u",
".",
"User",
".",
"Password",
"(",
")",
";",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"sp",
".",
"Host",
"=",
"u",
".",
"Hostname",
"(",
")",
"\n",
"if",
"sp",
".",
"Host",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"sp",
".",
"Port",
"=",
"u",
".",
"Port",
"(",
")",
"\n",
"if",
"u",
".",
"Path",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"u",
".",
"Path",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"RawQuery",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"u",
".",
"RawQuery",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"Fragment",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"u",
".",
"Fragment",
")",
"\n",
"}",
"\n",
"return",
"&",
"sp",
",",
"err",
"\n",
"}"
] | // ParseURL parses URL | [
"ParseURL",
"parses",
"URL"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/connhelper/ssh/ssh.go#L11-L43 | train |
docker/cli | cli/compose/interpolation/interpolation.go | Interpolate | func Interpolate(config map[string]interface{}, opts Options) (map[string]interface{}, error) {
if opts.LookupValue == nil {
opts.LookupValue = os.LookupEnv
}
if opts.TypeCastMapping == nil {
opts.TypeCastMapping = make(map[Path]Cast)
}
if opts.Substitute == nil {
opts.Substitute = template.Substitute
}
out := map[string]interface{}{}
for key, value := range config {
interpolatedValue, err := recursiveInterpolate(value, NewPath(key), opts)
if err != nil {
return out, err
}
out[key] = interpolatedValue
}
return out, nil
} | go | func Interpolate(config map[string]interface{}, opts Options) (map[string]interface{}, error) {
if opts.LookupValue == nil {
opts.LookupValue = os.LookupEnv
}
if opts.TypeCastMapping == nil {
opts.TypeCastMapping = make(map[Path]Cast)
}
if opts.Substitute == nil {
opts.Substitute = template.Substitute
}
out := map[string]interface{}{}
for key, value := range config {
interpolatedValue, err := recursiveInterpolate(value, NewPath(key), opts)
if err != nil {
return out, err
}
out[key] = interpolatedValue
}
return out, nil
} | [
"func",
"Interpolate",
"(",
"config",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"opts",
"Options",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"opts",
".",
"LookupValue",
"==",
"nil",
"{",
"opts",
".",
"LookupValue",
"=",
"os",
".",
"LookupEnv",
"\n",
"}",
"\n",
"if",
"opts",
".",
"TypeCastMapping",
"==",
"nil",
"{",
"opts",
".",
"TypeCastMapping",
"=",
"make",
"(",
"map",
"[",
"Path",
"]",
"Cast",
")",
"\n",
"}",
"\n",
"if",
"opts",
".",
"Substitute",
"==",
"nil",
"{",
"opts",
".",
"Substitute",
"=",
"template",
".",
"Substitute",
"\n",
"}",
"\n\n",
"out",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n\n",
"for",
"key",
",",
"value",
":=",
"range",
"config",
"{",
"interpolatedValue",
",",
"err",
":=",
"recursiveInterpolate",
"(",
"value",
",",
"NewPath",
"(",
"key",
")",
",",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"out",
",",
"err",
"\n",
"}",
"\n",
"out",
"[",
"key",
"]",
"=",
"interpolatedValue",
"\n",
"}",
"\n\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // Interpolate replaces variables in a string with the values from a mapping | [
"Interpolate",
"replaces",
"variables",
"in",
"a",
"string",
"with",
"the",
"values",
"from",
"a",
"mapping"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/compose/interpolation/interpolation.go#L31-L53 | train |
docker/cli | cli/compose/interpolation/interpolation.go | Next | func (p Path) Next(part string) Path {
return Path(string(p) + pathSeparator + part)
} | go | func (p Path) Next(part string) Path {
return Path(string(p) + pathSeparator + part)
} | [
"func",
"(",
"p",
"Path",
")",
"Next",
"(",
"part",
"string",
")",
"Path",
"{",
"return",
"Path",
"(",
"string",
"(",
"p",
")",
"+",
"pathSeparator",
"+",
"part",
")",
"\n",
"}"
] | // Next returns a new path by append part to the current path | [
"Next",
"returns",
"a",
"new",
"path",
"by",
"append",
"part",
"to",
"the",
"current",
"path"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/compose/interpolation/interpolation.go#L130-L132 | train |
docker/cli | internal/licenseutils/utils.go | GetOrgByID | func (u HubUser) GetOrgByID(orgID string) (model.Org, error) {
for _, org := range u.Orgs {
if org.ID == orgID {
return org, nil
}
}
return model.Org{}, fmt.Errorf("org %s not found", orgID)
} | go | func (u HubUser) GetOrgByID(orgID string) (model.Org, error) {
for _, org := range u.Orgs {
if org.ID == orgID {
return org, nil
}
}
return model.Org{}, fmt.Errorf("org %s not found", orgID)
} | [
"func",
"(",
"u",
"HubUser",
")",
"GetOrgByID",
"(",
"orgID",
"string",
")",
"(",
"model",
".",
"Org",
",",
"error",
")",
"{",
"for",
"_",
",",
"org",
":=",
"range",
"u",
".",
"Orgs",
"{",
"if",
"org",
".",
"ID",
"==",
"orgID",
"{",
"return",
"org",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"model",
".",
"Org",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"orgID",
")",
"\n",
"}"
] | //GetOrgByID finds the org by the ID in the users list of orgs | [
"GetOrgByID",
"finds",
"the",
"org",
"by",
"the",
"ID",
"in",
"the",
"users",
"list",
"of",
"orgs"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L30-L37 | train |
docker/cli | internal/licenseutils/utils.go | Login | func Login(ctx context.Context, authConfig *types.AuthConfig) (HubUser, error) {
lclient, err := getClient()
if err != nil {
return HubUser{}, err
}
// For licensing we know they must have a valid login session
if authConfig.Username == "" {
return HubUser{}, fmt.Errorf("you must be logged in to access licenses. Please use 'docker login' then try again")
}
token, err := lclient.LoginViaAuth(ctx, authConfig.Username, authConfig.Password)
if err != nil {
return HubUser{}, err
}
user, err := lclient.GetHubUserByName(ctx, authConfig.Username)
if err != nil {
return HubUser{}, err
}
orgs, err := lclient.GetHubUserOrgs(ctx, token)
if err != nil {
return HubUser{}, err
}
return HubUser{
Client: lclient,
token: token,
User: *user,
Orgs: orgs,
}, nil
} | go | func Login(ctx context.Context, authConfig *types.AuthConfig) (HubUser, error) {
lclient, err := getClient()
if err != nil {
return HubUser{}, err
}
// For licensing we know they must have a valid login session
if authConfig.Username == "" {
return HubUser{}, fmt.Errorf("you must be logged in to access licenses. Please use 'docker login' then try again")
}
token, err := lclient.LoginViaAuth(ctx, authConfig.Username, authConfig.Password)
if err != nil {
return HubUser{}, err
}
user, err := lclient.GetHubUserByName(ctx, authConfig.Username)
if err != nil {
return HubUser{}, err
}
orgs, err := lclient.GetHubUserOrgs(ctx, token)
if err != nil {
return HubUser{}, err
}
return HubUser{
Client: lclient,
token: token,
User: *user,
Orgs: orgs,
}, nil
} | [
"func",
"Login",
"(",
"ctx",
"context",
".",
"Context",
",",
"authConfig",
"*",
"types",
".",
"AuthConfig",
")",
"(",
"HubUser",
",",
"error",
")",
"{",
"lclient",
",",
"err",
":=",
"getClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"HubUser",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"// For licensing we know they must have a valid login session",
"if",
"authConfig",
".",
"Username",
"==",
"\"",
"\"",
"{",
"return",
"HubUser",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"token",
",",
"err",
":=",
"lclient",
".",
"LoginViaAuth",
"(",
"ctx",
",",
"authConfig",
".",
"Username",
",",
"authConfig",
".",
"Password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"HubUser",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"lclient",
".",
"GetHubUserByName",
"(",
"ctx",
",",
"authConfig",
".",
"Username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"HubUser",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"orgs",
",",
"err",
":=",
"lclient",
".",
"GetHubUserOrgs",
"(",
"ctx",
",",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"HubUser",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"HubUser",
"{",
"Client",
":",
"lclient",
",",
"token",
":",
"token",
",",
"User",
":",
"*",
"user",
",",
"Orgs",
":",
"orgs",
",",
"}",
",",
"nil",
"\n\n",
"}"
] | // Login to the license server and return a client that can be used to look up and download license files or generate new trial licenses | [
"Login",
"to",
"the",
"license",
"server",
"and",
"return",
"a",
"client",
"that",
"can",
"be",
"used",
"to",
"look",
"up",
"and",
"download",
"license",
"files",
"or",
"generate",
"new",
"trial",
"licenses"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L53-L82 | train |
docker/cli | internal/licenseutils/utils.go | GetAvailableLicenses | func (u HubUser) GetAvailableLicenses(ctx context.Context) ([]LicenseDisplay, error) {
subs, err := u.Client.ListSubscriptions(ctx, u.token, u.User.ID)
if err != nil {
return nil, err
}
for _, org := range u.Orgs {
orgSub, err := u.Client.ListSubscriptions(ctx, u.token, org.ID)
if err != nil {
return nil, err
}
subs = append(subs, orgSub...)
}
// Convert the SubscriptionDetails to a more user-friendly type to render in the CLI
res := []LicenseDisplay{}
// Filter out expired licenses
i := 0
for _, s := range subs {
if s.State == "active" && s.Expires != nil {
owner := ""
if s.DockerID == u.User.ID {
owner = u.User.Username
} else {
ownerOrg, err := u.GetOrgByID(s.DockerID)
if err == nil {
owner = ownerOrg.Orgname
} else {
owner = "unknown"
logrus.Debugf("Unable to lookup org ID %s: %s", s.DockerID, err)
}
}
comps := []string{}
for _, pc := range s.PricingComponents {
comps = append(comps, fmt.Sprintf("%s:%d", pc.Name, pc.Value))
}
res = append(res, LicenseDisplay{
Subscription: *s,
Num: i,
Owner: owner,
ComponentsString: strings.Join(comps, ","),
})
i++
}
}
return res, nil
} | go | func (u HubUser) GetAvailableLicenses(ctx context.Context) ([]LicenseDisplay, error) {
subs, err := u.Client.ListSubscriptions(ctx, u.token, u.User.ID)
if err != nil {
return nil, err
}
for _, org := range u.Orgs {
orgSub, err := u.Client.ListSubscriptions(ctx, u.token, org.ID)
if err != nil {
return nil, err
}
subs = append(subs, orgSub...)
}
// Convert the SubscriptionDetails to a more user-friendly type to render in the CLI
res := []LicenseDisplay{}
// Filter out expired licenses
i := 0
for _, s := range subs {
if s.State == "active" && s.Expires != nil {
owner := ""
if s.DockerID == u.User.ID {
owner = u.User.Username
} else {
ownerOrg, err := u.GetOrgByID(s.DockerID)
if err == nil {
owner = ownerOrg.Orgname
} else {
owner = "unknown"
logrus.Debugf("Unable to lookup org ID %s: %s", s.DockerID, err)
}
}
comps := []string{}
for _, pc := range s.PricingComponents {
comps = append(comps, fmt.Sprintf("%s:%d", pc.Name, pc.Value))
}
res = append(res, LicenseDisplay{
Subscription: *s,
Num: i,
Owner: owner,
ComponentsString: strings.Join(comps, ","),
})
i++
}
}
return res, nil
} | [
"func",
"(",
"u",
"HubUser",
")",
"GetAvailableLicenses",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"LicenseDisplay",
",",
"error",
")",
"{",
"subs",
",",
"err",
":=",
"u",
".",
"Client",
".",
"ListSubscriptions",
"(",
"ctx",
",",
"u",
".",
"token",
",",
"u",
".",
"User",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"org",
":=",
"range",
"u",
".",
"Orgs",
"{",
"orgSub",
",",
"err",
":=",
"u",
".",
"Client",
".",
"ListSubscriptions",
"(",
"ctx",
",",
"u",
".",
"token",
",",
"org",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"subs",
"=",
"append",
"(",
"subs",
",",
"orgSub",
"...",
")",
"\n",
"}",
"\n\n",
"// Convert the SubscriptionDetails to a more user-friendly type to render in the CLI",
"res",
":=",
"[",
"]",
"LicenseDisplay",
"{",
"}",
"\n\n",
"// Filter out expired licenses",
"i",
":=",
"0",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"subs",
"{",
"if",
"s",
".",
"State",
"==",
"\"",
"\"",
"&&",
"s",
".",
"Expires",
"!=",
"nil",
"{",
"owner",
":=",
"\"",
"\"",
"\n",
"if",
"s",
".",
"DockerID",
"==",
"u",
".",
"User",
".",
"ID",
"{",
"owner",
"=",
"u",
".",
"User",
".",
"Username",
"\n",
"}",
"else",
"{",
"ownerOrg",
",",
"err",
":=",
"u",
".",
"GetOrgByID",
"(",
"s",
".",
"DockerID",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"owner",
"=",
"ownerOrg",
".",
"Orgname",
"\n",
"}",
"else",
"{",
"owner",
"=",
"\"",
"\"",
"\n",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"s",
".",
"DockerID",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"comps",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"pc",
":=",
"range",
"s",
".",
"PricingComponents",
"{",
"comps",
"=",
"append",
"(",
"comps",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pc",
".",
"Name",
",",
"pc",
".",
"Value",
")",
")",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"LicenseDisplay",
"{",
"Subscription",
":",
"*",
"s",
",",
"Num",
":",
"i",
",",
"Owner",
":",
"owner",
",",
"ComponentsString",
":",
"strings",
".",
"Join",
"(",
"comps",
",",
"\"",
"\"",
")",
",",
"}",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // GetAvailableLicenses finds all available licenses for a given account and their orgs | [
"GetAvailableLicenses",
"finds",
"all",
"available",
"licenses",
"for",
"a",
"given",
"account",
"and",
"their",
"orgs"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L85-L133 | train |
docker/cli | internal/licenseutils/utils.go | GenerateTrialLicense | func (u HubUser) GenerateTrialLicense(ctx context.Context, targetID string) (*model.IssuedLicense, error) {
subID, err := u.Client.GenerateNewTrialSubscription(ctx, u.token, targetID)
if err != nil {
return nil, err
}
return u.Client.DownloadLicenseFromHub(ctx, u.token, subID)
} | go | func (u HubUser) GenerateTrialLicense(ctx context.Context, targetID string) (*model.IssuedLicense, error) {
subID, err := u.Client.GenerateNewTrialSubscription(ctx, u.token, targetID)
if err != nil {
return nil, err
}
return u.Client.DownloadLicenseFromHub(ctx, u.token, subID)
} | [
"func",
"(",
"u",
"HubUser",
")",
"GenerateTrialLicense",
"(",
"ctx",
"context",
".",
"Context",
",",
"targetID",
"string",
")",
"(",
"*",
"model",
".",
"IssuedLicense",
",",
"error",
")",
"{",
"subID",
",",
"err",
":=",
"u",
".",
"Client",
".",
"GenerateNewTrialSubscription",
"(",
"ctx",
",",
"u",
".",
"token",
",",
"targetID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"u",
".",
"Client",
".",
"DownloadLicenseFromHub",
"(",
"ctx",
",",
"u",
".",
"token",
",",
"subID",
")",
"\n",
"}"
] | // GenerateTrialLicense will generate a new trial license for the specified user or org | [
"GenerateTrialLicense",
"will",
"generate",
"a",
"new",
"trial",
"license",
"for",
"the",
"specified",
"user",
"or",
"org"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L136-L142 | train |
docker/cli | internal/licenseutils/utils.go | GetIssuedLicense | func (u HubUser) GetIssuedLicense(ctx context.Context, ID string) (*model.IssuedLicense, error) {
return u.Client.DownloadLicenseFromHub(ctx, u.token, ID)
} | go | func (u HubUser) GetIssuedLicense(ctx context.Context, ID string) (*model.IssuedLicense, error) {
return u.Client.DownloadLicenseFromHub(ctx, u.token, ID)
} | [
"func",
"(",
"u",
"HubUser",
")",
"GetIssuedLicense",
"(",
"ctx",
"context",
".",
"Context",
",",
"ID",
"string",
")",
"(",
"*",
"model",
".",
"IssuedLicense",
",",
"error",
")",
"{",
"return",
"u",
".",
"Client",
".",
"DownloadLicenseFromHub",
"(",
"ctx",
",",
"u",
".",
"token",
",",
"ID",
")",
"\n",
"}"
] | // GetIssuedLicense will download a license by ID | [
"GetIssuedLicense",
"will",
"download",
"a",
"license",
"by",
"ID"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L145-L147 | train |
docker/cli | internal/licenseutils/utils.go | LoadLocalIssuedLicense | func LoadLocalIssuedLicense(ctx context.Context, filename string) (*model.IssuedLicense, error) {
lclient, err := getClient()
if err != nil {
return nil, err
}
return doLoadLocalIssuedLicense(ctx, filename, lclient)
} | go | func LoadLocalIssuedLicense(ctx context.Context, filename string) (*model.IssuedLicense, error) {
lclient, err := getClient()
if err != nil {
return nil, err
}
return doLoadLocalIssuedLicense(ctx, filename, lclient)
} | [
"func",
"LoadLocalIssuedLicense",
"(",
"ctx",
"context",
".",
"Context",
",",
"filename",
"string",
")",
"(",
"*",
"model",
".",
"IssuedLicense",
",",
"error",
")",
"{",
"lclient",
",",
"err",
":=",
"getClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"doLoadLocalIssuedLicense",
"(",
"ctx",
",",
"filename",
",",
"lclient",
")",
"\n",
"}"
] | // LoadLocalIssuedLicense will load a local license file | [
"LoadLocalIssuedLicense",
"will",
"load",
"a",
"local",
"license",
"file"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L150-L156 | train |
docker/cli | internal/licenseutils/utils.go | GetLicenseSummary | func GetLicenseSummary(ctx context.Context, license model.IssuedLicense) (string, error) {
lclient, err := getClient()
if err != nil {
return "", err
}
cr, err := lclient.VerifyLicense(ctx, license)
if err != nil {
return "", err
}
return lclient.SummarizeLicense(cr, license.KeyID).String(), nil
} | go | func GetLicenseSummary(ctx context.Context, license model.IssuedLicense) (string, error) {
lclient, err := getClient()
if err != nil {
return "", err
}
cr, err := lclient.VerifyLicense(ctx, license)
if err != nil {
return "", err
}
return lclient.SummarizeLicense(cr, license.KeyID).String(), nil
} | [
"func",
"GetLicenseSummary",
"(",
"ctx",
"context",
".",
"Context",
",",
"license",
"model",
".",
"IssuedLicense",
")",
"(",
"string",
",",
"error",
")",
"{",
"lclient",
",",
"err",
":=",
"getClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"cr",
",",
"err",
":=",
"lclient",
".",
"VerifyLicense",
"(",
"ctx",
",",
"license",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"lclient",
".",
"SummarizeLicense",
"(",
"cr",
",",
"license",
".",
"KeyID",
")",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] | // GetLicenseSummary summarizes the license for the user | [
"GetLicenseSummary",
"summarizes",
"the",
"license",
"for",
"the",
"user"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L159-L170 | train |
docker/cli | internal/licenseutils/utils.go | ApplyLicense | func ApplyLicense(ctx context.Context, dclient licensing.WrappedDockerClient, license *model.IssuedLicense) error {
info, err := dclient.Info(ctx)
if err != nil {
return err
}
return licensing.StoreLicense(ctx, dclient, license, info.DockerRootDir)
} | go | func ApplyLicense(ctx context.Context, dclient licensing.WrappedDockerClient, license *model.IssuedLicense) error {
info, err := dclient.Info(ctx)
if err != nil {
return err
}
return licensing.StoreLicense(ctx, dclient, license, info.DockerRootDir)
} | [
"func",
"ApplyLicense",
"(",
"ctx",
"context",
".",
"Context",
",",
"dclient",
"licensing",
".",
"WrappedDockerClient",
",",
"license",
"*",
"model",
".",
"IssuedLicense",
")",
"error",
"{",
"info",
",",
"err",
":=",
"dclient",
".",
"Info",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"licensing",
".",
"StoreLicense",
"(",
"ctx",
",",
"dclient",
",",
"license",
",",
"info",
".",
"DockerRootDir",
")",
"\n",
"}"
] | // ApplyLicense will store a license on the local system | [
"ApplyLicense",
"will",
"store",
"a",
"license",
"on",
"the",
"local",
"system"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/licenseutils/utils.go#L196-L202 | train |
docker/cli | cli/command/registry.go | RegistryAuthenticationPrivilegedFunc | func RegistryAuthenticationPrivilegedFunc(cli Cli, index *registrytypes.IndexInfo, cmdName string) types.RequestPrivilegeFunc {
return func() (string, error) {
fmt.Fprintf(cli.Out(), "\nPlease login prior to %s:\n", cmdName)
indexServer := registry.GetAuthConfigKey(index)
isDefaultRegistry := indexServer == ElectAuthServer(context.Background(), cli)
authConfig, err := GetDefaultAuthConfig(cli, true, indexServer, isDefaultRegistry)
if err != nil {
fmt.Fprintf(cli.Err(), "Unable to retrieve stored credentials for %s, error: %s.\n", indexServer, err)
}
err = ConfigureAuth(cli, "", "", authConfig, isDefaultRegistry)
if err != nil {
return "", err
}
return EncodeAuthToBase64(*authConfig)
}
} | go | func RegistryAuthenticationPrivilegedFunc(cli Cli, index *registrytypes.IndexInfo, cmdName string) types.RequestPrivilegeFunc {
return func() (string, error) {
fmt.Fprintf(cli.Out(), "\nPlease login prior to %s:\n", cmdName)
indexServer := registry.GetAuthConfigKey(index)
isDefaultRegistry := indexServer == ElectAuthServer(context.Background(), cli)
authConfig, err := GetDefaultAuthConfig(cli, true, indexServer, isDefaultRegistry)
if err != nil {
fmt.Fprintf(cli.Err(), "Unable to retrieve stored credentials for %s, error: %s.\n", indexServer, err)
}
err = ConfigureAuth(cli, "", "", authConfig, isDefaultRegistry)
if err != nil {
return "", err
}
return EncodeAuthToBase64(*authConfig)
}
} | [
"func",
"RegistryAuthenticationPrivilegedFunc",
"(",
"cli",
"Cli",
",",
"index",
"*",
"registrytypes",
".",
"IndexInfo",
",",
"cmdName",
"string",
")",
"types",
".",
"RequestPrivilegeFunc",
"{",
"return",
"func",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"cli",
".",
"Out",
"(",
")",
",",
"\"",
"\\n",
"\\n",
"\"",
",",
"cmdName",
")",
"\n",
"indexServer",
":=",
"registry",
".",
"GetAuthConfigKey",
"(",
"index",
")",
"\n",
"isDefaultRegistry",
":=",
"indexServer",
"==",
"ElectAuthServer",
"(",
"context",
".",
"Background",
"(",
")",
",",
"cli",
")",
"\n",
"authConfig",
",",
"err",
":=",
"GetDefaultAuthConfig",
"(",
"cli",
",",
"true",
",",
"indexServer",
",",
"isDefaultRegistry",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintf",
"(",
"cli",
".",
"Err",
"(",
")",
",",
"\"",
"\\n",
"\"",
",",
"indexServer",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"ConfigureAuth",
"(",
"cli",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"authConfig",
",",
"isDefaultRegistry",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"EncodeAuthToBase64",
"(",
"*",
"authConfig",
")",
"\n",
"}",
"\n",
"}"
] | // RegistryAuthenticationPrivilegedFunc returns a RequestPrivilegeFunc from the specified registry index info
// for the given command. | [
"RegistryAuthenticationPrivilegedFunc",
"returns",
"a",
"RequestPrivilegeFunc",
"from",
"the",
"specified",
"registry",
"index",
"info",
"for",
"the",
"given",
"command",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/registry.go#L60-L75 | train |
docker/cli | cli/command/registry.go | ResolveAuthConfig | func ResolveAuthConfig(ctx context.Context, cli Cli, index *registrytypes.IndexInfo) types.AuthConfig {
configKey := index.Name
if index.Official {
configKey = ElectAuthServer(ctx, cli)
}
a, _ := cli.ConfigFile().GetAuthConfig(configKey)
return types.AuthConfig(a)
} | go | func ResolveAuthConfig(ctx context.Context, cli Cli, index *registrytypes.IndexInfo) types.AuthConfig {
configKey := index.Name
if index.Official {
configKey = ElectAuthServer(ctx, cli)
}
a, _ := cli.ConfigFile().GetAuthConfig(configKey)
return types.AuthConfig(a)
} | [
"func",
"ResolveAuthConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"Cli",
",",
"index",
"*",
"registrytypes",
".",
"IndexInfo",
")",
"types",
".",
"AuthConfig",
"{",
"configKey",
":=",
"index",
".",
"Name",
"\n",
"if",
"index",
".",
"Official",
"{",
"configKey",
"=",
"ElectAuthServer",
"(",
"ctx",
",",
"cli",
")",
"\n",
"}",
"\n\n",
"a",
",",
"_",
":=",
"cli",
".",
"ConfigFile",
"(",
")",
".",
"GetAuthConfig",
"(",
"configKey",
")",
"\n",
"return",
"types",
".",
"AuthConfig",
"(",
"a",
")",
"\n",
"}"
] | // ResolveAuthConfig is like registry.ResolveAuthConfig, but if using the
// default index, it uses the default index name for the daemon's platform,
// not the client's platform. | [
"ResolveAuthConfig",
"is",
"like",
"registry",
".",
"ResolveAuthConfig",
"but",
"if",
"using",
"the",
"default",
"index",
"it",
"uses",
"the",
"default",
"index",
"name",
"for",
"the",
"daemon",
"s",
"platform",
"not",
"the",
"client",
"s",
"platform",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/registry.go#L80-L88 | train |
docker/cli | cli/command/registry.go | GetDefaultAuthConfig | func GetDefaultAuthConfig(cli Cli, checkCredStore bool, serverAddress string, isDefaultRegistry bool) (*types.AuthConfig, error) {
if !isDefaultRegistry {
serverAddress = registry.ConvertToHostname(serverAddress)
}
var authconfig configtypes.AuthConfig
var err error
if checkCredStore {
authconfig, err = cli.ConfigFile().GetAuthConfig(serverAddress)
} else {
authconfig = configtypes.AuthConfig{}
}
authconfig.ServerAddress = serverAddress
authconfig.IdentityToken = ""
res := types.AuthConfig(authconfig)
return &res, err
} | go | func GetDefaultAuthConfig(cli Cli, checkCredStore bool, serverAddress string, isDefaultRegistry bool) (*types.AuthConfig, error) {
if !isDefaultRegistry {
serverAddress = registry.ConvertToHostname(serverAddress)
}
var authconfig configtypes.AuthConfig
var err error
if checkCredStore {
authconfig, err = cli.ConfigFile().GetAuthConfig(serverAddress)
} else {
authconfig = configtypes.AuthConfig{}
}
authconfig.ServerAddress = serverAddress
authconfig.IdentityToken = ""
res := types.AuthConfig(authconfig)
return &res, err
} | [
"func",
"GetDefaultAuthConfig",
"(",
"cli",
"Cli",
",",
"checkCredStore",
"bool",
",",
"serverAddress",
"string",
",",
"isDefaultRegistry",
"bool",
")",
"(",
"*",
"types",
".",
"AuthConfig",
",",
"error",
")",
"{",
"if",
"!",
"isDefaultRegistry",
"{",
"serverAddress",
"=",
"registry",
".",
"ConvertToHostname",
"(",
"serverAddress",
")",
"\n",
"}",
"\n",
"var",
"authconfig",
"configtypes",
".",
"AuthConfig",
"\n",
"var",
"err",
"error",
"\n",
"if",
"checkCredStore",
"{",
"authconfig",
",",
"err",
"=",
"cli",
".",
"ConfigFile",
"(",
")",
".",
"GetAuthConfig",
"(",
"serverAddress",
")",
"\n",
"}",
"else",
"{",
"authconfig",
"=",
"configtypes",
".",
"AuthConfig",
"{",
"}",
"\n",
"}",
"\n",
"authconfig",
".",
"ServerAddress",
"=",
"serverAddress",
"\n",
"authconfig",
".",
"IdentityToken",
"=",
"\"",
"\"",
"\n",
"res",
":=",
"types",
".",
"AuthConfig",
"(",
"authconfig",
")",
"\n",
"return",
"&",
"res",
",",
"err",
"\n",
"}"
] | // GetDefaultAuthConfig gets the default auth config given a serverAddress
// If credentials for given serverAddress exists in the credential store, the configuration will be populated with values in it | [
"GetDefaultAuthConfig",
"gets",
"the",
"default",
"auth",
"config",
"given",
"a",
"serverAddress",
"If",
"credentials",
"for",
"given",
"serverAddress",
"exists",
"in",
"the",
"credential",
"store",
"the",
"configuration",
"will",
"be",
"populated",
"with",
"values",
"in",
"it"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/registry.go#L92-L107 | train |
docker/cli | cli/command/registry.go | ConfigureAuth | func ConfigureAuth(cli Cli, flUser, flPassword string, authconfig *types.AuthConfig, isDefaultRegistry bool) error {
// On Windows, force the use of the regular OS stdin stream. Fixes #14336/#14210
if runtime.GOOS == "windows" {
cli.SetIn(streams.NewIn(os.Stdin))
}
// Some links documenting this:
// - https://code.google.com/archive/p/mintty/issues/56
// - https://github.com/docker/docker/issues/15272
// - https://mintty.github.io/ (compatibility)
// Linux will hit this if you attempt `cat | docker login`, and Windows
// will hit this if you attempt docker login from mintty where stdin
// is a pipe, not a character based console.
if flPassword == "" && !cli.In().IsTerminal() {
return errors.Errorf("Error: Cannot perform an interactive login from a non TTY device")
}
authconfig.Username = strings.TrimSpace(authconfig.Username)
if flUser = strings.TrimSpace(flUser); flUser == "" {
if isDefaultRegistry {
// if this is a default registry (docker hub), then display the following message.
fmt.Fprintln(cli.Out(), "Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.")
}
promptWithDefault(cli.Out(), "Username", authconfig.Username)
flUser = readInput(cli.In(), cli.Out())
flUser = strings.TrimSpace(flUser)
if flUser == "" {
flUser = authconfig.Username
}
}
if flUser == "" {
return errors.Errorf("Error: Non-null Username Required")
}
if flPassword == "" {
oldState, err := term.SaveState(cli.In().FD())
if err != nil {
return err
}
fmt.Fprintf(cli.Out(), "Password: ")
term.DisableEcho(cli.In().FD(), oldState)
flPassword = readInput(cli.In(), cli.Out())
fmt.Fprint(cli.Out(), "\n")
term.RestoreTerminal(cli.In().FD(), oldState)
if flPassword == "" {
return errors.Errorf("Error: Password Required")
}
}
authconfig.Username = flUser
authconfig.Password = flPassword
return nil
} | go | func ConfigureAuth(cli Cli, flUser, flPassword string, authconfig *types.AuthConfig, isDefaultRegistry bool) error {
// On Windows, force the use of the regular OS stdin stream. Fixes #14336/#14210
if runtime.GOOS == "windows" {
cli.SetIn(streams.NewIn(os.Stdin))
}
// Some links documenting this:
// - https://code.google.com/archive/p/mintty/issues/56
// - https://github.com/docker/docker/issues/15272
// - https://mintty.github.io/ (compatibility)
// Linux will hit this if you attempt `cat | docker login`, and Windows
// will hit this if you attempt docker login from mintty where stdin
// is a pipe, not a character based console.
if flPassword == "" && !cli.In().IsTerminal() {
return errors.Errorf("Error: Cannot perform an interactive login from a non TTY device")
}
authconfig.Username = strings.TrimSpace(authconfig.Username)
if flUser = strings.TrimSpace(flUser); flUser == "" {
if isDefaultRegistry {
// if this is a default registry (docker hub), then display the following message.
fmt.Fprintln(cli.Out(), "Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.")
}
promptWithDefault(cli.Out(), "Username", authconfig.Username)
flUser = readInput(cli.In(), cli.Out())
flUser = strings.TrimSpace(flUser)
if flUser == "" {
flUser = authconfig.Username
}
}
if flUser == "" {
return errors.Errorf("Error: Non-null Username Required")
}
if flPassword == "" {
oldState, err := term.SaveState(cli.In().FD())
if err != nil {
return err
}
fmt.Fprintf(cli.Out(), "Password: ")
term.DisableEcho(cli.In().FD(), oldState)
flPassword = readInput(cli.In(), cli.Out())
fmt.Fprint(cli.Out(), "\n")
term.RestoreTerminal(cli.In().FD(), oldState)
if flPassword == "" {
return errors.Errorf("Error: Password Required")
}
}
authconfig.Username = flUser
authconfig.Password = flPassword
return nil
} | [
"func",
"ConfigureAuth",
"(",
"cli",
"Cli",
",",
"flUser",
",",
"flPassword",
"string",
",",
"authconfig",
"*",
"types",
".",
"AuthConfig",
",",
"isDefaultRegistry",
"bool",
")",
"error",
"{",
"// On Windows, force the use of the regular OS stdin stream. Fixes #14336/#14210",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"cli",
".",
"SetIn",
"(",
"streams",
".",
"NewIn",
"(",
"os",
".",
"Stdin",
")",
")",
"\n",
"}",
"\n\n",
"// Some links documenting this:",
"// - https://code.google.com/archive/p/mintty/issues/56",
"// - https://github.com/docker/docker/issues/15272",
"// - https://mintty.github.io/ (compatibility)",
"// Linux will hit this if you attempt `cat | docker login`, and Windows",
"// will hit this if you attempt docker login from mintty where stdin",
"// is a pipe, not a character based console.",
"if",
"flPassword",
"==",
"\"",
"\"",
"&&",
"!",
"cli",
".",
"In",
"(",
")",
".",
"IsTerminal",
"(",
")",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"authconfig",
".",
"Username",
"=",
"strings",
".",
"TrimSpace",
"(",
"authconfig",
".",
"Username",
")",
"\n\n",
"if",
"flUser",
"=",
"strings",
".",
"TrimSpace",
"(",
"flUser",
")",
";",
"flUser",
"==",
"\"",
"\"",
"{",
"if",
"isDefaultRegistry",
"{",
"// if this is a default registry (docker hub), then display the following message.",
"fmt",
".",
"Fprintln",
"(",
"cli",
".",
"Out",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"promptWithDefault",
"(",
"cli",
".",
"Out",
"(",
")",
",",
"\"",
"\"",
",",
"authconfig",
".",
"Username",
")",
"\n",
"flUser",
"=",
"readInput",
"(",
"cli",
".",
"In",
"(",
")",
",",
"cli",
".",
"Out",
"(",
")",
")",
"\n",
"flUser",
"=",
"strings",
".",
"TrimSpace",
"(",
"flUser",
")",
"\n",
"if",
"flUser",
"==",
"\"",
"\"",
"{",
"flUser",
"=",
"authconfig",
".",
"Username",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"flUser",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"flPassword",
"==",
"\"",
"\"",
"{",
"oldState",
",",
"err",
":=",
"term",
".",
"SaveState",
"(",
"cli",
".",
"In",
"(",
")",
".",
"FD",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"cli",
".",
"Out",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"term",
".",
"DisableEcho",
"(",
"cli",
".",
"In",
"(",
")",
".",
"FD",
"(",
")",
",",
"oldState",
")",
"\n\n",
"flPassword",
"=",
"readInput",
"(",
"cli",
".",
"In",
"(",
")",
",",
"cli",
".",
"Out",
"(",
")",
")",
"\n",
"fmt",
".",
"Fprint",
"(",
"cli",
".",
"Out",
"(",
")",
",",
"\"",
"\\n",
"\"",
")",
"\n\n",
"term",
".",
"RestoreTerminal",
"(",
"cli",
".",
"In",
"(",
")",
".",
"FD",
"(",
")",
",",
"oldState",
")",
"\n",
"if",
"flPassword",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"authconfig",
".",
"Username",
"=",
"flUser",
"\n",
"authconfig",
".",
"Password",
"=",
"flPassword",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ConfigureAuth handles prompting of user's username and password if needed | [
"ConfigureAuth",
"handles",
"prompting",
"of",
"user",
"s",
"username",
"and",
"password",
"if",
"needed"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/registry.go#L110-L165 | train |
docker/cli | cli/command/registry.go | RetrieveAuthTokenFromImage | func RetrieveAuthTokenFromImage(ctx context.Context, cli Cli, image string) (string, error) {
// Retrieve encoded auth token from the image reference
authConfig, err := resolveAuthConfigFromImage(ctx, cli, image)
if err != nil {
return "", err
}
encodedAuth, err := EncodeAuthToBase64(authConfig)
if err != nil {
return "", err
}
return encodedAuth, nil
} | go | func RetrieveAuthTokenFromImage(ctx context.Context, cli Cli, image string) (string, error) {
// Retrieve encoded auth token from the image reference
authConfig, err := resolveAuthConfigFromImage(ctx, cli, image)
if err != nil {
return "", err
}
encodedAuth, err := EncodeAuthToBase64(authConfig)
if err != nil {
return "", err
}
return encodedAuth, nil
} | [
"func",
"RetrieveAuthTokenFromImage",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"Cli",
",",
"image",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Retrieve encoded auth token from the image reference",
"authConfig",
",",
"err",
":=",
"resolveAuthConfigFromImage",
"(",
"ctx",
",",
"cli",
",",
"image",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"encodedAuth",
",",
"err",
":=",
"EncodeAuthToBase64",
"(",
"authConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"encodedAuth",
",",
"nil",
"\n",
"}"
] | // RetrieveAuthTokenFromImage retrieves an encoded auth token given a complete image | [
"RetrieveAuthTokenFromImage",
"retrieves",
"an",
"encoded",
"auth",
"token",
"given",
"a",
"complete",
"image"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/registry.go#L186-L197 | train |
docker/cli | cli/command/registry.go | resolveAuthConfigFromImage | func resolveAuthConfigFromImage(ctx context.Context, cli Cli, image string) (types.AuthConfig, error) {
registryRef, err := reference.ParseNormalizedNamed(image)
if err != nil {
return types.AuthConfig{}, err
}
repoInfo, err := registry.ParseRepositoryInfo(registryRef)
if err != nil {
return types.AuthConfig{}, err
}
return ResolveAuthConfig(ctx, cli, repoInfo.Index), nil
} | go | func resolveAuthConfigFromImage(ctx context.Context, cli Cli, image string) (types.AuthConfig, error) {
registryRef, err := reference.ParseNormalizedNamed(image)
if err != nil {
return types.AuthConfig{}, err
}
repoInfo, err := registry.ParseRepositoryInfo(registryRef)
if err != nil {
return types.AuthConfig{}, err
}
return ResolveAuthConfig(ctx, cli, repoInfo.Index), nil
} | [
"func",
"resolveAuthConfigFromImage",
"(",
"ctx",
"context",
".",
"Context",
",",
"cli",
"Cli",
",",
"image",
"string",
")",
"(",
"types",
".",
"AuthConfig",
",",
"error",
")",
"{",
"registryRef",
",",
"err",
":=",
"reference",
".",
"ParseNormalizedNamed",
"(",
"image",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"types",
".",
"AuthConfig",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"repoInfo",
",",
"err",
":=",
"registry",
".",
"ParseRepositoryInfo",
"(",
"registryRef",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"types",
".",
"AuthConfig",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"ResolveAuthConfig",
"(",
"ctx",
",",
"cli",
",",
"repoInfo",
".",
"Index",
")",
",",
"nil",
"\n",
"}"
] | // resolveAuthConfigFromImage retrieves that AuthConfig using the image string | [
"resolveAuthConfigFromImage",
"retrieves",
"that",
"AuthConfig",
"using",
"the",
"image",
"string"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/registry.go#L200-L210 | train |
docker/cli | cli/command/container/list.go | NewPsCommand | func NewPsCommand(dockerCli command.Cli) *cobra.Command {
options := psOptions{filter: opts.NewFilterOpt()}
cmd := &cobra.Command{
Use: "ps [OPTIONS]",
Short: "List containers",
Args: cli.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
return runPs(dockerCli, &options)
},
}
flags := cmd.Flags()
flags.BoolVarP(&options.quiet, "quiet", "q", false, "Only display numeric IDs")
flags.BoolVarP(&options.size, "size", "s", false, "Display total file sizes")
flags.BoolVarP(&options.all, "all", "a", false, "Show all containers (default shows just running)")
flags.BoolVar(&options.noTrunc, "no-trunc", false, "Don't truncate output")
flags.BoolVarP(&options.nLatest, "latest", "l", false, "Show the latest created container (includes all states)")
flags.IntVarP(&options.last, "last", "n", -1, "Show n last created containers (includes all states)")
flags.StringVarP(&options.format, "format", "", "", "Pretty-print containers using a Go template")
flags.VarP(&options.filter, "filter", "f", "Filter output based on conditions provided")
return cmd
} | go | func NewPsCommand(dockerCli command.Cli) *cobra.Command {
options := psOptions{filter: opts.NewFilterOpt()}
cmd := &cobra.Command{
Use: "ps [OPTIONS]",
Short: "List containers",
Args: cli.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
return runPs(dockerCli, &options)
},
}
flags := cmd.Flags()
flags.BoolVarP(&options.quiet, "quiet", "q", false, "Only display numeric IDs")
flags.BoolVarP(&options.size, "size", "s", false, "Display total file sizes")
flags.BoolVarP(&options.all, "all", "a", false, "Show all containers (default shows just running)")
flags.BoolVar(&options.noTrunc, "no-trunc", false, "Don't truncate output")
flags.BoolVarP(&options.nLatest, "latest", "l", false, "Show the latest created container (includes all states)")
flags.IntVarP(&options.last, "last", "n", -1, "Show n last created containers (includes all states)")
flags.StringVarP(&options.format, "format", "", "", "Pretty-print containers using a Go template")
flags.VarP(&options.filter, "filter", "f", "Filter output based on conditions provided")
return cmd
} | [
"func",
"NewPsCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"options",
":=",
"psOptions",
"{",
"filter",
":",
"opts",
".",
"NewFilterOpt",
"(",
")",
"}",
"\n\n",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Args",
":",
"cli",
".",
"NoArgs",
",",
"RunE",
":",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"return",
"runPs",
"(",
"dockerCli",
",",
"&",
"options",
")",
"\n",
"}",
",",
"}",
"\n\n",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n\n",
"flags",
".",
"BoolVarP",
"(",
"&",
"options",
".",
"quiet",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"BoolVarP",
"(",
"&",
"options",
".",
"size",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"BoolVarP",
"(",
"&",
"options",
".",
"all",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"BoolVar",
"(",
"&",
"options",
".",
"noTrunc",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"BoolVarP",
"(",
"&",
"options",
".",
"nLatest",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"IntVarP",
"(",
"&",
"options",
".",
"last",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"StringVarP",
"(",
"&",
"options",
".",
"format",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"VarP",
"(",
"&",
"options",
".",
"filter",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"return",
"cmd",
"\n",
"}"
] | // NewPsCommand creates a new cobra.Command for `docker ps` | [
"NewPsCommand",
"creates",
"a",
"new",
"cobra",
".",
"Command",
"for",
"docker",
"ps"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/container/list.go#L28-L52 | train |
docker/cli | cli/compose/convert/volume.go | Volumes | func Volumes(serviceVolumes []composetypes.ServiceVolumeConfig, stackVolumes volumes, namespace Namespace) ([]mount.Mount, error) {
var mounts []mount.Mount
for _, volumeConfig := range serviceVolumes {
mount, err := convertVolumeToMount(volumeConfig, stackVolumes, namespace)
if err != nil {
return nil, err
}
mounts = append(mounts, mount)
}
return mounts, nil
} | go | func Volumes(serviceVolumes []composetypes.ServiceVolumeConfig, stackVolumes volumes, namespace Namespace) ([]mount.Mount, error) {
var mounts []mount.Mount
for _, volumeConfig := range serviceVolumes {
mount, err := convertVolumeToMount(volumeConfig, stackVolumes, namespace)
if err != nil {
return nil, err
}
mounts = append(mounts, mount)
}
return mounts, nil
} | [
"func",
"Volumes",
"(",
"serviceVolumes",
"[",
"]",
"composetypes",
".",
"ServiceVolumeConfig",
",",
"stackVolumes",
"volumes",
",",
"namespace",
"Namespace",
")",
"(",
"[",
"]",
"mount",
".",
"Mount",
",",
"error",
")",
"{",
"var",
"mounts",
"[",
"]",
"mount",
".",
"Mount",
"\n\n",
"for",
"_",
",",
"volumeConfig",
":=",
"range",
"serviceVolumes",
"{",
"mount",
",",
"err",
":=",
"convertVolumeToMount",
"(",
"volumeConfig",
",",
"stackVolumes",
",",
"namespace",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"mounts",
"=",
"append",
"(",
"mounts",
",",
"mount",
")",
"\n",
"}",
"\n",
"return",
"mounts",
",",
"nil",
"\n",
"}"
] | // Volumes from compose-file types to engine api types | [
"Volumes",
"from",
"compose",
"-",
"file",
"types",
"to",
"engine",
"api",
"types"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/compose/convert/volume.go#L12-L23 | train |
docker/cli | cli/command/service/cmd.go | NewServiceCommand | func NewServiceCommand(dockerCli command.Cli) *cobra.Command {
cmd := &cobra.Command{
Use: "service",
Short: "Manage services",
Args: cli.NoArgs,
RunE: command.ShowHelp(dockerCli.Err()),
Annotations: map[string]string{
"version": "1.24",
"swarm": "",
},
}
cmd.AddCommand(
newCreateCommand(dockerCli),
newInspectCommand(dockerCli),
newPsCommand(dockerCli),
newListCommand(dockerCli),
newRemoveCommand(dockerCli),
newScaleCommand(dockerCli),
newUpdateCommand(dockerCli),
newLogsCommand(dockerCli),
newRollbackCommand(dockerCli),
)
return cmd
} | go | func NewServiceCommand(dockerCli command.Cli) *cobra.Command {
cmd := &cobra.Command{
Use: "service",
Short: "Manage services",
Args: cli.NoArgs,
RunE: command.ShowHelp(dockerCli.Err()),
Annotations: map[string]string{
"version": "1.24",
"swarm": "",
},
}
cmd.AddCommand(
newCreateCommand(dockerCli),
newInspectCommand(dockerCli),
newPsCommand(dockerCli),
newListCommand(dockerCli),
newRemoveCommand(dockerCli),
newScaleCommand(dockerCli),
newUpdateCommand(dockerCli),
newLogsCommand(dockerCli),
newRollbackCommand(dockerCli),
)
return cmd
} | [
"func",
"NewServiceCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Args",
":",
"cli",
".",
"NoArgs",
",",
"RunE",
":",
"command",
".",
"ShowHelp",
"(",
"dockerCli",
".",
"Err",
"(",
")",
")",
",",
"Annotations",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
"}",
"\n",
"cmd",
".",
"AddCommand",
"(",
"newCreateCommand",
"(",
"dockerCli",
")",
",",
"newInspectCommand",
"(",
"dockerCli",
")",
",",
"newPsCommand",
"(",
"dockerCli",
")",
",",
"newListCommand",
"(",
"dockerCli",
")",
",",
"newRemoveCommand",
"(",
"dockerCli",
")",
",",
"newScaleCommand",
"(",
"dockerCli",
")",
",",
"newUpdateCommand",
"(",
"dockerCli",
")",
",",
"newLogsCommand",
"(",
"dockerCli",
")",
",",
"newRollbackCommand",
"(",
"dockerCli",
")",
",",
")",
"\n",
"return",
"cmd",
"\n",
"}"
] | // NewServiceCommand returns a cobra command for `service` subcommands | [
"NewServiceCommand",
"returns",
"a",
"cobra",
"command",
"for",
"service",
"subcommands"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/service/cmd.go#L11-L34 | train |
docker/cli | cli/required.go | RequiresMaxArgs | func RequiresMaxArgs(max int) cobra.PositionalArgs {
return func(cmd *cobra.Command, args []string) error {
if len(args) <= max {
return nil
}
return errors.Errorf(
"%q requires at most %d %s.\nSee '%s --help'.\n\nUsage: %s\n\n%s",
cmd.CommandPath(),
max,
pluralize("argument", max),
cmd.CommandPath(),
cmd.UseLine(),
cmd.Short,
)
}
} | go | func RequiresMaxArgs(max int) cobra.PositionalArgs {
return func(cmd *cobra.Command, args []string) error {
if len(args) <= max {
return nil
}
return errors.Errorf(
"%q requires at most %d %s.\nSee '%s --help'.\n\nUsage: %s\n\n%s",
cmd.CommandPath(),
max,
pluralize("argument", max),
cmd.CommandPath(),
cmd.UseLine(),
cmd.Short,
)
}
} | [
"func",
"RequiresMaxArgs",
"(",
"max",
"int",
")",
"cobra",
".",
"PositionalArgs",
"{",
"return",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"args",
")",
"<=",
"max",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\\n",
"\\n",
"\"",
",",
"cmd",
".",
"CommandPath",
"(",
")",
",",
"max",
",",
"pluralize",
"(",
"\"",
"\"",
",",
"max",
")",
",",
"cmd",
".",
"CommandPath",
"(",
")",
",",
"cmd",
".",
"UseLine",
"(",
")",
",",
"cmd",
".",
"Short",
",",
")",
"\n",
"}",
"\n",
"}"
] | // RequiresMaxArgs returns an error if there is not at most max args | [
"RequiresMaxArgs",
"returns",
"an",
"error",
"if",
"there",
"is",
"not",
"at",
"most",
"max",
"args"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/required.go#L48-L63 | train |
docker/cli | cli/required.go | ExactArgs | func ExactArgs(number int) cobra.PositionalArgs {
return func(cmd *cobra.Command, args []string) error {
if len(args) == number {
return nil
}
return errors.Errorf(
"%q requires exactly %d %s.\nSee '%s --help'.\n\nUsage: %s\n\n%s",
cmd.CommandPath(),
number,
pluralize("argument", number),
cmd.CommandPath(),
cmd.UseLine(),
cmd.Short,
)
}
} | go | func ExactArgs(number int) cobra.PositionalArgs {
return func(cmd *cobra.Command, args []string) error {
if len(args) == number {
return nil
}
return errors.Errorf(
"%q requires exactly %d %s.\nSee '%s --help'.\n\nUsage: %s\n\n%s",
cmd.CommandPath(),
number,
pluralize("argument", number),
cmd.CommandPath(),
cmd.UseLine(),
cmd.Short,
)
}
} | [
"func",
"ExactArgs",
"(",
"number",
"int",
")",
"cobra",
".",
"PositionalArgs",
"{",
"return",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"args",
")",
"==",
"number",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\\n",
"\\n",
"\"",
",",
"cmd",
".",
"CommandPath",
"(",
")",
",",
"number",
",",
"pluralize",
"(",
"\"",
"\"",
",",
"number",
")",
",",
"cmd",
".",
"CommandPath",
"(",
")",
",",
"cmd",
".",
"UseLine",
"(",
")",
",",
"cmd",
".",
"Short",
",",
")",
"\n",
"}",
"\n",
"}"
] | // ExactArgs returns an error if there is not the exact number of args | [
"ExactArgs",
"returns",
"an",
"error",
"if",
"there",
"is",
"not",
"the",
"exact",
"number",
"of",
"args"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/required.go#L85-L100 | train |
docker/cli | cli/command/container/update.go | NewUpdateCommand | func NewUpdateCommand(dockerCli command.Cli) *cobra.Command {
var options updateOptions
cmd := &cobra.Command{
Use: "update [OPTIONS] CONTAINER [CONTAINER...]",
Short: "Update configuration of one or more containers",
Args: cli.RequiresMinArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
options.containers = args
options.nFlag = cmd.Flags().NFlag()
return runUpdate(dockerCli, &options)
},
}
flags := cmd.Flags()
flags.Uint16Var(&options.blkioWeight, "blkio-weight", 0, "Block IO (relative weight), between 10 and 1000, or 0 to disable (default 0)")
flags.Int64Var(&options.cpuPeriod, "cpu-period", 0, "Limit CPU CFS (Completely Fair Scheduler) period")
flags.Int64Var(&options.cpuQuota, "cpu-quota", 0, "Limit CPU CFS (Completely Fair Scheduler) quota")
flags.Int64Var(&options.cpuRealtimePeriod, "cpu-rt-period", 0, "Limit the CPU real-time period in microseconds")
flags.SetAnnotation("cpu-rt-period", "version", []string{"1.25"})
flags.Int64Var(&options.cpuRealtimeRuntime, "cpu-rt-runtime", 0, "Limit the CPU real-time runtime in microseconds")
flags.SetAnnotation("cpu-rt-runtime", "version", []string{"1.25"})
flags.StringVar(&options.cpusetCpus, "cpuset-cpus", "", "CPUs in which to allow execution (0-3, 0,1)")
flags.StringVar(&options.cpusetMems, "cpuset-mems", "", "MEMs in which to allow execution (0-3, 0,1)")
flags.Int64VarP(&options.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)")
flags.VarP(&options.memory, "memory", "m", "Memory limit")
flags.Var(&options.memoryReservation, "memory-reservation", "Memory soft limit")
flags.Var(&options.memorySwap, "memory-swap", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap")
flags.Var(&options.kernelMemory, "kernel-memory", "Kernel memory limit")
flags.StringVar(&options.restartPolicy, "restart", "", "Restart policy to apply when a container exits")
flags.Int64Var(&options.pidsLimit, "pids-limit", 0, "Tune container pids limit (set -1 for unlimited)")
flags.SetAnnotation("pids-limit", "version", []string{"1.40"})
flags.Var(&options.cpus, "cpus", "Number of CPUs")
flags.SetAnnotation("cpus", "version", []string{"1.29"})
return cmd
} | go | func NewUpdateCommand(dockerCli command.Cli) *cobra.Command {
var options updateOptions
cmd := &cobra.Command{
Use: "update [OPTIONS] CONTAINER [CONTAINER...]",
Short: "Update configuration of one or more containers",
Args: cli.RequiresMinArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
options.containers = args
options.nFlag = cmd.Flags().NFlag()
return runUpdate(dockerCli, &options)
},
}
flags := cmd.Flags()
flags.Uint16Var(&options.blkioWeight, "blkio-weight", 0, "Block IO (relative weight), between 10 and 1000, or 0 to disable (default 0)")
flags.Int64Var(&options.cpuPeriod, "cpu-period", 0, "Limit CPU CFS (Completely Fair Scheduler) period")
flags.Int64Var(&options.cpuQuota, "cpu-quota", 0, "Limit CPU CFS (Completely Fair Scheduler) quota")
flags.Int64Var(&options.cpuRealtimePeriod, "cpu-rt-period", 0, "Limit the CPU real-time period in microseconds")
flags.SetAnnotation("cpu-rt-period", "version", []string{"1.25"})
flags.Int64Var(&options.cpuRealtimeRuntime, "cpu-rt-runtime", 0, "Limit the CPU real-time runtime in microseconds")
flags.SetAnnotation("cpu-rt-runtime", "version", []string{"1.25"})
flags.StringVar(&options.cpusetCpus, "cpuset-cpus", "", "CPUs in which to allow execution (0-3, 0,1)")
flags.StringVar(&options.cpusetMems, "cpuset-mems", "", "MEMs in which to allow execution (0-3, 0,1)")
flags.Int64VarP(&options.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)")
flags.VarP(&options.memory, "memory", "m", "Memory limit")
flags.Var(&options.memoryReservation, "memory-reservation", "Memory soft limit")
flags.Var(&options.memorySwap, "memory-swap", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap")
flags.Var(&options.kernelMemory, "kernel-memory", "Kernel memory limit")
flags.StringVar(&options.restartPolicy, "restart", "", "Restart policy to apply when a container exits")
flags.Int64Var(&options.pidsLimit, "pids-limit", 0, "Tune container pids limit (set -1 for unlimited)")
flags.SetAnnotation("pids-limit", "version", []string{"1.40"})
flags.Var(&options.cpus, "cpus", "Number of CPUs")
flags.SetAnnotation("cpus", "version", []string{"1.29"})
return cmd
} | [
"func",
"NewUpdateCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"options",
"updateOptions",
"\n\n",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Args",
":",
"cli",
".",
"RequiresMinArgs",
"(",
"1",
")",
",",
"RunE",
":",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"options",
".",
"containers",
"=",
"args",
"\n",
"options",
".",
"nFlag",
"=",
"cmd",
".",
"Flags",
"(",
")",
".",
"NFlag",
"(",
")",
"\n",
"return",
"runUpdate",
"(",
"dockerCli",
",",
"&",
"options",
")",
"\n",
"}",
",",
"}",
"\n\n",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n",
"flags",
".",
"Uint16Var",
"(",
"&",
"options",
".",
"blkioWeight",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Int64Var",
"(",
"&",
"options",
".",
"cpuPeriod",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Int64Var",
"(",
"&",
"options",
".",
"cpuQuota",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Int64Var",
"(",
"&",
"options",
".",
"cpuRealtimePeriod",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"SetAnnotation",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
")",
"\n",
"flags",
".",
"Int64Var",
"(",
"&",
"options",
".",
"cpuRealtimeRuntime",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"SetAnnotation",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
")",
"\n",
"flags",
".",
"StringVar",
"(",
"&",
"options",
".",
"cpusetCpus",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"StringVar",
"(",
"&",
"options",
".",
"cpusetMems",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Int64VarP",
"(",
"&",
"options",
".",
"cpuShares",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"VarP",
"(",
"&",
"options",
".",
"memory",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Var",
"(",
"&",
"options",
".",
"memoryReservation",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Var",
"(",
"&",
"options",
".",
"memorySwap",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Var",
"(",
"&",
"options",
".",
"kernelMemory",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"StringVar",
"(",
"&",
"options",
".",
"restartPolicy",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"Int64Var",
"(",
"&",
"options",
".",
"pidsLimit",
",",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"SetAnnotation",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
")",
"\n\n",
"flags",
".",
"Var",
"(",
"&",
"options",
".",
"cpus",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"SetAnnotation",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
")",
"\n\n",
"return",
"cmd",
"\n",
"}"
] | // NewUpdateCommand creates a new cobra.Command for `docker update` | [
"NewUpdateCommand",
"creates",
"a",
"new",
"cobra",
".",
"Command",
"for",
"docker",
"update"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/container/update.go#L39-L76 | train |
docker/cli | cli/command/image/tag.go | NewTagCommand | func NewTagCommand(dockerCli command.Cli) *cobra.Command {
var opts tagOptions
cmd := &cobra.Command{
Use: "tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]",
Short: "Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE",
Args: cli.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
opts.image = args[0]
opts.name = args[1]
return runTag(dockerCli, opts)
},
}
flags := cmd.Flags()
flags.SetInterspersed(false)
return cmd
} | go | func NewTagCommand(dockerCli command.Cli) *cobra.Command {
var opts tagOptions
cmd := &cobra.Command{
Use: "tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]",
Short: "Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE",
Args: cli.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
opts.image = args[0]
opts.name = args[1]
return runTag(dockerCli, opts)
},
}
flags := cmd.Flags()
flags.SetInterspersed(false)
return cmd
} | [
"func",
"NewTagCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"opts",
"tagOptions",
"\n\n",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Args",
":",
"cli",
".",
"ExactArgs",
"(",
"2",
")",
",",
"RunE",
":",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"opts",
".",
"image",
"=",
"args",
"[",
"0",
"]",
"\n",
"opts",
".",
"name",
"=",
"args",
"[",
"1",
"]",
"\n",
"return",
"runTag",
"(",
"dockerCli",
",",
"opts",
")",
"\n",
"}",
",",
"}",
"\n\n",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n",
"flags",
".",
"SetInterspersed",
"(",
"false",
")",
"\n\n",
"return",
"cmd",
"\n",
"}"
] | // NewTagCommand creates a new `docker tag` command | [
"NewTagCommand",
"creates",
"a",
"new",
"docker",
"tag",
"command"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/image/tag.go#L17-L35 | train |
docker/cli | cli/command/manifest/cmd.go | NewManifestCommand | func NewManifestCommand(dockerCli command.Cli) *cobra.Command {
// use dockerCli as command.Cli
cmd := &cobra.Command{
Use: "manifest COMMAND",
Short: "Manage Docker image manifests and manifest lists",
Long: manifestDescription,
Args: cli.NoArgs,
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintf(dockerCli.Err(), "\n"+cmd.UsageString())
},
Annotations: map[string]string{"experimentalCLI": ""},
}
cmd.AddCommand(
newCreateListCommand(dockerCli),
newInspectCommand(dockerCli),
newAnnotateCommand(dockerCli),
newPushListCommand(dockerCli),
)
return cmd
} | go | func NewManifestCommand(dockerCli command.Cli) *cobra.Command {
// use dockerCli as command.Cli
cmd := &cobra.Command{
Use: "manifest COMMAND",
Short: "Manage Docker image manifests and manifest lists",
Long: manifestDescription,
Args: cli.NoArgs,
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintf(dockerCli.Err(), "\n"+cmd.UsageString())
},
Annotations: map[string]string{"experimentalCLI": ""},
}
cmd.AddCommand(
newCreateListCommand(dockerCli),
newInspectCommand(dockerCli),
newAnnotateCommand(dockerCli),
newPushListCommand(dockerCli),
)
return cmd
} | [
"func",
"NewManifestCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"// use dockerCli as command.Cli",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Long",
":",
"manifestDescription",
",",
"Args",
":",
"cli",
".",
"NoArgs",
",",
"Run",
":",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"dockerCli",
".",
"Err",
"(",
")",
",",
"\"",
"\\n",
"\"",
"+",
"cmd",
".",
"UsageString",
"(",
")",
")",
"\n",
"}",
",",
"Annotations",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
",",
"}",
"\n",
"cmd",
".",
"AddCommand",
"(",
"newCreateListCommand",
"(",
"dockerCli",
")",
",",
"newInspectCommand",
"(",
"dockerCli",
")",
",",
"newAnnotateCommand",
"(",
"dockerCli",
")",
",",
"newPushListCommand",
"(",
"dockerCli",
")",
",",
")",
"\n",
"return",
"cmd",
"\n",
"}"
] | // NewManifestCommand returns a cobra command for `manifest` subcommands | [
"NewManifestCommand",
"returns",
"a",
"cobra",
"command",
"for",
"manifest",
"subcommands"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/manifest/cmd.go#L13-L32 | train |
docker/cli | cli/command/container/stats.go | NewStatsCommand | func NewStatsCommand(dockerCli command.Cli) *cobra.Command {
var opts statsOptions
cmd := &cobra.Command{
Use: "stats [OPTIONS] [CONTAINER...]",
Short: "Display a live stream of container(s) resource usage statistics",
Args: cli.RequiresMinArgs(0),
RunE: func(cmd *cobra.Command, args []string) error {
opts.containers = args
return runStats(dockerCli, &opts)
},
}
flags := cmd.Flags()
flags.BoolVarP(&opts.all, "all", "a", false, "Show all containers (default shows just running)")
flags.BoolVar(&opts.noStream, "no-stream", false, "Disable streaming stats and only pull the first result")
flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate output")
flags.StringVar(&opts.format, "format", "", "Pretty-print images using a Go template")
return cmd
} | go | func NewStatsCommand(dockerCli command.Cli) *cobra.Command {
var opts statsOptions
cmd := &cobra.Command{
Use: "stats [OPTIONS] [CONTAINER...]",
Short: "Display a live stream of container(s) resource usage statistics",
Args: cli.RequiresMinArgs(0),
RunE: func(cmd *cobra.Command, args []string) error {
opts.containers = args
return runStats(dockerCli, &opts)
},
}
flags := cmd.Flags()
flags.BoolVarP(&opts.all, "all", "a", false, "Show all containers (default shows just running)")
flags.BoolVar(&opts.noStream, "no-stream", false, "Disable streaming stats and only pull the first result")
flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate output")
flags.StringVar(&opts.format, "format", "", "Pretty-print images using a Go template")
return cmd
} | [
"func",
"NewStatsCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"opts",
"statsOptions",
"\n\n",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Args",
":",
"cli",
".",
"RequiresMinArgs",
"(",
"0",
")",
",",
"RunE",
":",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"opts",
".",
"containers",
"=",
"args",
"\n",
"return",
"runStats",
"(",
"dockerCli",
",",
"&",
"opts",
")",
"\n",
"}",
",",
"}",
"\n\n",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n",
"flags",
".",
"BoolVarP",
"(",
"&",
"opts",
".",
"all",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"BoolVar",
"(",
"&",
"opts",
".",
"noStream",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"BoolVar",
"(",
"&",
"opts",
".",
"noTrunc",
",",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"flags",
".",
"StringVar",
"(",
"&",
"opts",
".",
"format",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"cmd",
"\n",
"}"
] | // NewStatsCommand creates a new cobra.Command for `docker stats` | [
"NewStatsCommand",
"creates",
"a",
"new",
"cobra",
".",
"Command",
"for",
"docker",
"stats"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/container/stats.go#L30-L49 | train |
docker/cli | cli/command/trust/sign.go | getOrGenerateNotaryKey | func getOrGenerateNotaryKey(notaryRepo client.Repository, role data.RoleName) (data.PublicKey, error) {
// use the signer name in the PEM headers if this is a delegation key
if data.IsDelegation(role) {
role = data.RoleName(notaryRoleToSigner(role))
}
keys := notaryRepo.GetCryptoService().ListKeys(role)
var err error
var key data.PublicKey
// always select the first key by ID
if len(keys) > 0 {
sort.Strings(keys)
keyID := keys[0]
privKey, _, err := notaryRepo.GetCryptoService().GetPrivateKey(keyID)
if err != nil {
return nil, err
}
key = data.PublicKeyFromPrivate(privKey)
} else {
key, err = notaryRepo.GetCryptoService().Create(role, "", data.ECDSAKey)
if err != nil {
return nil, err
}
}
return key, nil
} | go | func getOrGenerateNotaryKey(notaryRepo client.Repository, role data.RoleName) (data.PublicKey, error) {
// use the signer name in the PEM headers if this is a delegation key
if data.IsDelegation(role) {
role = data.RoleName(notaryRoleToSigner(role))
}
keys := notaryRepo.GetCryptoService().ListKeys(role)
var err error
var key data.PublicKey
// always select the first key by ID
if len(keys) > 0 {
sort.Strings(keys)
keyID := keys[0]
privKey, _, err := notaryRepo.GetCryptoService().GetPrivateKey(keyID)
if err != nil {
return nil, err
}
key = data.PublicKeyFromPrivate(privKey)
} else {
key, err = notaryRepo.GetCryptoService().Create(role, "", data.ECDSAKey)
if err != nil {
return nil, err
}
}
return key, nil
} | [
"func",
"getOrGenerateNotaryKey",
"(",
"notaryRepo",
"client",
".",
"Repository",
",",
"role",
"data",
".",
"RoleName",
")",
"(",
"data",
".",
"PublicKey",
",",
"error",
")",
"{",
"// use the signer name in the PEM headers if this is a delegation key",
"if",
"data",
".",
"IsDelegation",
"(",
"role",
")",
"{",
"role",
"=",
"data",
".",
"RoleName",
"(",
"notaryRoleToSigner",
"(",
"role",
")",
")",
"\n",
"}",
"\n",
"keys",
":=",
"notaryRepo",
".",
"GetCryptoService",
"(",
")",
".",
"ListKeys",
"(",
"role",
")",
"\n",
"var",
"err",
"error",
"\n",
"var",
"key",
"data",
".",
"PublicKey",
"\n",
"// always select the first key by ID",
"if",
"len",
"(",
"keys",
")",
">",
"0",
"{",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n",
"keyID",
":=",
"keys",
"[",
"0",
"]",
"\n",
"privKey",
",",
"_",
",",
"err",
":=",
"notaryRepo",
".",
"GetCryptoService",
"(",
")",
".",
"GetPrivateKey",
"(",
"keyID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"key",
"=",
"data",
".",
"PublicKeyFromPrivate",
"(",
"privKey",
")",
"\n",
"}",
"else",
"{",
"key",
",",
"err",
"=",
"notaryRepo",
".",
"GetCryptoService",
"(",
")",
".",
"Create",
"(",
"role",
",",
"\"",
"\"",
",",
"data",
".",
"ECDSAKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"key",
",",
"nil",
"\n",
"}"
] | // generates an ECDSA key without a GUN for the specified role | [
"generates",
"an",
"ECDSA",
"key",
"without",
"a",
"GUN",
"for",
"the",
"specified",
"role"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/trust/sign.go#L206-L230 | train |
docker/cli | cli/command/stack/kubernetes/services.go | RunServices | func RunServices(dockerCli *KubeCli, opts options.Services) error {
filters := opts.Filter.Value()
if err := filters.Validate(supportedServicesFilters); err != nil {
return err
}
client, err := dockerCli.composeClient()
if err != nil {
return nil
}
stacks, err := client.Stacks(false)
if err != nil {
return nil
}
stackName := opts.Namespace
_, err = stacks.Get(stackName)
if apierrs.IsNotFound(err) {
return fmt.Errorf("nothing found in stack: %s", stackName)
}
if err != nil {
return err
}
labelSelector := generateLabelSelector(filters, stackName)
replicasList, daemonsList, servicesList, err := getResourcesForServiceList(dockerCli, filters, labelSelector)
if err != nil {
return err
}
// Convert Replicas sets and kubernetes services to swarm services and formatter information
services, info, err := convertToServices(replicasList, daemonsList, servicesList)
if err != nil {
return err
}
services = filterServicesByName(services, filters.Get("name"), stackName)
if opts.Quiet {
info = map[string]service.ListInfo{}
}
format := opts.Format
if len(format) == 0 {
if len(dockerCli.ConfigFile().ServicesFormat) > 0 && !opts.Quiet {
format = dockerCli.ConfigFile().ServicesFormat
} else {
format = formatter.TableFormatKey
}
}
servicesCtx := formatter.Context{
Output: dockerCli.Out(),
Format: service.NewListFormat(format, opts.Quiet),
}
return service.ListFormatWrite(servicesCtx, services, info)
} | go | func RunServices(dockerCli *KubeCli, opts options.Services) error {
filters := opts.Filter.Value()
if err := filters.Validate(supportedServicesFilters); err != nil {
return err
}
client, err := dockerCli.composeClient()
if err != nil {
return nil
}
stacks, err := client.Stacks(false)
if err != nil {
return nil
}
stackName := opts.Namespace
_, err = stacks.Get(stackName)
if apierrs.IsNotFound(err) {
return fmt.Errorf("nothing found in stack: %s", stackName)
}
if err != nil {
return err
}
labelSelector := generateLabelSelector(filters, stackName)
replicasList, daemonsList, servicesList, err := getResourcesForServiceList(dockerCli, filters, labelSelector)
if err != nil {
return err
}
// Convert Replicas sets and kubernetes services to swarm services and formatter information
services, info, err := convertToServices(replicasList, daemonsList, servicesList)
if err != nil {
return err
}
services = filterServicesByName(services, filters.Get("name"), stackName)
if opts.Quiet {
info = map[string]service.ListInfo{}
}
format := opts.Format
if len(format) == 0 {
if len(dockerCli.ConfigFile().ServicesFormat) > 0 && !opts.Quiet {
format = dockerCli.ConfigFile().ServicesFormat
} else {
format = formatter.TableFormatKey
}
}
servicesCtx := formatter.Context{
Output: dockerCli.Out(),
Format: service.NewListFormat(format, opts.Quiet),
}
return service.ListFormatWrite(servicesCtx, services, info)
} | [
"func",
"RunServices",
"(",
"dockerCli",
"*",
"KubeCli",
",",
"opts",
"options",
".",
"Services",
")",
"error",
"{",
"filters",
":=",
"opts",
".",
"Filter",
".",
"Value",
"(",
")",
"\n",
"if",
"err",
":=",
"filters",
".",
"Validate",
"(",
"supportedServicesFilters",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"dockerCli",
".",
"composeClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"stacks",
",",
"err",
":=",
"client",
".",
"Stacks",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"stackName",
":=",
"opts",
".",
"Namespace",
"\n",
"_",
",",
"err",
"=",
"stacks",
".",
"Get",
"(",
"stackName",
")",
"\n",
"if",
"apierrs",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"stackName",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"labelSelector",
":=",
"generateLabelSelector",
"(",
"filters",
",",
"stackName",
")",
"\n",
"replicasList",
",",
"daemonsList",
",",
"servicesList",
",",
"err",
":=",
"getResourcesForServiceList",
"(",
"dockerCli",
",",
"filters",
",",
"labelSelector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Convert Replicas sets and kubernetes services to swarm services and formatter information",
"services",
",",
"info",
",",
"err",
":=",
"convertToServices",
"(",
"replicasList",
",",
"daemonsList",
",",
"servicesList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"services",
"=",
"filterServicesByName",
"(",
"services",
",",
"filters",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"stackName",
")",
"\n\n",
"if",
"opts",
".",
"Quiet",
"{",
"info",
"=",
"map",
"[",
"string",
"]",
"service",
".",
"ListInfo",
"{",
"}",
"\n",
"}",
"\n\n",
"format",
":=",
"opts",
".",
"Format",
"\n",
"if",
"len",
"(",
"format",
")",
"==",
"0",
"{",
"if",
"len",
"(",
"dockerCli",
".",
"ConfigFile",
"(",
")",
".",
"ServicesFormat",
")",
">",
"0",
"&&",
"!",
"opts",
".",
"Quiet",
"{",
"format",
"=",
"dockerCli",
".",
"ConfigFile",
"(",
")",
".",
"ServicesFormat",
"\n",
"}",
"else",
"{",
"format",
"=",
"formatter",
".",
"TableFormatKey",
"\n",
"}",
"\n",
"}",
"\n\n",
"servicesCtx",
":=",
"formatter",
".",
"Context",
"{",
"Output",
":",
"dockerCli",
".",
"Out",
"(",
")",
",",
"Format",
":",
"service",
".",
"NewListFormat",
"(",
"format",
",",
"opts",
".",
"Quiet",
")",
",",
"}",
"\n",
"return",
"service",
".",
"ListFormatWrite",
"(",
"servicesCtx",
",",
"services",
",",
"info",
")",
"\n",
"}"
] | // RunServices is the kubernetes implementation of docker stack services | [
"RunServices",
"is",
"the",
"kubernetes",
"implementation",
"of",
"docker",
"stack",
"services"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/stack/kubernetes/services.go#L83-L136 | train |
docker/cli | cli/context/kubernetes/save.go | FromKubeConfig | func FromKubeConfig(kubeconfig, kubeContext, namespaceOverride string) (Endpoint, error) {
cfg := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
&clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeconfig},
&clientcmd.ConfigOverrides{CurrentContext: kubeContext, Context: clientcmdapi.Context{Namespace: namespaceOverride}})
ns, _, err := cfg.Namespace()
if err != nil {
return Endpoint{}, err
}
clientcfg, err := cfg.ClientConfig()
if err != nil {
return Endpoint{}, err
}
var ca, key, cert []byte
if ca, err = readFileOrDefault(clientcfg.CAFile, clientcfg.CAData); err != nil {
return Endpoint{}, err
}
if key, err = readFileOrDefault(clientcfg.KeyFile, clientcfg.KeyData); err != nil {
return Endpoint{}, err
}
if cert, err = readFileOrDefault(clientcfg.CertFile, clientcfg.CertData); err != nil {
return Endpoint{}, err
}
var tlsData *context.TLSData
if ca != nil || cert != nil || key != nil {
tlsData = &context.TLSData{
CA: ca,
Cert: cert,
Key: key,
}
}
return Endpoint{
EndpointMeta: EndpointMeta{
EndpointMetaBase: context.EndpointMetaBase{
Host: clientcfg.Host,
SkipTLSVerify: clientcfg.Insecure,
},
DefaultNamespace: ns,
AuthProvider: clientcfg.AuthProvider,
Exec: clientcfg.ExecProvider,
},
TLSData: tlsData,
}, nil
} | go | func FromKubeConfig(kubeconfig, kubeContext, namespaceOverride string) (Endpoint, error) {
cfg := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
&clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeconfig},
&clientcmd.ConfigOverrides{CurrentContext: kubeContext, Context: clientcmdapi.Context{Namespace: namespaceOverride}})
ns, _, err := cfg.Namespace()
if err != nil {
return Endpoint{}, err
}
clientcfg, err := cfg.ClientConfig()
if err != nil {
return Endpoint{}, err
}
var ca, key, cert []byte
if ca, err = readFileOrDefault(clientcfg.CAFile, clientcfg.CAData); err != nil {
return Endpoint{}, err
}
if key, err = readFileOrDefault(clientcfg.KeyFile, clientcfg.KeyData); err != nil {
return Endpoint{}, err
}
if cert, err = readFileOrDefault(clientcfg.CertFile, clientcfg.CertData); err != nil {
return Endpoint{}, err
}
var tlsData *context.TLSData
if ca != nil || cert != nil || key != nil {
tlsData = &context.TLSData{
CA: ca,
Cert: cert,
Key: key,
}
}
return Endpoint{
EndpointMeta: EndpointMeta{
EndpointMetaBase: context.EndpointMetaBase{
Host: clientcfg.Host,
SkipTLSVerify: clientcfg.Insecure,
},
DefaultNamespace: ns,
AuthProvider: clientcfg.AuthProvider,
Exec: clientcfg.ExecProvider,
},
TLSData: tlsData,
}, nil
} | [
"func",
"FromKubeConfig",
"(",
"kubeconfig",
",",
"kubeContext",
",",
"namespaceOverride",
"string",
")",
"(",
"Endpoint",
",",
"error",
")",
"{",
"cfg",
":=",
"clientcmd",
".",
"NewNonInteractiveDeferredLoadingClientConfig",
"(",
"&",
"clientcmd",
".",
"ClientConfigLoadingRules",
"{",
"ExplicitPath",
":",
"kubeconfig",
"}",
",",
"&",
"clientcmd",
".",
"ConfigOverrides",
"{",
"CurrentContext",
":",
"kubeContext",
",",
"Context",
":",
"clientcmdapi",
".",
"Context",
"{",
"Namespace",
":",
"namespaceOverride",
"}",
"}",
")",
"\n",
"ns",
",",
"_",
",",
"err",
":=",
"cfg",
".",
"Namespace",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Endpoint",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"clientcfg",
",",
"err",
":=",
"cfg",
".",
"ClientConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Endpoint",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"var",
"ca",
",",
"key",
",",
"cert",
"[",
"]",
"byte",
"\n",
"if",
"ca",
",",
"err",
"=",
"readFileOrDefault",
"(",
"clientcfg",
".",
"CAFile",
",",
"clientcfg",
".",
"CAData",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Endpoint",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"if",
"key",
",",
"err",
"=",
"readFileOrDefault",
"(",
"clientcfg",
".",
"KeyFile",
",",
"clientcfg",
".",
"KeyData",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Endpoint",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"if",
"cert",
",",
"err",
"=",
"readFileOrDefault",
"(",
"clientcfg",
".",
"CertFile",
",",
"clientcfg",
".",
"CertData",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Endpoint",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"var",
"tlsData",
"*",
"context",
".",
"TLSData",
"\n",
"if",
"ca",
"!=",
"nil",
"||",
"cert",
"!=",
"nil",
"||",
"key",
"!=",
"nil",
"{",
"tlsData",
"=",
"&",
"context",
".",
"TLSData",
"{",
"CA",
":",
"ca",
",",
"Cert",
":",
"cert",
",",
"Key",
":",
"key",
",",
"}",
"\n",
"}",
"\n",
"return",
"Endpoint",
"{",
"EndpointMeta",
":",
"EndpointMeta",
"{",
"EndpointMetaBase",
":",
"context",
".",
"EndpointMetaBase",
"{",
"Host",
":",
"clientcfg",
".",
"Host",
",",
"SkipTLSVerify",
":",
"clientcfg",
".",
"Insecure",
",",
"}",
",",
"DefaultNamespace",
":",
"ns",
",",
"AuthProvider",
":",
"clientcfg",
".",
"AuthProvider",
",",
"Exec",
":",
"clientcfg",
".",
"ExecProvider",
",",
"}",
",",
"TLSData",
":",
"tlsData",
",",
"}",
",",
"nil",
"\n",
"}"
] | // FromKubeConfig creates a Kubernetes endpoint from a Kubeconfig file | [
"FromKubeConfig",
"creates",
"a",
"Kubernetes",
"endpoint",
"from",
"a",
"Kubeconfig",
"file"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/context/kubernetes/save.go#L12-L54 | train |
docker/cli | cli/command/container/create.go | NewCreateCommand | func NewCreateCommand(dockerCli command.Cli) *cobra.Command {
var opts createOptions
var copts *containerOptions
cmd := &cobra.Command{
Use: "create [OPTIONS] IMAGE [COMMAND] [ARG...]",
Short: "Create a new container",
Args: cli.RequiresMinArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
copts.Image = args[0]
if len(args) > 1 {
copts.Args = args[1:]
}
return runCreate(dockerCli, cmd.Flags(), &opts, copts)
},
}
flags := cmd.Flags()
flags.SetInterspersed(false)
flags.StringVar(&opts.name, "name", "", "Assign a name to the container")
// Add an explicit help that doesn't have a `-h` to prevent the conflict
// with hostname
flags.Bool("help", false, "Print usage")
command.AddPlatformFlag(flags, &opts.platform)
command.AddTrustVerificationFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
copts = addFlags(flags)
return cmd
} | go | func NewCreateCommand(dockerCli command.Cli) *cobra.Command {
var opts createOptions
var copts *containerOptions
cmd := &cobra.Command{
Use: "create [OPTIONS] IMAGE [COMMAND] [ARG...]",
Short: "Create a new container",
Args: cli.RequiresMinArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
copts.Image = args[0]
if len(args) > 1 {
copts.Args = args[1:]
}
return runCreate(dockerCli, cmd.Flags(), &opts, copts)
},
}
flags := cmd.Flags()
flags.SetInterspersed(false)
flags.StringVar(&opts.name, "name", "", "Assign a name to the container")
// Add an explicit help that doesn't have a `-h` to prevent the conflict
// with hostname
flags.Bool("help", false, "Print usage")
command.AddPlatformFlag(flags, &opts.platform)
command.AddTrustVerificationFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
copts = addFlags(flags)
return cmd
} | [
"func",
"NewCreateCommand",
"(",
"dockerCli",
"command",
".",
"Cli",
")",
"*",
"cobra",
".",
"Command",
"{",
"var",
"opts",
"createOptions",
"\n",
"var",
"copts",
"*",
"containerOptions",
"\n\n",
"cmd",
":=",
"&",
"cobra",
".",
"Command",
"{",
"Use",
":",
"\"",
"\"",
",",
"Short",
":",
"\"",
"\"",
",",
"Args",
":",
"cli",
".",
"RequiresMinArgs",
"(",
"1",
")",
",",
"RunE",
":",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"copts",
".",
"Image",
"=",
"args",
"[",
"0",
"]",
"\n",
"if",
"len",
"(",
"args",
")",
">",
"1",
"{",
"copts",
".",
"Args",
"=",
"args",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"return",
"runCreate",
"(",
"dockerCli",
",",
"cmd",
".",
"Flags",
"(",
")",
",",
"&",
"opts",
",",
"copts",
")",
"\n",
"}",
",",
"}",
"\n\n",
"flags",
":=",
"cmd",
".",
"Flags",
"(",
")",
"\n",
"flags",
".",
"SetInterspersed",
"(",
"false",
")",
"\n\n",
"flags",
".",
"StringVar",
"(",
"&",
"opts",
".",
"name",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"// Add an explicit help that doesn't have a `-h` to prevent the conflict",
"// with hostname",
"flags",
".",
"Bool",
"(",
"\"",
"\"",
",",
"false",
",",
"\"",
"\"",
")",
"\n\n",
"command",
".",
"AddPlatformFlag",
"(",
"flags",
",",
"&",
"opts",
".",
"platform",
")",
"\n",
"command",
".",
"AddTrustVerificationFlags",
"(",
"flags",
",",
"&",
"opts",
".",
"untrusted",
",",
"dockerCli",
".",
"ContentTrustEnabled",
"(",
")",
")",
"\n",
"copts",
"=",
"addFlags",
"(",
"flags",
")",
"\n",
"return",
"cmd",
"\n",
"}"
] | // NewCreateCommand creates a new cobra.Command for `docker create` | [
"NewCreateCommand",
"creates",
"a",
"new",
"cobra",
".",
"Command",
"for",
"docker",
"create"
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/container/create.go#L32-L62 | train |
docker/cli | cli/command/trust/revoke.go | getSignableRolesForTargetAndRemove | func getSignableRolesForTargetAndRemove(releasedTarget client.Target, notaryRepo client.Repository) error {
signableRoles, err := trust.GetSignableRoles(notaryRepo, &releasedTarget)
if err != nil {
return err
}
// remove from all roles
return notaryRepo.RemoveTarget(releasedTarget.Name, signableRoles...)
} | go | func getSignableRolesForTargetAndRemove(releasedTarget client.Target, notaryRepo client.Repository) error {
signableRoles, err := trust.GetSignableRoles(notaryRepo, &releasedTarget)
if err != nil {
return err
}
// remove from all roles
return notaryRepo.RemoveTarget(releasedTarget.Name, signableRoles...)
} | [
"func",
"getSignableRolesForTargetAndRemove",
"(",
"releasedTarget",
"client",
".",
"Target",
",",
"notaryRepo",
"client",
".",
"Repository",
")",
"error",
"{",
"signableRoles",
",",
"err",
":=",
"trust",
".",
"GetSignableRoles",
"(",
"notaryRepo",
",",
"&",
"releasedTarget",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// remove from all roles",
"return",
"notaryRepo",
".",
"RemoveTarget",
"(",
"releasedTarget",
".",
"Name",
",",
"signableRoles",
"...",
")",
"\n",
"}"
] | // get all the roles that signed the target and removes it from all roles. | [
"get",
"all",
"the",
"roles",
"that",
"signed",
"the",
"target",
"and",
"removes",
"it",
"from",
"all",
"roles",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/cli/command/trust/revoke.go#L118-L125 | train |
docker/cli | internal/containerizedengine/containerd.go | NewClient | func NewClient(sockPath string) (clitypes.ContainerizedClient, error) {
if sockPath == "" {
sockPath = containerdSockPath
}
cclient, err := containerd.New(sockPath)
if err != nil {
return nil, err
}
return &baseClient{
cclient: cclient,
}, nil
} | go | func NewClient(sockPath string) (clitypes.ContainerizedClient, error) {
if sockPath == "" {
sockPath = containerdSockPath
}
cclient, err := containerd.New(sockPath)
if err != nil {
return nil, err
}
return &baseClient{
cclient: cclient,
}, nil
} | [
"func",
"NewClient",
"(",
"sockPath",
"string",
")",
"(",
"clitypes",
".",
"ContainerizedClient",
",",
"error",
")",
"{",
"if",
"sockPath",
"==",
"\"",
"\"",
"{",
"sockPath",
"=",
"containerdSockPath",
"\n",
"}",
"\n",
"cclient",
",",
"err",
":=",
"containerd",
".",
"New",
"(",
"sockPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"baseClient",
"{",
"cclient",
":",
"cclient",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewClient returns a new containerizedengine client
// This client can be used to manage the lifecycle of
// dockerd running as a container on containerd. | [
"NewClient",
"returns",
"a",
"new",
"containerizedengine",
"client",
"This",
"client",
"can",
"be",
"used",
"to",
"manage",
"the",
"lifecycle",
"of",
"dockerd",
"running",
"as",
"a",
"container",
"on",
"containerd",
"."
] | 3273c2e23546dddd0ff8bb499f4aba02fe60bf30 | https://github.com/docker/cli/blob/3273c2e23546dddd0ff8bb499f4aba02fe60bf30/internal/containerizedengine/containerd.go#L19-L30 | train |
containernetworking/cni | pkg/invoke/delegate.go | DelegateAdd | func DelegateAdd(ctx context.Context, delegatePlugin string, netconf []byte, exec Exec) (types.Result, error) {
pluginPath, realExec, err := delegateCommon("ADD", delegatePlugin, exec)
if err != nil {
return nil, err
}
return ExecPluginWithResult(ctx, pluginPath, netconf, ArgsFromEnv(), realExec)
} | go | func DelegateAdd(ctx context.Context, delegatePlugin string, netconf []byte, exec Exec) (types.Result, error) {
pluginPath, realExec, err := delegateCommon("ADD", delegatePlugin, exec)
if err != nil {
return nil, err
}
return ExecPluginWithResult(ctx, pluginPath, netconf, ArgsFromEnv(), realExec)
} | [
"func",
"DelegateAdd",
"(",
"ctx",
"context",
".",
"Context",
",",
"delegatePlugin",
"string",
",",
"netconf",
"[",
"]",
"byte",
",",
"exec",
"Exec",
")",
"(",
"types",
".",
"Result",
",",
"error",
")",
"{",
"pluginPath",
",",
"realExec",
",",
"err",
":=",
"delegateCommon",
"(",
"\"",
"\"",
",",
"delegatePlugin",
",",
"exec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"ExecPluginWithResult",
"(",
"ctx",
",",
"pluginPath",
",",
"netconf",
",",
"ArgsFromEnv",
"(",
")",
",",
"realExec",
")",
"\n",
"}"
] | // DelegateAdd calls the given delegate plugin with the CNI ADD action and
// JSON configuration | [
"DelegateAdd",
"calls",
"the",
"given",
"delegate",
"plugin",
"with",
"the",
"CNI",
"ADD",
"action",
"and",
"JSON",
"configuration"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/invoke/delegate.go#L46-L53 | train |
containernetworking/cni | pkg/invoke/delegate.go | DelegateCheck | func DelegateCheck(ctx context.Context, delegatePlugin string, netconf []byte, exec Exec) error {
pluginPath, realExec, err := delegateCommon("CHECK", delegatePlugin, exec)
if err != nil {
return err
}
return ExecPluginWithoutResult(ctx, pluginPath, netconf, ArgsFromEnv(), realExec)
} | go | func DelegateCheck(ctx context.Context, delegatePlugin string, netconf []byte, exec Exec) error {
pluginPath, realExec, err := delegateCommon("CHECK", delegatePlugin, exec)
if err != nil {
return err
}
return ExecPluginWithoutResult(ctx, pluginPath, netconf, ArgsFromEnv(), realExec)
} | [
"func",
"DelegateCheck",
"(",
"ctx",
"context",
".",
"Context",
",",
"delegatePlugin",
"string",
",",
"netconf",
"[",
"]",
"byte",
",",
"exec",
"Exec",
")",
"error",
"{",
"pluginPath",
",",
"realExec",
",",
"err",
":=",
"delegateCommon",
"(",
"\"",
"\"",
",",
"delegatePlugin",
",",
"exec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"ExecPluginWithoutResult",
"(",
"ctx",
",",
"pluginPath",
",",
"netconf",
",",
"ArgsFromEnv",
"(",
")",
",",
"realExec",
")",
"\n",
"}"
] | // DelegateCheck calls the given delegate plugin with the CNI CHECK action and
// JSON configuration | [
"DelegateCheck",
"calls",
"the",
"given",
"delegate",
"plugin",
"with",
"the",
"CNI",
"CHECK",
"action",
"and",
"JSON",
"configuration"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/invoke/delegate.go#L57-L64 | train |
containernetworking/cni | pkg/invoke/exec.go | GetVersionInfo | func GetVersionInfo(ctx context.Context, pluginPath string, exec Exec) (version.PluginInfo, error) {
if exec == nil {
exec = defaultExec
}
args := &Args{
Command: "VERSION",
// set fake values required by plugins built against an older version of skel
NetNS: "dummy",
IfName: "dummy",
Path: "dummy",
}
stdin := []byte(fmt.Sprintf(`{"cniVersion":%q}`, version.Current()))
stdoutBytes, err := exec.ExecPlugin(ctx, pluginPath, stdin, args.AsEnv())
if err != nil {
if err.Error() == "unknown CNI_COMMAND: VERSION" {
return version.PluginSupports("0.1.0"), nil
}
return nil, err
}
return exec.Decode(stdoutBytes)
} | go | func GetVersionInfo(ctx context.Context, pluginPath string, exec Exec) (version.PluginInfo, error) {
if exec == nil {
exec = defaultExec
}
args := &Args{
Command: "VERSION",
// set fake values required by plugins built against an older version of skel
NetNS: "dummy",
IfName: "dummy",
Path: "dummy",
}
stdin := []byte(fmt.Sprintf(`{"cniVersion":%q}`, version.Current()))
stdoutBytes, err := exec.ExecPlugin(ctx, pluginPath, stdin, args.AsEnv())
if err != nil {
if err.Error() == "unknown CNI_COMMAND: VERSION" {
return version.PluginSupports("0.1.0"), nil
}
return nil, err
}
return exec.Decode(stdoutBytes)
} | [
"func",
"GetVersionInfo",
"(",
"ctx",
"context",
".",
"Context",
",",
"pluginPath",
"string",
",",
"exec",
"Exec",
")",
"(",
"version",
".",
"PluginInfo",
",",
"error",
")",
"{",
"if",
"exec",
"==",
"nil",
"{",
"exec",
"=",
"defaultExec",
"\n",
"}",
"\n",
"args",
":=",
"&",
"Args",
"{",
"Command",
":",
"\"",
"\"",
",",
"// set fake values required by plugins built against an older version of skel",
"NetNS",
":",
"\"",
"\"",
",",
"IfName",
":",
"\"",
"\"",
",",
"Path",
":",
"\"",
"\"",
",",
"}",
"\n",
"stdin",
":=",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"`{\"cniVersion\":%q}`",
",",
"version",
".",
"Current",
"(",
")",
")",
")",
"\n",
"stdoutBytes",
",",
"err",
":=",
"exec",
".",
"ExecPlugin",
"(",
"ctx",
",",
"pluginPath",
",",
"stdin",
",",
"args",
".",
"AsEnv",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
".",
"Error",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"version",
".",
"PluginSupports",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"exec",
".",
"Decode",
"(",
"stdoutBytes",
")",
"\n",
"}"
] | // GetVersionInfo returns the version information available about the plugin.
// For recent-enough plugins, it uses the information returned by the VERSION
// command. For older plugins which do not recognize that command, it reports
// version 0.1.0 | [
"GetVersionInfo",
"returns",
"the",
"version",
"information",
"available",
"about",
"the",
"plugin",
".",
"For",
"recent",
"-",
"enough",
"plugins",
"it",
"uses",
"the",
"information",
"returned",
"by",
"the",
"VERSION",
"command",
".",
"For",
"older",
"plugins",
"which",
"do",
"not",
"recognize",
"that",
"command",
"it",
"reports",
"version",
"0",
".",
"1",
".",
"0"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/invoke/exec.go#L108-L130 | train |
containernetworking/cni | libcni/api.go | NewCNIConfig | func NewCNIConfig(path []string, exec invoke.Exec) *CNIConfig {
return &CNIConfig{
Path: path,
exec: exec,
}
} | go | func NewCNIConfig(path []string, exec invoke.Exec) *CNIConfig {
return &CNIConfig{
Path: path,
exec: exec,
}
} | [
"func",
"NewCNIConfig",
"(",
"path",
"[",
"]",
"string",
",",
"exec",
"invoke",
".",
"Exec",
")",
"*",
"CNIConfig",
"{",
"return",
"&",
"CNIConfig",
"{",
"Path",
":",
"path",
",",
"exec",
":",
"exec",
",",
"}",
"\n",
"}"
] | // NewCNIConfig returns a new CNIConfig object that will search for plugins
// in the given paths and use the given exec interface to run those plugins,
// or if the exec interface is not given, will use a default exec handler. | [
"NewCNIConfig",
"returns",
"a",
"new",
"CNIConfig",
"object",
"that",
"will",
"search",
"for",
"plugins",
"in",
"the",
"given",
"paths",
"and",
"use",
"the",
"given",
"exec",
"interface",
"to",
"run",
"those",
"plugins",
"or",
"if",
"the",
"exec",
"interface",
"is",
"not",
"given",
"will",
"use",
"a",
"default",
"exec",
"handler",
"."
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L93-L98 | train |
containernetworking/cni | libcni/api.go | injectRuntimeConfig | func injectRuntimeConfig(orig *NetworkConfig, rt *RuntimeConf) (*NetworkConfig, error) {
var err error
rc := make(map[string]interface{})
for capability, supported := range orig.Network.Capabilities {
if !supported {
continue
}
if data, ok := rt.CapabilityArgs[capability]; ok {
rc[capability] = data
}
}
if len(rc) > 0 {
orig, err = InjectConf(orig, map[string]interface{}{"runtimeConfig": rc})
if err != nil {
return nil, err
}
}
return orig, nil
} | go | func injectRuntimeConfig(orig *NetworkConfig, rt *RuntimeConf) (*NetworkConfig, error) {
var err error
rc := make(map[string]interface{})
for capability, supported := range orig.Network.Capabilities {
if !supported {
continue
}
if data, ok := rt.CapabilityArgs[capability]; ok {
rc[capability] = data
}
}
if len(rc) > 0 {
orig, err = InjectConf(orig, map[string]interface{}{"runtimeConfig": rc})
if err != nil {
return nil, err
}
}
return orig, nil
} | [
"func",
"injectRuntimeConfig",
"(",
"orig",
"*",
"NetworkConfig",
",",
"rt",
"*",
"RuntimeConf",
")",
"(",
"*",
"NetworkConfig",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"rc",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"capability",
",",
"supported",
":=",
"range",
"orig",
".",
"Network",
".",
"Capabilities",
"{",
"if",
"!",
"supported",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"data",
",",
"ok",
":=",
"rt",
".",
"CapabilityArgs",
"[",
"capability",
"]",
";",
"ok",
"{",
"rc",
"[",
"capability",
"]",
"=",
"data",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"rc",
")",
">",
"0",
"{",
"orig",
",",
"err",
"=",
"InjectConf",
"(",
"orig",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"rc",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"orig",
",",
"nil",
"\n",
"}"
] | // This function takes a libcni RuntimeConf structure and injects values into
// a "runtimeConfig" dictionary in the CNI network configuration JSON that
// will be passed to the plugin on stdin.
//
// Only "capabilities arguments" passed by the runtime are currently injected.
// These capabilities arguments are filtered through the plugin's advertised
// capabilities from its config JSON, and any keys in the CapabilityArgs
// matching plugin capabilities are added to the "runtimeConfig" dictionary
// sent to the plugin via JSON on stdin. For example, if the plugin's
// capabilities include "portMappings", and the CapabilityArgs map includes a
// "portMappings" key, that key and its value are added to the "runtimeConfig"
// dictionary to be passed to the plugin's stdin. | [
"This",
"function",
"takes",
"a",
"libcni",
"RuntimeConf",
"structure",
"and",
"injects",
"values",
"into",
"a",
"runtimeConfig",
"dictionary",
"in",
"the",
"CNI",
"network",
"configuration",
"JSON",
"that",
"will",
"be",
"passed",
"to",
"the",
"plugin",
"on",
"stdin",
".",
"Only",
"capabilities",
"arguments",
"passed",
"by",
"the",
"runtime",
"are",
"currently",
"injected",
".",
"These",
"capabilities",
"arguments",
"are",
"filtered",
"through",
"the",
"plugin",
"s",
"advertised",
"capabilities",
"from",
"its",
"config",
"JSON",
"and",
"any",
"keys",
"in",
"the",
"CapabilityArgs",
"matching",
"plugin",
"capabilities",
"are",
"added",
"to",
"the",
"runtimeConfig",
"dictionary",
"sent",
"to",
"the",
"plugin",
"via",
"JSON",
"on",
"stdin",
".",
"For",
"example",
"if",
"the",
"plugin",
"s",
"capabilities",
"include",
"portMappings",
"and",
"the",
"CapabilityArgs",
"map",
"includes",
"a",
"portMappings",
"key",
"that",
"key",
"and",
"its",
"value",
"are",
"added",
"to",
"the",
"runtimeConfig",
"dictionary",
"to",
"be",
"passed",
"to",
"the",
"plugin",
"s",
"stdin",
"."
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L133-L154 | train |
containernetworking/cni | libcni/api.go | ensureExec | func (c *CNIConfig) ensureExec() invoke.Exec {
if c.exec == nil {
c.exec = &invoke.DefaultExec{
RawExec: &invoke.RawExec{Stderr: os.Stderr},
PluginDecoder: version.PluginDecoder{},
}
}
return c.exec
} | go | func (c *CNIConfig) ensureExec() invoke.Exec {
if c.exec == nil {
c.exec = &invoke.DefaultExec{
RawExec: &invoke.RawExec{Stderr: os.Stderr},
PluginDecoder: version.PluginDecoder{},
}
}
return c.exec
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"ensureExec",
"(",
")",
"invoke",
".",
"Exec",
"{",
"if",
"c",
".",
"exec",
"==",
"nil",
"{",
"c",
".",
"exec",
"=",
"&",
"invoke",
".",
"DefaultExec",
"{",
"RawExec",
":",
"&",
"invoke",
".",
"RawExec",
"{",
"Stderr",
":",
"os",
".",
"Stderr",
"}",
",",
"PluginDecoder",
":",
"version",
".",
"PluginDecoder",
"{",
"}",
",",
"}",
"\n",
"}",
"\n",
"return",
"c",
".",
"exec",
"\n",
"}"
] | // ensure we have a usable exec if the CNIConfig was not given one | [
"ensure",
"we",
"have",
"a",
"usable",
"exec",
"if",
"the",
"CNIConfig",
"was",
"not",
"given",
"one"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L157-L165 | train |
containernetworking/cni | libcni/api.go | AddNetworkList | func (c *CNIConfig) AddNetworkList(ctx context.Context, list *NetworkConfigList, rt *RuntimeConf) (types.Result, error) {
var err error
var result types.Result
for _, net := range list.Plugins {
result, err = c.addNetwork(ctx, list.Name, list.CNIVersion, net, result, rt)
if err != nil {
return nil, err
}
}
if err = setCachedResult(result, list.Name, rt); err != nil {
return nil, fmt.Errorf("failed to set network %q cached result: %v", list.Name, err)
}
return result, nil
} | go | func (c *CNIConfig) AddNetworkList(ctx context.Context, list *NetworkConfigList, rt *RuntimeConf) (types.Result, error) {
var err error
var result types.Result
for _, net := range list.Plugins {
result, err = c.addNetwork(ctx, list.Name, list.CNIVersion, net, result, rt)
if err != nil {
return nil, err
}
}
if err = setCachedResult(result, list.Name, rt); err != nil {
return nil, fmt.Errorf("failed to set network %q cached result: %v", list.Name, err)
}
return result, nil
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"AddNetworkList",
"(",
"ctx",
"context",
".",
"Context",
",",
"list",
"*",
"NetworkConfigList",
",",
"rt",
"*",
"RuntimeConf",
")",
"(",
"types",
".",
"Result",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"result",
"types",
".",
"Result",
"\n",
"for",
"_",
",",
"net",
":=",
"range",
"list",
".",
"Plugins",
"{",
"result",
",",
"err",
"=",
"c",
".",
"addNetwork",
"(",
"ctx",
",",
"list",
".",
"Name",
",",
"list",
".",
"CNIVersion",
",",
"net",
",",
"result",
",",
"rt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"setCachedResult",
"(",
"result",
",",
"list",
".",
"Name",
",",
"rt",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"list",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // AddNetworkList executes a sequence of plugins with the ADD command | [
"AddNetworkList",
"executes",
"a",
"sequence",
"of",
"plugins",
"with",
"the",
"ADD",
"command"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L252-L267 | train |
containernetworking/cni | libcni/api.go | CheckNetworkList | func (c *CNIConfig) CheckNetworkList(ctx context.Context, list *NetworkConfigList, rt *RuntimeConf) error {
// CHECK was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(list.CNIVersion, "0.4.0"); err != nil {
return err
} else if !gtet {
return fmt.Errorf("configuration version %q does not support the CHECK command", list.CNIVersion)
}
if list.DisableCheck {
return nil
}
cachedResult, err := getCachedResult(list.Name, list.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", list.Name, err)
}
for _, net := range list.Plugins {
if err := c.checkNetwork(ctx, list.Name, list.CNIVersion, net, cachedResult, rt); err != nil {
return err
}
}
return nil
} | go | func (c *CNIConfig) CheckNetworkList(ctx context.Context, list *NetworkConfigList, rt *RuntimeConf) error {
// CHECK was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(list.CNIVersion, "0.4.0"); err != nil {
return err
} else if !gtet {
return fmt.Errorf("configuration version %q does not support the CHECK command", list.CNIVersion)
}
if list.DisableCheck {
return nil
}
cachedResult, err := getCachedResult(list.Name, list.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", list.Name, err)
}
for _, net := range list.Plugins {
if err := c.checkNetwork(ctx, list.Name, list.CNIVersion, net, cachedResult, rt); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"CheckNetworkList",
"(",
"ctx",
"context",
".",
"Context",
",",
"list",
"*",
"NetworkConfigList",
",",
"rt",
"*",
"RuntimeConf",
")",
"error",
"{",
"// CHECK was added in CNI spec version 0.4.0 and higher",
"if",
"gtet",
",",
"err",
":=",
"version",
".",
"GreaterThanOrEqualTo",
"(",
"list",
".",
"CNIVersion",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"!",
"gtet",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"list",
".",
"CNIVersion",
")",
"\n",
"}",
"\n\n",
"if",
"list",
".",
"DisableCheck",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"cachedResult",
",",
"err",
":=",
"getCachedResult",
"(",
"list",
".",
"Name",
",",
"list",
".",
"CNIVersion",
",",
"rt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"list",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"net",
":=",
"range",
"list",
".",
"Plugins",
"{",
"if",
"err",
":=",
"c",
".",
"checkNetwork",
"(",
"ctx",
",",
"list",
".",
"Name",
",",
"list",
".",
"CNIVersion",
",",
"net",
",",
"cachedResult",
",",
"rt",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CheckNetworkList executes a sequence of plugins with the CHECK command | [
"CheckNetworkList",
"executes",
"a",
"sequence",
"of",
"plugins",
"with",
"the",
"CHECK",
"command"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L285-L309 | train |
containernetworking/cni | libcni/api.go | DelNetworkList | func (c *CNIConfig) DelNetworkList(ctx context.Context, list *NetworkConfigList, rt *RuntimeConf) error {
var cachedResult types.Result
// Cached result on DEL was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(list.CNIVersion, "0.4.0"); err != nil {
return err
} else if gtet {
cachedResult, err = getCachedResult(list.Name, list.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", list.Name, err)
}
}
for i := len(list.Plugins) - 1; i >= 0; i-- {
net := list.Plugins[i]
if err := c.delNetwork(ctx, list.Name, list.CNIVersion, net, cachedResult, rt); err != nil {
return err
}
}
_ = delCachedResult(list.Name, rt)
return nil
} | go | func (c *CNIConfig) DelNetworkList(ctx context.Context, list *NetworkConfigList, rt *RuntimeConf) error {
var cachedResult types.Result
// Cached result on DEL was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(list.CNIVersion, "0.4.0"); err != nil {
return err
} else if gtet {
cachedResult, err = getCachedResult(list.Name, list.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", list.Name, err)
}
}
for i := len(list.Plugins) - 1; i >= 0; i-- {
net := list.Plugins[i]
if err := c.delNetwork(ctx, list.Name, list.CNIVersion, net, cachedResult, rt); err != nil {
return err
}
}
_ = delCachedResult(list.Name, rt)
return nil
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"DelNetworkList",
"(",
"ctx",
"context",
".",
"Context",
",",
"list",
"*",
"NetworkConfigList",
",",
"rt",
"*",
"RuntimeConf",
")",
"error",
"{",
"var",
"cachedResult",
"types",
".",
"Result",
"\n\n",
"// Cached result on DEL was added in CNI spec version 0.4.0 and higher",
"if",
"gtet",
",",
"err",
":=",
"version",
".",
"GreaterThanOrEqualTo",
"(",
"list",
".",
"CNIVersion",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"gtet",
"{",
"cachedResult",
",",
"err",
"=",
"getCachedResult",
"(",
"list",
".",
"Name",
",",
"list",
".",
"CNIVersion",
",",
"rt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"list",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"len",
"(",
"list",
".",
"Plugins",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"net",
":=",
"list",
".",
"Plugins",
"[",
"i",
"]",
"\n",
"if",
"err",
":=",
"c",
".",
"delNetwork",
"(",
"ctx",
",",
"list",
".",
"Name",
",",
"list",
".",
"CNIVersion",
",",
"net",
",",
"cachedResult",
",",
"rt",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"_",
"=",
"delCachedResult",
"(",
"list",
".",
"Name",
",",
"rt",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // DelNetworkList executes a sequence of plugins with the DEL command | [
"DelNetworkList",
"executes",
"a",
"sequence",
"of",
"plugins",
"with",
"the",
"DEL",
"command"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L327-L349 | train |
containernetworking/cni | libcni/api.go | AddNetwork | func (c *CNIConfig) AddNetwork(ctx context.Context, net *NetworkConfig, rt *RuntimeConf) (types.Result, error) {
result, err := c.addNetwork(ctx, net.Network.Name, net.Network.CNIVersion, net, nil, rt)
if err != nil {
return nil, err
}
if err = setCachedResult(result, net.Network.Name, rt); err != nil {
return nil, fmt.Errorf("failed to set network %q cached result: %v", net.Network.Name, err)
}
return result, nil
} | go | func (c *CNIConfig) AddNetwork(ctx context.Context, net *NetworkConfig, rt *RuntimeConf) (types.Result, error) {
result, err := c.addNetwork(ctx, net.Network.Name, net.Network.CNIVersion, net, nil, rt)
if err != nil {
return nil, err
}
if err = setCachedResult(result, net.Network.Name, rt); err != nil {
return nil, fmt.Errorf("failed to set network %q cached result: %v", net.Network.Name, err)
}
return result, nil
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"AddNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"net",
"*",
"NetworkConfig",
",",
"rt",
"*",
"RuntimeConf",
")",
"(",
"types",
".",
"Result",
",",
"error",
")",
"{",
"result",
",",
"err",
":=",
"c",
".",
"addNetwork",
"(",
"ctx",
",",
"net",
".",
"Network",
".",
"Name",
",",
"net",
".",
"Network",
".",
"CNIVersion",
",",
"net",
",",
"nil",
",",
"rt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"setCachedResult",
"(",
"result",
",",
"net",
".",
"Network",
".",
"Name",
",",
"rt",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"net",
".",
"Network",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // AddNetwork executes the plugin with the ADD command | [
"AddNetwork",
"executes",
"the",
"plugin",
"with",
"the",
"ADD",
"command"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L352-L363 | train |
containernetworking/cni | libcni/api.go | CheckNetwork | func (c *CNIConfig) CheckNetwork(ctx context.Context, net *NetworkConfig, rt *RuntimeConf) error {
// CHECK was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(net.Network.CNIVersion, "0.4.0"); err != nil {
return err
} else if !gtet {
return fmt.Errorf("configuration version %q does not support the CHECK command", net.Network.CNIVersion)
}
cachedResult, err := getCachedResult(net.Network.Name, net.Network.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", net.Network.Name, err)
}
return c.checkNetwork(ctx, net.Network.Name, net.Network.CNIVersion, net, cachedResult, rt)
} | go | func (c *CNIConfig) CheckNetwork(ctx context.Context, net *NetworkConfig, rt *RuntimeConf) error {
// CHECK was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(net.Network.CNIVersion, "0.4.0"); err != nil {
return err
} else if !gtet {
return fmt.Errorf("configuration version %q does not support the CHECK command", net.Network.CNIVersion)
}
cachedResult, err := getCachedResult(net.Network.Name, net.Network.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", net.Network.Name, err)
}
return c.checkNetwork(ctx, net.Network.Name, net.Network.CNIVersion, net, cachedResult, rt)
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"CheckNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"net",
"*",
"NetworkConfig",
",",
"rt",
"*",
"RuntimeConf",
")",
"error",
"{",
"// CHECK was added in CNI spec version 0.4.0 and higher",
"if",
"gtet",
",",
"err",
":=",
"version",
".",
"GreaterThanOrEqualTo",
"(",
"net",
".",
"Network",
".",
"CNIVersion",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"!",
"gtet",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"net",
".",
"Network",
".",
"CNIVersion",
")",
"\n",
"}",
"\n\n",
"cachedResult",
",",
"err",
":=",
"getCachedResult",
"(",
"net",
".",
"Network",
".",
"Name",
",",
"net",
".",
"Network",
".",
"CNIVersion",
",",
"rt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"net",
".",
"Network",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"checkNetwork",
"(",
"ctx",
",",
"net",
".",
"Network",
".",
"Name",
",",
"net",
".",
"Network",
".",
"CNIVersion",
",",
"net",
",",
"cachedResult",
",",
"rt",
")",
"\n",
"}"
] | // CheckNetwork executes the plugin with the CHECK command | [
"CheckNetwork",
"executes",
"the",
"plugin",
"with",
"the",
"CHECK",
"command"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L366-L379 | train |
containernetworking/cni | libcni/api.go | DelNetwork | func (c *CNIConfig) DelNetwork(ctx context.Context, net *NetworkConfig, rt *RuntimeConf) error {
var cachedResult types.Result
// Cached result on DEL was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(net.Network.CNIVersion, "0.4.0"); err != nil {
return err
} else if gtet {
cachedResult, err = getCachedResult(net.Network.Name, net.Network.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", net.Network.Name, err)
}
}
if err := c.delNetwork(ctx, net.Network.Name, net.Network.CNIVersion, net, cachedResult, rt); err != nil {
return err
}
_ = delCachedResult(net.Network.Name, rt)
return nil
} | go | func (c *CNIConfig) DelNetwork(ctx context.Context, net *NetworkConfig, rt *RuntimeConf) error {
var cachedResult types.Result
// Cached result on DEL was added in CNI spec version 0.4.0 and higher
if gtet, err := version.GreaterThanOrEqualTo(net.Network.CNIVersion, "0.4.0"); err != nil {
return err
} else if gtet {
cachedResult, err = getCachedResult(net.Network.Name, net.Network.CNIVersion, rt)
if err != nil {
return fmt.Errorf("failed to get network %q cached result: %v", net.Network.Name, err)
}
}
if err := c.delNetwork(ctx, net.Network.Name, net.Network.CNIVersion, net, cachedResult, rt); err != nil {
return err
}
_ = delCachedResult(net.Network.Name, rt)
return nil
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"DelNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"net",
"*",
"NetworkConfig",
",",
"rt",
"*",
"RuntimeConf",
")",
"error",
"{",
"var",
"cachedResult",
"types",
".",
"Result",
"\n\n",
"// Cached result on DEL was added in CNI spec version 0.4.0 and higher",
"if",
"gtet",
",",
"err",
":=",
"version",
".",
"GreaterThanOrEqualTo",
"(",
"net",
".",
"Network",
".",
"CNIVersion",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"gtet",
"{",
"cachedResult",
",",
"err",
"=",
"getCachedResult",
"(",
"net",
".",
"Network",
".",
"Name",
",",
"net",
".",
"Network",
".",
"CNIVersion",
",",
"rt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"net",
".",
"Network",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"c",
".",
"delNetwork",
"(",
"ctx",
",",
"net",
".",
"Network",
".",
"Name",
",",
"net",
".",
"Network",
".",
"CNIVersion",
",",
"net",
",",
"cachedResult",
",",
"rt",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
"=",
"delCachedResult",
"(",
"net",
".",
"Network",
".",
"Name",
",",
"rt",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // DelNetwork executes the plugin with the DEL command | [
"DelNetwork",
"executes",
"the",
"plugin",
"with",
"the",
"DEL",
"command"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L382-L400 | train |
containernetworking/cni | libcni/api.go | ValidateNetworkList | func (c *CNIConfig) ValidateNetworkList(ctx context.Context, list *NetworkConfigList) ([]string, error) {
version := list.CNIVersion
// holding map for seen caps (in case of duplicates)
caps := map[string]interface{}{}
errs := []error{}
for _, net := range list.Plugins {
if err := c.validatePlugin(ctx, net.Network.Type, version); err != nil {
errs = append(errs, err)
}
for c, enabled := range net.Network.Capabilities {
if !enabled {
continue
}
caps[c] = struct{}{}
}
}
if len(errs) > 0 {
return nil, fmt.Errorf("%v", errs)
}
// make caps list
cc := make([]string, 0, len(caps))
for c := range caps {
cc = append(cc, c)
}
return cc, nil
} | go | func (c *CNIConfig) ValidateNetworkList(ctx context.Context, list *NetworkConfigList) ([]string, error) {
version := list.CNIVersion
// holding map for seen caps (in case of duplicates)
caps := map[string]interface{}{}
errs := []error{}
for _, net := range list.Plugins {
if err := c.validatePlugin(ctx, net.Network.Type, version); err != nil {
errs = append(errs, err)
}
for c, enabled := range net.Network.Capabilities {
if !enabled {
continue
}
caps[c] = struct{}{}
}
}
if len(errs) > 0 {
return nil, fmt.Errorf("%v", errs)
}
// make caps list
cc := make([]string, 0, len(caps))
for c := range caps {
cc = append(cc, c)
}
return cc, nil
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"ValidateNetworkList",
"(",
"ctx",
"context",
".",
"Context",
",",
"list",
"*",
"NetworkConfigList",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"version",
":=",
"list",
".",
"CNIVersion",
"\n\n",
"// holding map for seen caps (in case of duplicates)",
"caps",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n\n",
"errs",
":=",
"[",
"]",
"error",
"{",
"}",
"\n",
"for",
"_",
",",
"net",
":=",
"range",
"list",
".",
"Plugins",
"{",
"if",
"err",
":=",
"c",
".",
"validatePlugin",
"(",
"ctx",
",",
"net",
".",
"Network",
".",
"Type",
",",
"version",
")",
";",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"c",
",",
"enabled",
":=",
"range",
"net",
".",
"Network",
".",
"Capabilities",
"{",
"if",
"!",
"enabled",
"{",
"continue",
"\n",
"}",
"\n",
"caps",
"[",
"c",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"errs",
")",
">",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errs",
")",
"\n",
"}",
"\n\n",
"// make caps list",
"cc",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"caps",
")",
")",
"\n",
"for",
"c",
":=",
"range",
"caps",
"{",
"cc",
"=",
"append",
"(",
"cc",
",",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"cc",
",",
"nil",
"\n",
"}"
] | // ValidateNetworkList checks that a configuration is reasonably valid.
// - all the specified plugins exist on disk
// - every plugin supports the desired version.
//
// Returns a list of all capabilities supported by the configuration, or error | [
"ValidateNetworkList",
"checks",
"that",
"a",
"configuration",
"is",
"reasonably",
"valid",
".",
"-",
"all",
"the",
"specified",
"plugins",
"exist",
"on",
"disk",
"-",
"every",
"plugin",
"supports",
"the",
"desired",
"version",
".",
"Returns",
"a",
"list",
"of",
"all",
"capabilities",
"supported",
"by",
"the",
"configuration",
"or",
"error"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L407-L437 | train |
containernetworking/cni | libcni/api.go | ValidateNetwork | func (c *CNIConfig) ValidateNetwork(ctx context.Context, net *NetworkConfig) ([]string, error) {
caps := []string{}
for c, ok := range net.Network.Capabilities {
if ok {
caps = append(caps, c)
}
}
if err := c.validatePlugin(ctx, net.Network.Type, net.Network.CNIVersion); err != nil {
return nil, err
}
return caps, nil
} | go | func (c *CNIConfig) ValidateNetwork(ctx context.Context, net *NetworkConfig) ([]string, error) {
caps := []string{}
for c, ok := range net.Network.Capabilities {
if ok {
caps = append(caps, c)
}
}
if err := c.validatePlugin(ctx, net.Network.Type, net.Network.CNIVersion); err != nil {
return nil, err
}
return caps, nil
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"ValidateNetwork",
"(",
"ctx",
"context",
".",
"Context",
",",
"net",
"*",
"NetworkConfig",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"caps",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"c",
",",
"ok",
":=",
"range",
"net",
".",
"Network",
".",
"Capabilities",
"{",
"if",
"ok",
"{",
"caps",
"=",
"append",
"(",
"caps",
",",
"c",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"validatePlugin",
"(",
"ctx",
",",
"net",
".",
"Network",
".",
"Type",
",",
"net",
".",
"Network",
".",
"CNIVersion",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"caps",
",",
"nil",
"\n",
"}"
] | // ValidateNetwork checks that a configuration is reasonably valid.
// It uses the same logic as ValidateNetworkList)
// Returns a list of capabilities | [
"ValidateNetwork",
"checks",
"that",
"a",
"configuration",
"is",
"reasonably",
"valid",
".",
"It",
"uses",
"the",
"same",
"logic",
"as",
"ValidateNetworkList",
")",
"Returns",
"a",
"list",
"of",
"capabilities"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L442-L453 | train |
containernetworking/cni | libcni/api.go | validatePlugin | func (c *CNIConfig) validatePlugin(ctx context.Context, pluginName, expectedVersion string) error {
pluginPath, err := invoke.FindInPath(pluginName, c.Path)
if err != nil {
return err
}
vi, err := invoke.GetVersionInfo(ctx, pluginPath, c.exec)
if err != nil {
return err
}
for _, vers := range vi.SupportedVersions() {
if vers == expectedVersion {
return nil
}
}
return fmt.Errorf("plugin %s does not support config version %q", pluginName, expectedVersion)
} | go | func (c *CNIConfig) validatePlugin(ctx context.Context, pluginName, expectedVersion string) error {
pluginPath, err := invoke.FindInPath(pluginName, c.Path)
if err != nil {
return err
}
vi, err := invoke.GetVersionInfo(ctx, pluginPath, c.exec)
if err != nil {
return err
}
for _, vers := range vi.SupportedVersions() {
if vers == expectedVersion {
return nil
}
}
return fmt.Errorf("plugin %s does not support config version %q", pluginName, expectedVersion)
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"validatePlugin",
"(",
"ctx",
"context",
".",
"Context",
",",
"pluginName",
",",
"expectedVersion",
"string",
")",
"error",
"{",
"pluginPath",
",",
"err",
":=",
"invoke",
".",
"FindInPath",
"(",
"pluginName",
",",
"c",
".",
"Path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"vi",
",",
"err",
":=",
"invoke",
".",
"GetVersionInfo",
"(",
"ctx",
",",
"pluginPath",
",",
"c",
".",
"exec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"vers",
":=",
"range",
"vi",
".",
"SupportedVersions",
"(",
")",
"{",
"if",
"vers",
"==",
"expectedVersion",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"pluginName",
",",
"expectedVersion",
")",
"\n",
"}"
] | // validatePlugin checks that an individual plugin's configuration is sane | [
"validatePlugin",
"checks",
"that",
"an",
"individual",
"plugin",
"s",
"configuration",
"is",
"sane"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L456-L472 | train |
containernetworking/cni | libcni/api.go | GetVersionInfo | func (c *CNIConfig) GetVersionInfo(ctx context.Context, pluginType string) (version.PluginInfo, error) {
c.ensureExec()
pluginPath, err := c.exec.FindInPath(pluginType, c.Path)
if err != nil {
return nil, err
}
return invoke.GetVersionInfo(ctx, pluginPath, c.exec)
} | go | func (c *CNIConfig) GetVersionInfo(ctx context.Context, pluginType string) (version.PluginInfo, error) {
c.ensureExec()
pluginPath, err := c.exec.FindInPath(pluginType, c.Path)
if err != nil {
return nil, err
}
return invoke.GetVersionInfo(ctx, pluginPath, c.exec)
} | [
"func",
"(",
"c",
"*",
"CNIConfig",
")",
"GetVersionInfo",
"(",
"ctx",
"context",
".",
"Context",
",",
"pluginType",
"string",
")",
"(",
"version",
".",
"PluginInfo",
",",
"error",
")",
"{",
"c",
".",
"ensureExec",
"(",
")",
"\n",
"pluginPath",
",",
"err",
":=",
"c",
".",
"exec",
".",
"FindInPath",
"(",
"pluginType",
",",
"c",
".",
"Path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"invoke",
".",
"GetVersionInfo",
"(",
"ctx",
",",
"pluginPath",
",",
"c",
".",
"exec",
")",
"\n",
"}"
] | // GetVersionInfo reports which versions of the CNI spec are supported by
// the given plugin. | [
"GetVersionInfo",
"reports",
"which",
"versions",
"of",
"the",
"CNI",
"spec",
"are",
"supported",
"by",
"the",
"given",
"plugin",
"."
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/api.go#L476-L484 | train |
containernetworking/cni | pkg/version/legacy_examples/examples.go | Build | func (e Example) Build() (string, error) {
if err := ensureBuildDirExists(); err != nil {
return "", err
}
outBinPath := filepath.Join(buildDir, e.Name)
if runtime.GOOS == "windows" {
outBinPath += ".exe"
}
if err := testhelpers.BuildAt([]byte(e.PluginSource), e.CNIRepoGitRef, outBinPath); err != nil {
return "", err
}
return outBinPath, nil
} | go | func (e Example) Build() (string, error) {
if err := ensureBuildDirExists(); err != nil {
return "", err
}
outBinPath := filepath.Join(buildDir, e.Name)
if runtime.GOOS == "windows" {
outBinPath += ".exe"
}
if err := testhelpers.BuildAt([]byte(e.PluginSource), e.CNIRepoGitRef, outBinPath); err != nil {
return "", err
}
return outBinPath, nil
} | [
"func",
"(",
"e",
"Example",
")",
"Build",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"ensureBuildDirExists",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"outBinPath",
":=",
"filepath",
".",
"Join",
"(",
"buildDir",
",",
"e",
".",
"Name",
")",
"\n",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"outBinPath",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"testhelpers",
".",
"BuildAt",
"(",
"[",
"]",
"byte",
"(",
"e",
".",
"PluginSource",
")",
",",
"e",
".",
"CNIRepoGitRef",
",",
"outBinPath",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"outBinPath",
",",
"nil",
"\n",
"}"
] | // Build builds the example, returning the path to the binary | [
"Build",
"builds",
"the",
"example",
"returning",
"the",
"path",
"to",
"the",
"binary"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/version/legacy_examples/examples.go#L59-L73 | train |
containernetworking/cni | pkg/version/version.go | ParsePrevResult | func ParsePrevResult(conf *types.NetConf) error {
if conf.RawPrevResult == nil {
return nil
}
resultBytes, err := json.Marshal(conf.RawPrevResult)
if err != nil {
return fmt.Errorf("could not serialize prevResult: %v", err)
}
conf.RawPrevResult = nil
conf.PrevResult, err = NewResult(conf.CNIVersion, resultBytes)
if err != nil {
return fmt.Errorf("could not parse prevResult: %v", err)
}
return nil
} | go | func ParsePrevResult(conf *types.NetConf) error {
if conf.RawPrevResult == nil {
return nil
}
resultBytes, err := json.Marshal(conf.RawPrevResult)
if err != nil {
return fmt.Errorf("could not serialize prevResult: %v", err)
}
conf.RawPrevResult = nil
conf.PrevResult, err = NewResult(conf.CNIVersion, resultBytes)
if err != nil {
return fmt.Errorf("could not parse prevResult: %v", err)
}
return nil
} | [
"func",
"ParsePrevResult",
"(",
"conf",
"*",
"types",
".",
"NetConf",
")",
"error",
"{",
"if",
"conf",
".",
"RawPrevResult",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"resultBytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"conf",
".",
"RawPrevResult",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"conf",
".",
"RawPrevResult",
"=",
"nil",
"\n",
"conf",
".",
"PrevResult",
",",
"err",
"=",
"NewResult",
"(",
"conf",
".",
"CNIVersion",
",",
"resultBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ParsePrevResult parses a prevResult in a NetConf structure and sets
// the NetConf's PrevResult member to the parsed Result object. | [
"ParsePrevResult",
"parses",
"a",
"prevResult",
"in",
"a",
"NetConf",
"structure",
"and",
"sets",
"the",
"NetConf",
"s",
"PrevResult",
"member",
"to",
"the",
"parsed",
"Result",
"object",
"."
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/version/version.go#L66-L83 | train |
containernetworking/cni | libcni/conf.go | ConfListFromConf | func ConfListFromConf(original *NetworkConfig) (*NetworkConfigList, error) {
// Re-deserialize the config's json, then make a raw map configlist.
// This may seem a bit strange, but it's to make the Bytes fields
// actually make sense. Otherwise, the generated json is littered with
// golang default values.
rawConfig := make(map[string]interface{})
if err := json.Unmarshal(original.Bytes, &rawConfig); err != nil {
return nil, err
}
rawConfigList := map[string]interface{}{
"name": original.Network.Name,
"cniVersion": original.Network.CNIVersion,
"plugins": []interface{}{rawConfig},
}
b, err := json.Marshal(rawConfigList)
if err != nil {
return nil, err
}
return ConfListFromBytes(b)
} | go | func ConfListFromConf(original *NetworkConfig) (*NetworkConfigList, error) {
// Re-deserialize the config's json, then make a raw map configlist.
// This may seem a bit strange, but it's to make the Bytes fields
// actually make sense. Otherwise, the generated json is littered with
// golang default values.
rawConfig := make(map[string]interface{})
if err := json.Unmarshal(original.Bytes, &rawConfig); err != nil {
return nil, err
}
rawConfigList := map[string]interface{}{
"name": original.Network.Name,
"cniVersion": original.Network.CNIVersion,
"plugins": []interface{}{rawConfig},
}
b, err := json.Marshal(rawConfigList)
if err != nil {
return nil, err
}
return ConfListFromBytes(b)
} | [
"func",
"ConfListFromConf",
"(",
"original",
"*",
"NetworkConfig",
")",
"(",
"*",
"NetworkConfigList",
",",
"error",
")",
"{",
"// Re-deserialize the config's json, then make a raw map configlist.",
"// This may seem a bit strange, but it's to make the Bytes fields",
"// actually make sense. Otherwise, the generated json is littered with",
"// golang default values.",
"rawConfig",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"original",
".",
"Bytes",
",",
"&",
"rawConfig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"rawConfigList",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"original",
".",
"Network",
".",
"Name",
",",
"\"",
"\"",
":",
"original",
".",
"Network",
".",
"CNIVersion",
",",
"\"",
"\"",
":",
"[",
"]",
"interface",
"{",
"}",
"{",
"rawConfig",
"}",
",",
"}",
"\n\n",
"b",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"rawConfigList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"ConfListFromBytes",
"(",
"b",
")",
"\n",
"}"
] | // ConfListFromConf "upconverts" a network config in to a NetworkConfigList,
// with the single network as the only entry in the list. | [
"ConfListFromConf",
"upconverts",
"a",
"network",
"config",
"in",
"to",
"a",
"NetworkConfigList",
"with",
"the",
"single",
"network",
"as",
"the",
"only",
"entry",
"in",
"the",
"list",
"."
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/libcni/conf.go#L246-L268 | train |
containernetworking/cni | pkg/version/plugin.go | PluginSupports | func PluginSupports(supportedVersions ...string) PluginInfo {
if len(supportedVersions) < 1 {
panic("programmer error: you must support at least one version")
}
return &pluginInfo{
CNIVersion_: Current(),
SupportedVersions_: supportedVersions,
}
} | go | func PluginSupports(supportedVersions ...string) PluginInfo {
if len(supportedVersions) < 1 {
panic("programmer error: you must support at least one version")
}
return &pluginInfo{
CNIVersion_: Current(),
SupportedVersions_: supportedVersions,
}
} | [
"func",
"PluginSupports",
"(",
"supportedVersions",
"...",
"string",
")",
"PluginInfo",
"{",
"if",
"len",
"(",
"supportedVersions",
")",
"<",
"1",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"pluginInfo",
"{",
"CNIVersion_",
":",
"Current",
"(",
")",
",",
"SupportedVersions_",
":",
"supportedVersions",
",",
"}",
"\n",
"}"
] | // PluginSupports returns a new PluginInfo that will report the given versions
// as supported | [
"PluginSupports",
"returns",
"a",
"new",
"PluginInfo",
"that",
"will",
"report",
"the",
"given",
"versions",
"as",
"supported"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/version/plugin.go#L54-L62 | train |
containernetworking/cni | pkg/version/plugin.go | ParseVersion | func ParseVersion(version string) (int, int, int, error) {
var major, minor, micro int
if version == "" {
return -1, -1, -1, fmt.Errorf("invalid version %q: the version is empty", version)
}
parts := strings.Split(version, ".")
if len(parts) >= 4 {
return -1, -1, -1, fmt.Errorf("invalid version %q: too many parts", version)
}
major, err := strconv.Atoi(parts[0])
if err != nil {
return -1, -1, -1, fmt.Errorf("failed to convert major version part %q: %v", parts[0], err)
}
if len(parts) >= 2 {
minor, err = strconv.Atoi(parts[1])
if err != nil {
return -1, -1, -1, fmt.Errorf("failed to convert minor version part %q: %v", parts[1], err)
}
}
if len(parts) >= 3 {
micro, err = strconv.Atoi(parts[2])
if err != nil {
return -1, -1, -1, fmt.Errorf("failed to convert micro version part %q: %v", parts[2], err)
}
}
return major, minor, micro, nil
} | go | func ParseVersion(version string) (int, int, int, error) {
var major, minor, micro int
if version == "" {
return -1, -1, -1, fmt.Errorf("invalid version %q: the version is empty", version)
}
parts := strings.Split(version, ".")
if len(parts) >= 4 {
return -1, -1, -1, fmt.Errorf("invalid version %q: too many parts", version)
}
major, err := strconv.Atoi(parts[0])
if err != nil {
return -1, -1, -1, fmt.Errorf("failed to convert major version part %q: %v", parts[0], err)
}
if len(parts) >= 2 {
minor, err = strconv.Atoi(parts[1])
if err != nil {
return -1, -1, -1, fmt.Errorf("failed to convert minor version part %q: %v", parts[1], err)
}
}
if len(parts) >= 3 {
micro, err = strconv.Atoi(parts[2])
if err != nil {
return -1, -1, -1, fmt.Errorf("failed to convert micro version part %q: %v", parts[2], err)
}
}
return major, minor, micro, nil
} | [
"func",
"ParseVersion",
"(",
"version",
"string",
")",
"(",
"int",
",",
"int",
",",
"int",
",",
"error",
")",
"{",
"var",
"major",
",",
"minor",
",",
"micro",
"int",
"\n",
"if",
"version",
"==",
"\"",
"\"",
"{",
"return",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"}",
"\n\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"version",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
">=",
"4",
"{",
"return",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"}",
"\n\n",
"major",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"parts",
"[",
"0",
"]",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"parts",
")",
">=",
"2",
"{",
"minor",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"parts",
"[",
"1",
"]",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"parts",
")",
">=",
"3",
"{",
"micro",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"parts",
"[",
"2",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"parts",
"[",
"2",
"]",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"major",
",",
"minor",
",",
"micro",
",",
"nil",
"\n",
"}"
] | // ParseVersion parses a version string like "3.0.1" or "0.4.5" into major,
// minor, and micro numbers or returns an error | [
"ParseVersion",
"parses",
"a",
"version",
"string",
"like",
"3",
".",
"0",
".",
"1",
"or",
"0",
".",
"4",
".",
"5",
"into",
"major",
"minor",
"and",
"micro",
"numbers",
"or",
"returns",
"an",
"error"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/version/plugin.go#L87-L118 | train |
containernetworking/cni | pkg/types/args.go | UnmarshalText | func (s *UnmarshallableString) UnmarshalText(data []byte) error {
*s = UnmarshallableString(data)
return nil
} | go | func (s *UnmarshallableString) UnmarshalText(data []byte) error {
*s = UnmarshallableString(data)
return nil
} | [
"func",
"(",
"s",
"*",
"UnmarshallableString",
")",
"UnmarshalText",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"*",
"s",
"=",
"UnmarshallableString",
"(",
"data",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalText implements the encoding.TextUnmarshaler interface.
// Returns the string | [
"UnmarshalText",
"implements",
"the",
"encoding",
".",
"TextUnmarshaler",
"interface",
".",
"Returns",
"the",
"string"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/types/args.go#L49-L52 | train |
containernetworking/cni | pkg/types/args.go | GetKeyField | func GetKeyField(keyString string, v reflect.Value) reflect.Value {
return v.Elem().FieldByName(keyString)
} | go | func GetKeyField(keyString string, v reflect.Value) reflect.Value {
return v.Elem().FieldByName(keyString)
} | [
"func",
"GetKeyField",
"(",
"keyString",
"string",
",",
"v",
"reflect",
".",
"Value",
")",
"reflect",
".",
"Value",
"{",
"return",
"v",
".",
"Elem",
"(",
")",
".",
"FieldByName",
"(",
"keyString",
")",
"\n",
"}"
] | // GetKeyField is a helper function to receive Values
// Values that represent a pointer to a struct | [
"GetKeyField",
"is",
"a",
"helper",
"function",
"to",
"receive",
"Values",
"Values",
"that",
"represent",
"a",
"pointer",
"to",
"a",
"struct"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/types/args.go#L62-L64 | train |
containernetworking/cni | pkg/types/args.go | LoadArgs | func LoadArgs(args string, container interface{}) error {
if args == "" {
return nil
}
containerValue := reflect.ValueOf(container)
pairs := strings.Split(args, ";")
unknownArgs := []string{}
for _, pair := range pairs {
kv := strings.Split(pair, "=")
if len(kv) != 2 {
return fmt.Errorf("ARGS: invalid pair %q", pair)
}
keyString := kv[0]
valueString := kv[1]
keyField := GetKeyField(keyString, containerValue)
if !keyField.IsValid() {
unknownArgs = append(unknownArgs, pair)
continue
}
keyFieldIface := keyField.Addr().Interface()
u, ok := keyFieldIface.(encoding.TextUnmarshaler)
if !ok {
return UnmarshalableArgsError{fmt.Errorf(
"ARGS: cannot unmarshal into field '%s' - type '%s' does not implement encoding.TextUnmarshaler",
keyString, reflect.TypeOf(keyFieldIface))}
}
err := u.UnmarshalText([]byte(valueString))
if err != nil {
return fmt.Errorf("ARGS: error parsing value of pair %q: %v)", pair, err)
}
}
isIgnoreUnknown := GetKeyField("IgnoreUnknown", containerValue).Bool()
if len(unknownArgs) > 0 && !isIgnoreUnknown {
return fmt.Errorf("ARGS: unknown args %q", unknownArgs)
}
return nil
} | go | func LoadArgs(args string, container interface{}) error {
if args == "" {
return nil
}
containerValue := reflect.ValueOf(container)
pairs := strings.Split(args, ";")
unknownArgs := []string{}
for _, pair := range pairs {
kv := strings.Split(pair, "=")
if len(kv) != 2 {
return fmt.Errorf("ARGS: invalid pair %q", pair)
}
keyString := kv[0]
valueString := kv[1]
keyField := GetKeyField(keyString, containerValue)
if !keyField.IsValid() {
unknownArgs = append(unknownArgs, pair)
continue
}
keyFieldIface := keyField.Addr().Interface()
u, ok := keyFieldIface.(encoding.TextUnmarshaler)
if !ok {
return UnmarshalableArgsError{fmt.Errorf(
"ARGS: cannot unmarshal into field '%s' - type '%s' does not implement encoding.TextUnmarshaler",
keyString, reflect.TypeOf(keyFieldIface))}
}
err := u.UnmarshalText([]byte(valueString))
if err != nil {
return fmt.Errorf("ARGS: error parsing value of pair %q: %v)", pair, err)
}
}
isIgnoreUnknown := GetKeyField("IgnoreUnknown", containerValue).Bool()
if len(unknownArgs) > 0 && !isIgnoreUnknown {
return fmt.Errorf("ARGS: unknown args %q", unknownArgs)
}
return nil
} | [
"func",
"LoadArgs",
"(",
"args",
"string",
",",
"container",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"args",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"containerValue",
":=",
"reflect",
".",
"ValueOf",
"(",
"container",
")",
"\n\n",
"pairs",
":=",
"strings",
".",
"Split",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"unknownArgs",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"pair",
":=",
"range",
"pairs",
"{",
"kv",
":=",
"strings",
".",
"Split",
"(",
"pair",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"kv",
")",
"!=",
"2",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"pair",
")",
"\n",
"}",
"\n",
"keyString",
":=",
"kv",
"[",
"0",
"]",
"\n",
"valueString",
":=",
"kv",
"[",
"1",
"]",
"\n",
"keyField",
":=",
"GetKeyField",
"(",
"keyString",
",",
"containerValue",
")",
"\n",
"if",
"!",
"keyField",
".",
"IsValid",
"(",
")",
"{",
"unknownArgs",
"=",
"append",
"(",
"unknownArgs",
",",
"pair",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"keyFieldIface",
":=",
"keyField",
".",
"Addr",
"(",
")",
".",
"Interface",
"(",
")",
"\n",
"u",
",",
"ok",
":=",
"keyFieldIface",
".",
"(",
"encoding",
".",
"TextUnmarshaler",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"UnmarshalableArgsError",
"{",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyString",
",",
"reflect",
".",
"TypeOf",
"(",
"keyFieldIface",
")",
")",
"}",
"\n",
"}",
"\n",
"err",
":=",
"u",
".",
"UnmarshalText",
"(",
"[",
"]",
"byte",
"(",
"valueString",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"pair",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"isIgnoreUnknown",
":=",
"GetKeyField",
"(",
"\"",
"\"",
",",
"containerValue",
")",
".",
"Bool",
"(",
")",
"\n",
"if",
"len",
"(",
"unknownArgs",
")",
">",
"0",
"&&",
"!",
"isIgnoreUnknown",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"unknownArgs",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // LoadArgs parses args from a string in the form "K=V;K2=V2;..." | [
"LoadArgs",
"parses",
"args",
"from",
"a",
"string",
"in",
"the",
"form",
"K",
"=",
"V",
";",
"K2",
"=",
"V2",
";",
"..."
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/types/args.go#L73-L112 | train |
containernetworking/cni | pkg/types/current/types.go | convertTo020 | func (r *Result) convertTo020() (*types020.Result, error) {
oldResult := &types020.Result{
CNIVersion: types020.ImplementedSpecVersion,
DNS: r.DNS,
}
for _, ip := range r.IPs {
// Only convert the first IP address of each version as 0.2.0
// and earlier cannot handle multiple IP addresses
if ip.Version == "4" && oldResult.IP4 == nil {
oldResult.IP4 = &types020.IPConfig{
IP: ip.Address,
Gateway: ip.Gateway,
}
} else if ip.Version == "6" && oldResult.IP6 == nil {
oldResult.IP6 = &types020.IPConfig{
IP: ip.Address,
Gateway: ip.Gateway,
}
}
if oldResult.IP4 != nil && oldResult.IP6 != nil {
break
}
}
for _, route := range r.Routes {
is4 := route.Dst.IP.To4() != nil
if is4 && oldResult.IP4 != nil {
oldResult.IP4.Routes = append(oldResult.IP4.Routes, types.Route{
Dst: route.Dst,
GW: route.GW,
})
} else if !is4 && oldResult.IP6 != nil {
oldResult.IP6.Routes = append(oldResult.IP6.Routes, types.Route{
Dst: route.Dst,
GW: route.GW,
})
}
}
if oldResult.IP4 == nil && oldResult.IP6 == nil {
return nil, fmt.Errorf("cannot convert: no valid IP addresses")
}
return oldResult, nil
} | go | func (r *Result) convertTo020() (*types020.Result, error) {
oldResult := &types020.Result{
CNIVersion: types020.ImplementedSpecVersion,
DNS: r.DNS,
}
for _, ip := range r.IPs {
// Only convert the first IP address of each version as 0.2.0
// and earlier cannot handle multiple IP addresses
if ip.Version == "4" && oldResult.IP4 == nil {
oldResult.IP4 = &types020.IPConfig{
IP: ip.Address,
Gateway: ip.Gateway,
}
} else if ip.Version == "6" && oldResult.IP6 == nil {
oldResult.IP6 = &types020.IPConfig{
IP: ip.Address,
Gateway: ip.Gateway,
}
}
if oldResult.IP4 != nil && oldResult.IP6 != nil {
break
}
}
for _, route := range r.Routes {
is4 := route.Dst.IP.To4() != nil
if is4 && oldResult.IP4 != nil {
oldResult.IP4.Routes = append(oldResult.IP4.Routes, types.Route{
Dst: route.Dst,
GW: route.GW,
})
} else if !is4 && oldResult.IP6 != nil {
oldResult.IP6.Routes = append(oldResult.IP6.Routes, types.Route{
Dst: route.Dst,
GW: route.GW,
})
}
}
if oldResult.IP4 == nil && oldResult.IP6 == nil {
return nil, fmt.Errorf("cannot convert: no valid IP addresses")
}
return oldResult, nil
} | [
"func",
"(",
"r",
"*",
"Result",
")",
"convertTo020",
"(",
")",
"(",
"*",
"types020",
".",
"Result",
",",
"error",
")",
"{",
"oldResult",
":=",
"&",
"types020",
".",
"Result",
"{",
"CNIVersion",
":",
"types020",
".",
"ImplementedSpecVersion",
",",
"DNS",
":",
"r",
".",
"DNS",
",",
"}",
"\n\n",
"for",
"_",
",",
"ip",
":=",
"range",
"r",
".",
"IPs",
"{",
"// Only convert the first IP address of each version as 0.2.0",
"// and earlier cannot handle multiple IP addresses",
"if",
"ip",
".",
"Version",
"==",
"\"",
"\"",
"&&",
"oldResult",
".",
"IP4",
"==",
"nil",
"{",
"oldResult",
".",
"IP4",
"=",
"&",
"types020",
".",
"IPConfig",
"{",
"IP",
":",
"ip",
".",
"Address",
",",
"Gateway",
":",
"ip",
".",
"Gateway",
",",
"}",
"\n",
"}",
"else",
"if",
"ip",
".",
"Version",
"==",
"\"",
"\"",
"&&",
"oldResult",
".",
"IP6",
"==",
"nil",
"{",
"oldResult",
".",
"IP6",
"=",
"&",
"types020",
".",
"IPConfig",
"{",
"IP",
":",
"ip",
".",
"Address",
",",
"Gateway",
":",
"ip",
".",
"Gateway",
",",
"}",
"\n",
"}",
"\n\n",
"if",
"oldResult",
".",
"IP4",
"!=",
"nil",
"&&",
"oldResult",
".",
"IP6",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"route",
":=",
"range",
"r",
".",
"Routes",
"{",
"is4",
":=",
"route",
".",
"Dst",
".",
"IP",
".",
"To4",
"(",
")",
"!=",
"nil",
"\n",
"if",
"is4",
"&&",
"oldResult",
".",
"IP4",
"!=",
"nil",
"{",
"oldResult",
".",
"IP4",
".",
"Routes",
"=",
"append",
"(",
"oldResult",
".",
"IP4",
".",
"Routes",
",",
"types",
".",
"Route",
"{",
"Dst",
":",
"route",
".",
"Dst",
",",
"GW",
":",
"route",
".",
"GW",
",",
"}",
")",
"\n",
"}",
"else",
"if",
"!",
"is4",
"&&",
"oldResult",
".",
"IP6",
"!=",
"nil",
"{",
"oldResult",
".",
"IP6",
".",
"Routes",
"=",
"append",
"(",
"oldResult",
".",
"IP6",
".",
"Routes",
",",
"types",
".",
"Route",
"{",
"Dst",
":",
"route",
".",
"Dst",
",",
"GW",
":",
"route",
".",
"GW",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"oldResult",
".",
"IP4",
"==",
"nil",
"&&",
"oldResult",
".",
"IP6",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"oldResult",
",",
"nil",
"\n",
"}"
] | // Convert to the older 0.2.0 CNI spec Result type | [
"Convert",
"to",
"the",
"older",
"0",
".",
"2",
".",
"0",
"CNI",
"spec",
"Result",
"type"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/types/current/types.go#L134-L180 | train |
containernetworking/cni | pkg/invoke/find.go | FindInPath | func FindInPath(plugin string, paths []string) (string, error) {
if plugin == "" {
return "", fmt.Errorf("no plugin name provided")
}
if len(paths) == 0 {
return "", fmt.Errorf("no paths provided")
}
for _, path := range paths {
for _, fe := range ExecutableFileExtensions {
fullpath := filepath.Join(path, plugin) + fe
if fi, err := os.Stat(fullpath); err == nil && fi.Mode().IsRegular() {
return fullpath, nil
}
}
}
return "", fmt.Errorf("failed to find plugin %q in path %s", plugin, paths)
} | go | func FindInPath(plugin string, paths []string) (string, error) {
if plugin == "" {
return "", fmt.Errorf("no plugin name provided")
}
if len(paths) == 0 {
return "", fmt.Errorf("no paths provided")
}
for _, path := range paths {
for _, fe := range ExecutableFileExtensions {
fullpath := filepath.Join(path, plugin) + fe
if fi, err := os.Stat(fullpath); err == nil && fi.Mode().IsRegular() {
return fullpath, nil
}
}
}
return "", fmt.Errorf("failed to find plugin %q in path %s", plugin, paths)
} | [
"func",
"FindInPath",
"(",
"plugin",
"string",
",",
"paths",
"[",
"]",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"plugin",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"paths",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"path",
":=",
"range",
"paths",
"{",
"for",
"_",
",",
"fe",
":=",
"range",
"ExecutableFileExtensions",
"{",
"fullpath",
":=",
"filepath",
".",
"Join",
"(",
"path",
",",
"plugin",
")",
"+",
"fe",
"\n",
"if",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"fullpath",
")",
";",
"err",
"==",
"nil",
"&&",
"fi",
".",
"Mode",
"(",
")",
".",
"IsRegular",
"(",
")",
"{",
"return",
"fullpath",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"plugin",
",",
"paths",
")",
"\n",
"}"
] | // FindInPath returns the full path of the plugin by searching in the provided path | [
"FindInPath",
"returns",
"the",
"full",
"path",
"of",
"the",
"plugin",
"by",
"searching",
"in",
"the",
"provided",
"path"
] | f726df9103d27044c93c99e30f6fb04048606444 | https://github.com/containernetworking/cni/blob/f726df9103d27044c93c99e30f6fb04048606444/pkg/invoke/find.go#L24-L43 | train |
go-xorm/xorm | cache_lru.go | NewLRUCacher | func NewLRUCacher(store core.CacheStore, maxElementSize int) *LRUCacher {
return NewLRUCacher2(store, 3600*time.Second, maxElementSize)
} | go | func NewLRUCacher(store core.CacheStore, maxElementSize int) *LRUCacher {
return NewLRUCacher2(store, 3600*time.Second, maxElementSize)
} | [
"func",
"NewLRUCacher",
"(",
"store",
"core",
".",
"CacheStore",
",",
"maxElementSize",
"int",
")",
"*",
"LRUCacher",
"{",
"return",
"NewLRUCacher2",
"(",
"store",
",",
"3600",
"*",
"time",
".",
"Second",
",",
"maxElementSize",
")",
"\n",
"}"
] | // NewLRUCacher creates a cacher | [
"NewLRUCacher",
"creates",
"a",
"cacher"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_lru.go#L30-L32 | train |
go-xorm/xorm | cache_lru.go | NewLRUCacher2 | func NewLRUCacher2(store core.CacheStore, expired time.Duration, maxElementSize int) *LRUCacher {
cacher := &LRUCacher{store: store, idList: list.New(),
sqlList: list.New(), Expired: expired,
GcInterval: core.CacheGcInterval, MaxElementSize: maxElementSize,
sqlIndex: make(map[string]map[string]*list.Element),
idIndex: make(map[string]map[string]*list.Element),
}
cacher.RunGC()
return cacher
} | go | func NewLRUCacher2(store core.CacheStore, expired time.Duration, maxElementSize int) *LRUCacher {
cacher := &LRUCacher{store: store, idList: list.New(),
sqlList: list.New(), Expired: expired,
GcInterval: core.CacheGcInterval, MaxElementSize: maxElementSize,
sqlIndex: make(map[string]map[string]*list.Element),
idIndex: make(map[string]map[string]*list.Element),
}
cacher.RunGC()
return cacher
} | [
"func",
"NewLRUCacher2",
"(",
"store",
"core",
".",
"CacheStore",
",",
"expired",
"time",
".",
"Duration",
",",
"maxElementSize",
"int",
")",
"*",
"LRUCacher",
"{",
"cacher",
":=",
"&",
"LRUCacher",
"{",
"store",
":",
"store",
",",
"idList",
":",
"list",
".",
"New",
"(",
")",
",",
"sqlList",
":",
"list",
".",
"New",
"(",
")",
",",
"Expired",
":",
"expired",
",",
"GcInterval",
":",
"core",
".",
"CacheGcInterval",
",",
"MaxElementSize",
":",
"maxElementSize",
",",
"sqlIndex",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"*",
"list",
".",
"Element",
")",
",",
"idIndex",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"*",
"list",
".",
"Element",
")",
",",
"}",
"\n",
"cacher",
".",
"RunGC",
"(",
")",
"\n",
"return",
"cacher",
"\n",
"}"
] | // NewLRUCacher2 creates a cache include different params | [
"NewLRUCacher2",
"creates",
"a",
"cache",
"include",
"different",
"params"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_lru.go#L35-L44 | train |
go-xorm/xorm | cache_lru.go | RunGC | func (m *LRUCacher) RunGC() {
time.AfterFunc(m.GcInterval, func() {
m.RunGC()
m.GC()
})
} | go | func (m *LRUCacher) RunGC() {
time.AfterFunc(m.GcInterval, func() {
m.RunGC()
m.GC()
})
} | [
"func",
"(",
"m",
"*",
"LRUCacher",
")",
"RunGC",
"(",
")",
"{",
"time",
".",
"AfterFunc",
"(",
"m",
".",
"GcInterval",
",",
"func",
"(",
")",
"{",
"m",
".",
"RunGC",
"(",
")",
"\n",
"m",
".",
"GC",
"(",
")",
"\n",
"}",
")",
"\n",
"}"
] | // RunGC run once every m.GcInterval | [
"RunGC",
"run",
"once",
"every",
"m",
".",
"GcInterval"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_lru.go#L47-L52 | train |
go-xorm/xorm | cache_lru.go | GetIds | func (m *LRUCacher) GetIds(tableName, sql string) interface{} {
m.mutex.Lock()
defer m.mutex.Unlock()
if _, ok := m.sqlIndex[tableName]; !ok {
m.sqlIndex[tableName] = make(map[string]*list.Element)
}
if v, err := m.store.Get(sql); err == nil {
if el, ok := m.sqlIndex[tableName][sql]; !ok {
el = m.sqlList.PushBack(newSQLNode(tableName, sql))
m.sqlIndex[tableName][sql] = el
} else {
lastTime := el.Value.(*sqlNode).lastVisit
// if expired, remove the node and return nil
if time.Now().Sub(lastTime) > m.Expired {
m.delIds(tableName, sql)
return nil
}
m.sqlList.MoveToBack(el)
el.Value.(*sqlNode).lastVisit = time.Now()
}
return v
}
m.delIds(tableName, sql)
return nil
} | go | func (m *LRUCacher) GetIds(tableName, sql string) interface{} {
m.mutex.Lock()
defer m.mutex.Unlock()
if _, ok := m.sqlIndex[tableName]; !ok {
m.sqlIndex[tableName] = make(map[string]*list.Element)
}
if v, err := m.store.Get(sql); err == nil {
if el, ok := m.sqlIndex[tableName][sql]; !ok {
el = m.sqlList.PushBack(newSQLNode(tableName, sql))
m.sqlIndex[tableName][sql] = el
} else {
lastTime := el.Value.(*sqlNode).lastVisit
// if expired, remove the node and return nil
if time.Now().Sub(lastTime) > m.Expired {
m.delIds(tableName, sql)
return nil
}
m.sqlList.MoveToBack(el)
el.Value.(*sqlNode).lastVisit = time.Now()
}
return v
}
m.delIds(tableName, sql)
return nil
} | [
"func",
"(",
"m",
"*",
"LRUCacher",
")",
"GetIds",
"(",
"tableName",
",",
"sql",
"string",
")",
"interface",
"{",
"}",
"{",
"m",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"m",
".",
"sqlIndex",
"[",
"tableName",
"]",
";",
"!",
"ok",
"{",
"m",
".",
"sqlIndex",
"[",
"tableName",
"]",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"list",
".",
"Element",
")",
"\n",
"}",
"\n",
"if",
"v",
",",
"err",
":=",
"m",
".",
"store",
".",
"Get",
"(",
"sql",
")",
";",
"err",
"==",
"nil",
"{",
"if",
"el",
",",
"ok",
":=",
"m",
".",
"sqlIndex",
"[",
"tableName",
"]",
"[",
"sql",
"]",
";",
"!",
"ok",
"{",
"el",
"=",
"m",
".",
"sqlList",
".",
"PushBack",
"(",
"newSQLNode",
"(",
"tableName",
",",
"sql",
")",
")",
"\n",
"m",
".",
"sqlIndex",
"[",
"tableName",
"]",
"[",
"sql",
"]",
"=",
"el",
"\n",
"}",
"else",
"{",
"lastTime",
":=",
"el",
".",
"Value",
".",
"(",
"*",
"sqlNode",
")",
".",
"lastVisit",
"\n",
"// if expired, remove the node and return nil",
"if",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"lastTime",
")",
">",
"m",
".",
"Expired",
"{",
"m",
".",
"delIds",
"(",
"tableName",
",",
"sql",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"m",
".",
"sqlList",
".",
"MoveToBack",
"(",
"el",
")",
"\n",
"el",
".",
"Value",
".",
"(",
"*",
"sqlNode",
")",
".",
"lastVisit",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}",
"\n\n",
"m",
".",
"delIds",
"(",
"tableName",
",",
"sql",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // GetIds returns all bean's ids according to sql and parameter from cache | [
"GetIds",
"returns",
"all",
"bean",
"s",
"ids",
"according",
"to",
"sql",
"and",
"parameter",
"from",
"cache"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_lru.go#L88-L113 | train |
go-xorm/xorm | cache_lru.go | clearIds | func (m *LRUCacher) clearIds(tableName string) {
if tis, ok := m.sqlIndex[tableName]; ok {
for sql, v := range tis {
m.sqlList.Remove(v)
m.store.Del(sql)
}
}
m.sqlIndex[tableName] = make(map[string]*list.Element)
} | go | func (m *LRUCacher) clearIds(tableName string) {
if tis, ok := m.sqlIndex[tableName]; ok {
for sql, v := range tis {
m.sqlList.Remove(v)
m.store.Del(sql)
}
}
m.sqlIndex[tableName] = make(map[string]*list.Element)
} | [
"func",
"(",
"m",
"*",
"LRUCacher",
")",
"clearIds",
"(",
"tableName",
"string",
")",
"{",
"if",
"tis",
",",
"ok",
":=",
"m",
".",
"sqlIndex",
"[",
"tableName",
"]",
";",
"ok",
"{",
"for",
"sql",
",",
"v",
":=",
"range",
"tis",
"{",
"m",
".",
"sqlList",
".",
"Remove",
"(",
"v",
")",
"\n",
"m",
".",
"store",
".",
"Del",
"(",
"sql",
")",
"\n",
"}",
"\n",
"}",
"\n",
"m",
".",
"sqlIndex",
"[",
"tableName",
"]",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"list",
".",
"Element",
")",
"\n",
"}"
] | // clearIds clears all sql-ids mapping on table tableName from cache | [
"clearIds",
"clears",
"all",
"sql",
"-",
"ids",
"mapping",
"on",
"table",
"tableName",
"from",
"cache"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_lru.go#L146-L154 | train |
go-xorm/xorm | cache_lru.go | DelIds | func (m *LRUCacher) DelIds(tableName, sql string) {
m.mutex.Lock()
m.delIds(tableName, sql)
m.mutex.Unlock()
} | go | func (m *LRUCacher) DelIds(tableName, sql string) {
m.mutex.Lock()
m.delIds(tableName, sql)
m.mutex.Unlock()
} | [
"func",
"(",
"m",
"*",
"LRUCacher",
")",
"DelIds",
"(",
"tableName",
",",
"sql",
"string",
")",
"{",
"m",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"m",
".",
"delIds",
"(",
"tableName",
",",
"sql",
")",
"\n",
"m",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // DelIds deletes ids | [
"DelIds",
"deletes",
"ids"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_lru.go#L235-L239 | train |
go-xorm/xorm | session_context.go | Context | func (session *Session) Context(ctx context.Context) *Session {
session.ctx = ctx
return session
} | go | func (session *Session) Context(ctx context.Context) *Session {
session.ctx = ctx
return session
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"Context",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"Session",
"{",
"session",
".",
"ctx",
"=",
"ctx",
"\n",
"return",
"session",
"\n",
"}"
] | // Context sets the context on this session | [
"Context",
"sets",
"the",
"context",
"on",
"this",
"session"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_context.go#L10-L13 | train |
go-xorm/xorm | session_context.go | PingContext | func (session *Session) PingContext(ctx context.Context) error {
if session.isAutoClose {
defer session.Close()
}
session.engine.logger.Infof("PING DATABASE %v", session.engine.DriverName())
return session.DB().PingContext(ctx)
} | go | func (session *Session) PingContext(ctx context.Context) error {
if session.isAutoClose {
defer session.Close()
}
session.engine.logger.Infof("PING DATABASE %v", session.engine.DriverName())
return session.DB().PingContext(ctx)
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"PingContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"session",
".",
"isAutoClose",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"session",
".",
"engine",
".",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"session",
".",
"engine",
".",
"DriverName",
"(",
")",
")",
"\n",
"return",
"session",
".",
"DB",
"(",
")",
".",
"PingContext",
"(",
"ctx",
")",
"\n",
"}"
] | // PingContext test if database is ok | [
"PingContext",
"test",
"if",
"database",
"is",
"ok"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_context.go#L16-L23 | train |
go-xorm/xorm | session_iterate.go | BufferSize | func (session *Session) BufferSize(size int) *Session {
session.statement.bufferSize = size
return session
} | go | func (session *Session) BufferSize(size int) *Session {
session.statement.bufferSize = size
return session
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"BufferSize",
"(",
"size",
"int",
")",
"*",
"Session",
"{",
"session",
".",
"statement",
".",
"bufferSize",
"=",
"size",
"\n",
"return",
"session",
"\n",
"}"
] | // BufferSize sets the buffersize for iterate | [
"BufferSize",
"sets",
"the",
"buffersize",
"for",
"iterate"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_iterate.go#L57-L60 | train |
go-xorm/xorm | xorm.go | NewEngineWithParams | func NewEngineWithParams(driverName string, dataSourceName string, params map[string]string) (*Engine, error) {
engine, err := NewEngine(driverName, dataSourceName)
engine.dialect.SetParams(params)
return engine, err
} | go | func NewEngineWithParams(driverName string, dataSourceName string, params map[string]string) (*Engine, error) {
engine, err := NewEngine(driverName, dataSourceName)
engine.dialect.SetParams(params)
return engine, err
} | [
"func",
"NewEngineWithParams",
"(",
"driverName",
"string",
",",
"dataSourceName",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"*",
"Engine",
",",
"error",
")",
"{",
"engine",
",",
"err",
":=",
"NewEngine",
"(",
"driverName",
",",
"dataSourceName",
")",
"\n",
"engine",
".",
"dialect",
".",
"SetParams",
"(",
"params",
")",
"\n",
"return",
"engine",
",",
"err",
"\n",
"}"
] | // NewEngineWithParams new a db manager with params. The params will be passed to dialect. | [
"NewEngineWithParams",
"new",
"a",
"db",
"manager",
"with",
"params",
".",
"The",
"params",
"will",
"be",
"passed",
"to",
"dialect",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/xorm.go#L117-L121 | train |
go-xorm/xorm | xorm.go | Clone | func (engine *Engine) Clone() (*Engine, error) {
return NewEngine(engine.DriverName(), engine.DataSourceName())
} | go | func (engine *Engine) Clone() (*Engine, error) {
return NewEngine(engine.DriverName(), engine.DataSourceName())
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Clone",
"(",
")",
"(",
"*",
"Engine",
",",
"error",
")",
"{",
"return",
"NewEngine",
"(",
"engine",
".",
"DriverName",
"(",
")",
",",
"engine",
".",
"DataSourceName",
"(",
")",
")",
"\n",
"}"
] | // Clone clone an engine | [
"Clone",
"clone",
"an",
"engine"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/xorm.go#L124-L126 | train |
go-xorm/xorm | session.go | ContextCache | func (session *Session) ContextCache(context ContextCache) *Session {
session.statement.context = context
return session
} | go | func (session *Session) ContextCache(context ContextCache) *Session {
session.statement.context = context
return session
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"ContextCache",
"(",
"context",
"ContextCache",
")",
"*",
"Session",
"{",
"session",
".",
"statement",
".",
"context",
"=",
"context",
"\n",
"return",
"session",
"\n",
"}"
] | // ContextCache enable context cache or not | [
"ContextCache",
"enable",
"context",
"cache",
"or",
"not"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session.go#L116-L119 | train |
go-xorm/xorm | session.go | Before | func (session *Session) Before(closures func(interface{})) *Session {
if closures != nil {
session.beforeClosures = append(session.beforeClosures, closures)
}
return session
} | go | func (session *Session) Before(closures func(interface{})) *Session {
if closures != nil {
session.beforeClosures = append(session.beforeClosures, closures)
}
return session
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"Before",
"(",
"closures",
"func",
"(",
"interface",
"{",
"}",
")",
")",
"*",
"Session",
"{",
"if",
"closures",
"!=",
"nil",
"{",
"session",
".",
"beforeClosures",
"=",
"append",
"(",
"session",
".",
"beforeClosures",
",",
"closures",
")",
"\n",
"}",
"\n",
"return",
"session",
"\n",
"}"
] | // Before Apply before Processor, affected bean is passed to closure arg | [
"Before",
"Apply",
"before",
"Processor",
"affected",
"bean",
"is",
"passed",
"to",
"closure",
"arg"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session.go#L139-L144 | train |
go-xorm/xorm | session.go | After | func (session *Session) After(closures func(interface{})) *Session {
if closures != nil {
session.afterClosures = append(session.afterClosures, closures)
}
return session
} | go | func (session *Session) After(closures func(interface{})) *Session {
if closures != nil {
session.afterClosures = append(session.afterClosures, closures)
}
return session
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"After",
"(",
"closures",
"func",
"(",
"interface",
"{",
"}",
")",
")",
"*",
"Session",
"{",
"if",
"closures",
"!=",
"nil",
"{",
"session",
".",
"afterClosures",
"=",
"append",
"(",
"session",
".",
"afterClosures",
",",
"closures",
")",
"\n",
"}",
"\n",
"return",
"session",
"\n",
"}"
] | // After Apply after Processor, affected bean is passed to closure arg | [
"After",
"Apply",
"after",
"Processor",
"affected",
"bean",
"is",
"passed",
"to",
"closure",
"arg"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session.go#L147-L152 | train |
go-xorm/xorm | session.go | DB | func (session *Session) DB() *core.DB {
if session.db == nil {
session.db = session.engine.db
session.stmtCache = make(map[uint32]*core.Stmt, 0)
}
return session.db
} | go | func (session *Session) DB() *core.DB {
if session.db == nil {
session.db = session.engine.db
session.stmtCache = make(map[uint32]*core.Stmt, 0)
}
return session.db
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"DB",
"(",
")",
"*",
"core",
".",
"DB",
"{",
"if",
"session",
".",
"db",
"==",
"nil",
"{",
"session",
".",
"db",
"=",
"session",
".",
"engine",
".",
"db",
"\n",
"session",
".",
"stmtCache",
"=",
"make",
"(",
"map",
"[",
"uint32",
"]",
"*",
"core",
".",
"Stmt",
",",
"0",
")",
"\n",
"}",
"\n",
"return",
"session",
".",
"db",
"\n",
"}"
] | // DB db return the wrapper of sql.DB | [
"DB",
"db",
"return",
"the",
"wrapper",
"of",
"sql",
".",
"DB"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session.go#L255-L261 | train |
go-xorm/xorm | tag.go | OnlyFromDBTagHandler | func OnlyFromDBTagHandler(ctx *tagContext) error {
ctx.col.MapType = core.ONLYFROMDB
return nil
} | go | func OnlyFromDBTagHandler(ctx *tagContext) error {
ctx.col.MapType = core.ONLYFROMDB
return nil
} | [
"func",
"OnlyFromDBTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"ctx",
".",
"col",
".",
"MapType",
"=",
"core",
".",
"ONLYFROMDB",
"\n",
"return",
"nil",
"\n",
"}"
] | // OnlyFromDBTagHandler describes mapping direction tag handler | [
"OnlyFromDBTagHandler",
"describes",
"mapping",
"direction",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L73-L76 | train |
go-xorm/xorm | tag.go | OnlyToDBTagHandler | func OnlyToDBTagHandler(ctx *tagContext) error {
ctx.col.MapType = core.ONLYTODB
return nil
} | go | func OnlyToDBTagHandler(ctx *tagContext) error {
ctx.col.MapType = core.ONLYTODB
return nil
} | [
"func",
"OnlyToDBTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"ctx",
".",
"col",
".",
"MapType",
"=",
"core",
".",
"ONLYTODB",
"\n",
"return",
"nil",
"\n",
"}"
] | // OnlyToDBTagHandler describes mapping direction tag handler | [
"OnlyToDBTagHandler",
"describes",
"mapping",
"direction",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L79-L82 | train |
go-xorm/xorm | tag.go | PKTagHandler | func PKTagHandler(ctx *tagContext) error {
ctx.col.IsPrimaryKey = true
ctx.col.Nullable = false
return nil
} | go | func PKTagHandler(ctx *tagContext) error {
ctx.col.IsPrimaryKey = true
ctx.col.Nullable = false
return nil
} | [
"func",
"PKTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"ctx",
".",
"col",
".",
"IsPrimaryKey",
"=",
"true",
"\n",
"ctx",
".",
"col",
".",
"Nullable",
"=",
"false",
"\n",
"return",
"nil",
"\n",
"}"
] | // PKTagHandler decribes primary key tag handler | [
"PKTagHandler",
"decribes",
"primary",
"key",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L85-L89 | train |
go-xorm/xorm | tag.go | NULLTagHandler | func NULLTagHandler(ctx *tagContext) error {
ctx.col.Nullable = (strings.ToUpper(ctx.preTag) != "NOT")
return nil
} | go | func NULLTagHandler(ctx *tagContext) error {
ctx.col.Nullable = (strings.ToUpper(ctx.preTag) != "NOT")
return nil
} | [
"func",
"NULLTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"ctx",
".",
"col",
".",
"Nullable",
"=",
"(",
"strings",
".",
"ToUpper",
"(",
"ctx",
".",
"preTag",
")",
"!=",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // NULLTagHandler describes null tag handler | [
"NULLTagHandler",
"describes",
"null",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L92-L95 | train |
go-xorm/xorm | tag.go | DefaultTagHandler | func DefaultTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.col.Default = ctx.params[0]
} else {
ctx.col.Default = ctx.nextTag
ctx.ignoreNext = true
}
return nil
} | go | func DefaultTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.col.Default = ctx.params[0]
} else {
ctx.col.Default = ctx.nextTag
ctx.ignoreNext = true
}
return nil
} | [
"func",
"DefaultTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
">",
"0",
"{",
"ctx",
".",
"col",
".",
"Default",
"=",
"ctx",
".",
"params",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"ctx",
".",
"col",
".",
"Default",
"=",
"ctx",
".",
"nextTag",
"\n",
"ctx",
".",
"ignoreNext",
"=",
"true",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DefaultTagHandler describes default tag handler | [
"DefaultTagHandler",
"describes",
"default",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L121-L129 | train |
go-xorm/xorm | tag.go | VersionTagHandler | func VersionTagHandler(ctx *tagContext) error {
ctx.col.IsVersion = true
ctx.col.Default = "1"
return nil
} | go | func VersionTagHandler(ctx *tagContext) error {
ctx.col.IsVersion = true
ctx.col.Default = "1"
return nil
} | [
"func",
"VersionTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"ctx",
".",
"col",
".",
"IsVersion",
"=",
"true",
"\n",
"ctx",
".",
"col",
".",
"Default",
"=",
"\"",
"\"",
"\n",
"return",
"nil",
"\n",
"}"
] | // VersionTagHandler describes version tag handler | [
"VersionTagHandler",
"describes",
"version",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L138-L142 | train |
go-xorm/xorm | tag.go | UTCTagHandler | func UTCTagHandler(ctx *tagContext) error {
ctx.col.TimeZone = time.UTC
return nil
} | go | func UTCTagHandler(ctx *tagContext) error {
ctx.col.TimeZone = time.UTC
return nil
} | [
"func",
"UTCTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"ctx",
".",
"col",
".",
"TimeZone",
"=",
"time",
".",
"UTC",
"\n",
"return",
"nil",
"\n",
"}"
] | // UTCTagHandler describes utc tag handler | [
"UTCTagHandler",
"describes",
"utc",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L145-L148 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.