Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "s", "*", "Stack", ")", "createFileBasedConfigMaps", "(", "configMaps", "corev1", ".", "ConfigMapInterface", ")", "(", "[", "]", "childResource", ",", "error", ")", "{", "var", "resources", "[", "]", "childResource", "\n", "for", "name", ",", "config", ":=", "range", "s", ".", "Spec", ".", "Configs", "{", "if", "config", ".", "File", "==", "\"", "\"", "{", "continue", "\n", "}", "\n\n", "fileName", ":=", "filepath", ".", "Base", "(", "config", ".", "File", ")", "\n", "content", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "config", ".", "File", ")", "\n", "if", "err", "!=", "nil", "{", "return", "resources", ",", "err", "\n", "}", "\n\n", "configMap", ",", "err", ":=", "configMaps", ".", "Create", "(", "toConfigMap", "(", "s", ".", "Name", ",", "name", ",", "fileName", ",", "content", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "resources", ",", "err", "\n", "}", "\n", "resources", "=", "append", "(", "resources", ",", "&", "configMapChildResource", "{", "client", ":", "configMaps", ",", "configMap", ":", "configMap", "}", ")", "\n", "}", "\n", "return", "resources", ",", "nil", "\n", "}" ]

[ "createFileBasedConfigMaps", "creates", "a", "Kubernetes", "ConfigMap", "for", "each", "Compose", "global", "file", "-", "based", "config", "." ]

[ "func", "toConfigMap", "(", "stackName", ",", "name", ",", "key", "string", ",", "content", "[", "]", "byte", ")", "*", "apiv1", ".", "ConfigMap", "{", "return", "&", "apiv1", ".", "ConfigMap", "{", "TypeMeta", ":", "metav1", ".", "TypeMeta", "{", "Kind", ":", "\"", "\"", ",", "APIVersion", ":", "\"", "\"", ",", "}", ",", "ObjectMeta", ":", "metav1", ".", "ObjectMeta", "{", "Name", ":", "name", ",", "Labels", ":", "map", "[", "string", "]", "string", "{", "labels", ".", "ForStackName", ":", "stackName", ",", "}", ",", "}", ",", "Data", ":", "map", "[", "string", "]", "string", "{", "key", ":", "string", "(", "content", ")", ",", "}", ",", "}", "\n", "}" ]

[ "toConfigMap", "converts", "a", "Compose", "Config", "to", "a", "Kube", "ConfigMap", "." ]

[ "func", "(", "s", "*", "Stack", ")", "createFileBasedSecrets", "(", "secrets", "corev1", ".", "SecretInterface", ")", "(", "[", "]", "childResource", ",", "error", ")", "{", "var", "resources", "[", "]", "childResource", "\n", "for", "name", ",", "secret", ":=", "range", "s", ".", "Spec", ".", "Secrets", "{", "if", "secret", ".", "File", "==", "\"", "\"", "{", "continue", "\n", "}", "\n\n", "fileName", ":=", "filepath", ".", "Base", "(", "secret", ".", "File", ")", "\n", "content", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "secret", ".", "File", ")", "\n", "if", "err", "!=", "nil", "{", "return", "resources", ",", "err", "\n", "}", "\n\n", "secret", ",", "err", ":=", "secrets", ".", "Create", "(", "toSecret", "(", "s", ".", "Name", ",", "name", ",", "fileName", ",", "content", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "resources", ",", "err", "\n", "}", "\n", "resources", "=", "append", "(", "resources", ",", "&", "secretChildResource", "{", "client", ":", "secrets", ",", "secret", ":", "secret", "}", ")", "\n", "}", "\n", "return", "resources", ",", "nil", "\n", "}" ]

[ "createFileBasedSecrets", "creates", "a", "Kubernetes", "Secret", "for", "each", "Compose", "global", "file", "-", "based", "secret", "." ]

[ "func", "toSecret", "(", "stackName", ",", "name", ",", "key", "string", ",", "content", "[", "]", "byte", ")", "*", "apiv1", ".", "Secret", "{", "return", "&", "apiv1", ".", "Secret", "{", "ObjectMeta", ":", "metav1", ".", "ObjectMeta", "{", "Name", ":", "name", ",", "Labels", ":", "map", "[", "string", "]", "string", "{", "labels", ".", "ForStackName", ":", "stackName", ",", "}", ",", "}", ",", "Data", ":", "map", "[", "string", "]", "[", "]", "byte", "{", "key", ":", "content", ",", "}", ",", "}", "\n", "}" ]

[ "toSecret", "converts", "a", "Compose", "Secret", "to", "a", "Kube", "Secret", "." ]

[ "func", "resolveDefaultContext", "(", "opts", "*", "cliflags", ".", "CommonOptions", ",", "config", "*", "configfile", ".", "ConfigFile", ",", "stderr", "io", ".", "Writer", ")", "(", "*", "DefaultContext", ",", "error", ")", "{", "stackOrchestrator", ",", "err", ":=", "GetStackOrchestrator", "(", "\"", "\"", ",", "\"", "\"", ",", "config", ".", "StackOrchestrator", ",", "stderr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "contextTLSData", ":=", "store", ".", "ContextTLSData", "{", "Endpoints", ":", "make", "(", "map", "[", "string", "]", "store", ".", "EndpointTLSData", ")", ",", "}", "\n", "contextMetadata", ":=", "store", ".", "Metadata", "{", "Endpoints", ":", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ",", "Metadata", ":", "DockerContext", "{", "Description", ":", "\"", "\"", ",", "StackOrchestrator", ":", "stackOrchestrator", ",", "}", ",", "Name", ":", "DefaultContextName", ",", "}", "\n\n", "dockerEP", ",", "err", ":=", "resolveDefaultDockerEndpoint", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "contextMetadata", ".", "Endpoints", "[", "docker", ".", "DockerEndpoint", "]", "=", "dockerEP", ".", "EndpointMeta", "\n", "if", "dockerEP", ".", "TLSData", "!=", "nil", "{", "contextTLSData", ".", "Endpoints", "[", "docker", ".", "DockerEndpoint", "]", "=", "*", "dockerEP", ".", "TLSData", ".", "ToStoreTLSData", "(", ")", "\n", "}", "\n\n", "// Default context uses env-based kubeconfig for Kubernetes endpoint configuration", "kubeconfig", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "kubeconfig", "==", "\"", "\"", "{", "kubeconfig", "=", "filepath", ".", "Join", "(", "homedir", ".", "Get", "(", ")", ",", "\"", "\"", ")", "\n", "}", "\n", "kubeEP", ",", "err", ":=", "kubernetes", ".", "FromKubeConfig", "(", "kubeconfig", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "(", "stackOrchestrator", "==", "OrchestratorKubernetes", "||", "stackOrchestrator", "==", "OrchestratorAll", ")", "&&", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "stackOrchestrator", ")", "\n", "}", "\n", "if", "err", "==", "nil", "{", "contextMetadata", ".", "Endpoints", "[", "kubernetes", ".", "KubernetesEndpoint", "]", "=", "kubeEP", ".", "EndpointMeta", "\n", "if", "kubeEP", ".", "TLSData", "!=", "nil", "{", "contextTLSData", ".", "Endpoints", "[", "kubernetes", ".", "KubernetesEndpoint", "]", "=", "*", "kubeEP", ".", "TLSData", ".", "ToStoreTLSData", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "&", "DefaultContext", "{", "Meta", ":", "contextMetadata", ",", "TLS", ":", "contextTLSData", "}", ",", "nil", "\n", "}" ]

[ "resolveDefaultContext", "creates", "a", "Metadata", "for", "the", "current", "CLI", "invocation", "parameters" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "List", "(", ")", "(", "[", "]", "store", ".", "Metadata", ",", "error", ")", "{", "contextList", ",", "err", ":=", "s", ".", "Store", ".", "List", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defaultContext", ",", "err", ":=", "s", ".", "Resolver", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "append", "(", "contextList", ",", "defaultContext", ".", "Meta", ")", ",", "nil", "\n", "}" ]

[ "List", "implements", "store", ".", "Store", "s", "List" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "CreateOrUpdate", "(", "meta", "store", ".", "Metadata", ")", "error", "{", "if", "meta", ".", "Name", "==", "DefaultContextName", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", ".", "Store", ".", "CreateOrUpdate", "(", "meta", ")", "\n", "}" ]

[ "CreateOrUpdate", "is", "not", "allowed", "for", "the", "default", "context", "and", "fails" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "Remove", "(", "name", "string", ")", "error", "{", "if", "name", "==", "DefaultContextName", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", ".", "Store", ".", "Remove", "(", "name", ")", "\n", "}" ]

[ "Remove", "is", "not", "allowed", "for", "the", "default", "context", "and", "fails" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "GetMetadata", "(", "name", "string", ")", "(", "store", ".", "Metadata", ",", "error", ")", "{", "if", "name", "==", "DefaultContextName", "{", "defaultContext", ",", "err", ":=", "s", ".", "Resolver", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "store", ".", "Metadata", "{", "}", ",", "err", "\n", "}", "\n", "return", "defaultContext", ".", "Meta", ",", "nil", "\n", "}", "\n", "return", "s", ".", "Store", ".", "GetMetadata", "(", "name", ")", "\n", "}" ]

[ "GetMetadata", "implements", "store", ".", "Store", "s", "GetMetadata" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "ResetTLSMaterial", "(", "name", "string", ",", "data", "*", "store", ".", "ContextTLSData", ")", "error", "{", "if", "name", "==", "DefaultContextName", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", ".", "Store", ".", "ResetTLSMaterial", "(", "name", ",", "data", ")", "\n", "}" ]

[ "ResetTLSMaterial", "is", "not", "implemented", "for", "default", "context", "and", "fails" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "ResetEndpointTLSMaterial", "(", "contextName", "string", ",", "endpointName", "string", ",", "data", "*", "store", ".", "EndpointTLSData", ")", "error", "{", "if", "contextName", "==", "DefaultContextName", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", ".", "Store", ".", "ResetEndpointTLSMaterial", "(", "contextName", ",", "endpointName", ",", "data", ")", "\n", "}" ]

[ "ResetEndpointTLSMaterial", "is", "not", "implemented", "for", "default", "context", "and", "fails" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "ListTLSFiles", "(", "name", "string", ")", "(", "map", "[", "string", "]", "store", ".", "EndpointFiles", ",", "error", ")", "{", "if", "name", "==", "DefaultContextName", "{", "defaultContext", ",", "err", ":=", "s", ".", "Resolver", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tlsfiles", ":=", "make", "(", "map", "[", "string", "]", "store", ".", "EndpointFiles", ")", "\n", "for", "epName", ",", "epTLSData", ":=", "range", "defaultContext", ".", "TLS", ".", "Endpoints", "{", "var", "files", "store", ".", "EndpointFiles", "\n", "for", "filename", ":=", "range", "epTLSData", ".", "Files", "{", "files", "=", "append", "(", "files", ",", "filename", ")", "\n", "}", "\n", "tlsfiles", "[", "epName", "]", "=", "files", "\n", "}", "\n", "return", "tlsfiles", ",", "nil", "\n", "}", "\n", "return", "s", ".", "Store", ".", "ListTLSFiles", "(", "name", ")", "\n", "}" ]

[ "ListTLSFiles", "implements", "store", ".", "Store", "s", "ListTLSFiles" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "GetTLSData", "(", "contextName", ",", "endpointName", ",", "fileName", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "contextName", "==", "DefaultContextName", "{", "defaultContext", ",", "err", ":=", "s", ".", "Resolver", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "defaultContext", ".", "TLS", ".", "Endpoints", "[", "endpointName", "]", ".", "Files", "[", "fileName", "]", "==", "nil", "{", "return", "nil", ",", "&", "noDefaultTLSDataError", "{", "endpointName", ":", "endpointName", ",", "fileName", ":", "fileName", "}", "\n", "}", "\n", "return", "defaultContext", ".", "TLS", ".", "Endpoints", "[", "endpointName", "]", ".", "Files", "[", "fileName", "]", ",", "nil", "\n\n", "}", "\n", "return", "s", ".", "Store", ".", "GetTLSData", "(", "contextName", ",", "endpointName", ",", "fileName", ")", "\n", "}" ]

[ "GetTLSData", "implements", "store", ".", "Store", "s", "GetTLSData" ]

[ "func", "(", "s", "*", "ContextStoreWithDefault", ")", "GetStorageInfo", "(", "contextName", "string", ")", "store", ".", "StorageInfo", "{", "if", "contextName", "==", "DefaultContextName", "{", "return", "store", ".", "StorageInfo", "{", "MetadataPath", ":", "\"", "\"", ",", "TLSPath", ":", "\"", "\"", "}", "\n", "}", "\n", "return", "s", ".", "Store", ".", "GetStorageInfo", "(", "contextName", ")", "\n", "}" ]

[ "GetStorageInfo", "implements", "store", ".", "Store", "s", "GetStorageInfo" ]

[ "func", "NewFormat", "(", "source", "string", ",", "quiet", "bool", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "PrettyFormatKey", ":", "return", "secretInspectPrettyTemplate", "\n", "case", "formatter", ".", "TableFormatKey", ":", "if", "quiet", "{", "return", "formatter", ".", "DefaultQuietFormat", "\n", "}", "\n", "return", "defaultSecretTableFormat", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

[ "NewFormat", "returns", "a", "Format", "for", "rendering", "using", "a", "secret", "Context" ]

[ "func", "InspectFormatWrite", "(", "ctx", "formatter", ".", "Context", ",", "refs", "[", "]", "string", ",", "getRef", "inspect", ".", "GetRefFunc", ")", "error", "{", "if", "ctx", ".", "Format", "!=", "secretInspectPrettyTemplate", "{", "return", "inspect", ".", "Inspect", "(", "ctx", ".", "Output", ",", "refs", ",", "string", "(", "ctx", ".", "Format", ")", ",", "getRef", ")", "\n", "}", "\n", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "ref", ":=", "range", "refs", "{", "secretI", ",", "_", ",", "err", ":=", "getRef", "(", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "secret", ",", "ok", ":=", "secretI", ".", "(", "swarm", ".", "Secret", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ok", ")", "\n", "}", "\n", "if", "err", ":=", "format", "(", "&", "secretInspectContext", "{", "Secret", ":", "secret", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "secretInspectContext", "{", "}", ",", "render", ")", "\n", "}" ]

[ "InspectFormatWrite", "renders", "the", "context", "for", "a", "list", "of", "secrets" ]

[ "func", "ValidateMACAddress", "(", "val", "string", ")", "(", "string", ",", "error", ")", "{", "_", ",", "err", ":=", "net", ".", "ParseMAC", "(", "strings", ".", "TrimSpace", "(", "val", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "val", ",", "nil", "\n", "}" ]

[ "ValidateMACAddress", "validates", "a", "MAC", "address", "." ]

[ "func", "ValidateSysctl", "(", "val", "string", ")", "(", "string", ",", "error", ")", "{", "validSysctlMap", ":=", "map", "[", "string", "]", "bool", "{", "\"", "\"", ":", "true", ",", "\"", "\"", ":", "true", ",", "\"", "\"", ":", "true", ",", "\"", "\"", ":", "true", ",", "\"", "\"", ":", "true", ",", "\"", "\"", ":", "true", ",", "\"", "\"", ":", "true", ",", "\"", "\"", ":", "true", ",", "}", "\n", "validSysctlPrefixes", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "arr", ":=", "strings", ".", "Split", "(", "val", ",", "\"", "\"", ")", "\n", "if", "len", "(", "arr", ")", "<", "2", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n", "if", "validSysctlMap", "[", "arr", "[", "0", "]", "]", "{", "return", "val", ",", "nil", "\n", "}", "\n\n", "for", "_", ",", "vp", ":=", "range", "validSysctlPrefixes", "{", "if", "strings", ".", "HasPrefix", "(", "arr", "[", "0", "]", ",", "vp", ")", "{", "return", "val", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}" ]

[ "ValidateSysctl", "validates", "a", "sysctl", "and", "returns", "it", "." ]

[ "func", "(", "c", "*", "NanoCPUs", ")", "String", "(", ")", "string", "{", "if", "*", "c", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "big", ".", "NewRat", "(", "c", ".", "Value", "(", ")", ",", "1e9", ")", ".", "FloatString", "(", "3", ")", "\n", "}" ]

[ "String", "returns", "the", "string", "format", "of", "the", "number" ]

[ "func", "(", "c", "*", "NanoCPUs", ")", "Set", "(", "value", "string", ")", "error", "{", "cpus", ",", "err", ":=", "ParseCPUs", "(", "value", ")", "\n", "*", "c", "=", "NanoCPUs", "(", "cpus", ")", "\n", "return", "err", "\n", "}" ]

[ "Set", "sets", "the", "value", "of", "the", "NanoCPU", "by", "passing", "a", "string" ]

[ "func", "ParseCPUs", "(", "value", "string", ")", "(", "int64", ",", "error", ")", "{", "cpu", ",", "ok", ":=", "new", "(", "big", ".", "Rat", ")", ".", "SetString", "(", "value", ")", "\n", "if", "!", "ok", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "value", ")", "\n", "}", "\n", "nano", ":=", "cpu", ".", "Mul", "(", "cpu", ",", "big", ".", "NewRat", "(", "1e9", ",", "1", ")", ")", "\n", "if", "!", "nano", ".", "IsInt", "(", ")", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nano", ".", "Num", "(", ")", ".", "Int64", "(", ")", ",", "nil", "\n", "}" ]

[ "ParseCPUs", "takes", "a", "string", "ratio", "and", "returns", "an", "integer", "value", "of", "nano", "cpus" ]

[ "func", "(", "m", "*", "MemSwapBytes", ")", "Set", "(", "value", "string", ")", "error", "{", "if", "value", "==", "\"", "\"", "{", "*", "m", "=", "MemSwapBytes", "(", "-", "1", ")", "\n", "return", "nil", "\n", "}", "\n", "val", ",", "err", ":=", "units", ".", "RAMInBytes", "(", "value", ")", "\n", "*", "m", "=", "MemSwapBytes", "(", "val", ")", "\n", "return", "err", "\n", "}" ]

[ "Set", "sets", "the", "value", "of", "the", "MemSwapBytes", "by", "passing", "a", "string" ]

[ "func", "(", "m", "*", "MemSwapBytes", ")", "UnmarshalJSON", "(", "s", "[", "]", "byte", ")", "error", "{", "b", ":=", "MemBytes", "(", "*", "m", ")", "\n", "return", "b", ".", "UnmarshalJSON", "(", "s", ")", "\n", "}" ]

[ "UnmarshalJSON", "is", "the", "customized", "unmarshaler", "for", "MemSwapBytes" ]

[ "func", "NewContextCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "}", "\n", "cmd", ".", "AddCommand", "(", "newCreateCommand", "(", "dockerCli", ")", ",", "newListCommand", "(", "dockerCli", ")", ",", "newUseCommand", "(", "dockerCli", ")", ",", "newExportCommand", "(", "dockerCli", ")", ",", "newImportCommand", "(", "dockerCli", ")", ",", "newRemoveCommand", "(", "dockerCli", ")", ",", "newUpdateCommand", "(", "dockerCli", ")", ",", "newInspectCommand", "(", "dockerCli", ")", ",", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewContextCommand", "returns", "the", "context", "cli", "subcommand" ]

[ "func", "NewCommitCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "options", "commitOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresRangeArgs", "(", "1", ",", "2", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "options", ".", "container", "=", "args", "[", "0", "]", "\n", "if", "len", "(", "args", ")", ">", "1", "{", "options", ".", "reference", "=", "args", "[", "1", "]", "\n", "}", "\n", "return", "runCommit", "(", "dockerCli", ",", "&", "options", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "SetInterspersed", "(", "false", ")", "\n\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "pause", ",", "\"", "\"", ",", "\"", "\"", ",", "true", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVarP", "(", "&", "options", ".", "comment", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVarP", "(", "&", "options", ".", "author", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\\\"", "\\\"", "\"", ")", "\n\n", "options", ".", "changes", "=", "opts", ".", "NewListOpts", "(", "nil", ")", "\n", "flags", ".", "VarP", "(", "&", "options", ".", "changes", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewCommitCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "commit" ]

[ "func", "NewNativeStore", "(", "file", "store", ",", "helperSuffix", "string", ")", "Store", "{", "name", ":=", "remoteCredentialsPrefix", "+", "helperSuffix", "\n", "return", "&", "nativeStore", "{", "programFunc", ":", "client", ".", "NewShellProgramFunc", "(", "name", ")", ",", "fileStore", ":", "NewFileStore", "(", "file", ")", ",", "}", "\n", "}" ]

[ "NewNativeStore", "creates", "a", "new", "native", "store", "that", "uses", "a", "remote", "helper", "program", "to", "manage", "credentials", "." ]

[ "func", "(", "c", "*", "nativeStore", ")", "Erase", "(", "serverAddress", "string", ")", "error", "{", "if", "err", ":=", "client", ".", "Erase", "(", "c", ".", "programFunc", ",", "serverAddress", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Fallback to plain text store to remove email", "return", "c", ".", "fileStore", ".", "Erase", "(", "serverAddress", ")", "\n", "}" ]

[ "Erase", "removes", "the", "given", "credentials", "from", "the", "native", "store", "." ]

[ "func", "(", "c", "*", "nativeStore", ")", "Get", "(", "serverAddress", "string", ")", "(", "types", ".", "AuthConfig", ",", "error", ")", "{", "// load user email if it exist or an empty auth config.", "auth", ",", "_", ":=", "c", ".", "fileStore", ".", "Get", "(", "serverAddress", ")", "\n\n", "creds", ",", "err", ":=", "c", ".", "getCredentialsFromStore", "(", "serverAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "auth", ",", "err", "\n", "}", "\n", "auth", ".", "Username", "=", "creds", ".", "Username", "\n", "auth", ".", "IdentityToken", "=", "creds", ".", "IdentityToken", "\n", "auth", ".", "Password", "=", "creds", ".", "Password", "\n\n", "return", "auth", ",", "nil", "\n", "}" ]

[ "Get", "retrieves", "credentials", "for", "a", "specific", "server", "from", "the", "native", "store", "." ]

[ "func", "(", "c", "*", "nativeStore", ")", "GetAll", "(", ")", "(", "map", "[", "string", "]", "types", ".", "AuthConfig", ",", "error", ")", "{", "auths", ",", "err", ":=", "c", ".", "listCredentialsInStore", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Emails are only stored in the file store.", "// This call can be safely eliminated when emails are removed.", "fileConfigs", ",", "_", ":=", "c", ".", "fileStore", ".", "GetAll", "(", ")", "\n\n", "authConfigs", ":=", "make", "(", "map", "[", "string", "]", "types", ".", "AuthConfig", ")", "\n", "for", "registry", ":=", "range", "auths", "{", "creds", ",", "err", ":=", "c", ".", "getCredentialsFromStore", "(", "registry", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ac", ":=", "fileConfigs", "[", "registry", "]", "// might contain Email", "\n", "ac", ".", "Username", "=", "creds", ".", "Username", "\n", "ac", ".", "Password", "=", "creds", ".", "Password", "\n", "ac", ".", "IdentityToken", "=", "creds", ".", "IdentityToken", "\n", "authConfigs", "[", "registry", "]", "=", "ac", "\n", "}", "\n\n", "return", "authConfigs", ",", "nil", "\n", "}" ]

[ "GetAll", "retrieves", "all", "the", "credentials", "from", "the", "native", "store", "." ]

[ "func", "(", "c", "*", "nativeStore", ")", "storeCredentialsInStore", "(", "config", "types", ".", "AuthConfig", ")", "error", "{", "creds", ":=", "&", "credentials", ".", "Credentials", "{", "ServerURL", ":", "config", ".", "ServerAddress", ",", "Username", ":", "config", ".", "Username", ",", "Secret", ":", "config", ".", "Password", ",", "}", "\n\n", "if", "config", ".", "IdentityToken", "!=", "\"", "\"", "{", "creds", ".", "Username", "=", "tokenUsername", "\n", "creds", ".", "Secret", "=", "config", ".", "IdentityToken", "\n", "}", "\n\n", "return", "client", ".", "Store", "(", "c", ".", "programFunc", ",", "creds", ")", "\n", "}" ]

[ "storeCredentialsInStore", "executes", "the", "command", "to", "store", "the", "credentials", "in", "the", "native", "store", "." ]

[ "func", "(", "c", "*", "nativeStore", ")", "getCredentialsFromStore", "(", "serverAddress", "string", ")", "(", "types", ".", "AuthConfig", ",", "error", ")", "{", "var", "ret", "types", ".", "AuthConfig", "\n\n", "creds", ",", "err", ":=", "client", ".", "Get", "(", "c", ".", "programFunc", ",", "serverAddress", ")", "\n", "if", "err", "!=", "nil", "{", "if", "credentials", ".", "IsErrCredentialsNotFound", "(", "err", ")", "{", "// do not return an error if the credentials are not", "// in the keychain. Let docker ask for new credentials.", "return", "ret", ",", "nil", "\n", "}", "\n", "return", "ret", ",", "err", "\n", "}", "\n\n", "if", "creds", ".", "Username", "==", "tokenUsername", "{", "ret", ".", "IdentityToken", "=", "creds", ".", "Secret", "\n", "}", "else", "{", "ret", ".", "Password", "=", "creds", ".", "Secret", "\n", "ret", ".", "Username", "=", "creds", ".", "Username", "\n", "}", "\n\n", "ret", ".", "ServerAddress", "=", "serverAddress", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "getCredentialsFromStore", "executes", "the", "command", "to", "get", "the", "credentials", "from", "the", "native", "store", "." ]

[ "func", "(", "c", "*", "nativeStore", ")", "listCredentialsInStore", "(", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "return", "client", ".", "List", "(", "c", ".", "programFunc", ")", "\n", "}" ]

[ "listCredentialsInStore", "returns", "a", "listing", "of", "stored", "credentials", "as", "a", "map", "of", "URL", "-", ">", "username", "." ]

[ "func", "GetEngineVersions", "(", "ctx", "context", ".", "Context", ",", "registryClient", "registryclient", ".", "RegistryClient", ",", "registryPrefix", ",", "imageName", ",", "versionString", "string", ")", "(", "clitypes", ".", "AvailableVersions", ",", "error", ")", "{", "if", "imageName", "==", "\"", "\"", "{", "var", "err", "error", "\n", "localMetadata", ",", "err", ":=", "GetCurrentRuntimeMetadata", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "clitypes", ".", "AvailableVersions", "{", "}", ",", "err", "\n", "}", "\n", "imageName", "=", "localMetadata", ".", "EngineImage", "\n", "}", "\n", "imageRef", ",", "err", ":=", "reference", ".", "ParseNormalizedNamed", "(", "path", ".", "Join", "(", "registryPrefix", ",", "imageName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "clitypes", ".", "AvailableVersions", "{", "}", ",", "err", "\n", "}", "\n\n", "tags", ",", "err", ":=", "registryClient", ".", "GetTags", "(", "ctx", ",", "imageRef", ")", "\n", "if", "err", "!=", "nil", "{", "return", "clitypes", ".", "AvailableVersions", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "parseTags", "(", "tags", ",", "versionString", ")", "\n", "}" ]

[ "GetEngineVersions", "reports", "the", "versions", "of", "the", "engine", "that", "are", "available" ]

[ "func", "GetCurrentRuntimeMetadata", "(", "metadataDir", "string", ")", "(", "*", "clitypes", ".", "RuntimeMetadata", ",", "error", ")", "{", "if", "metadataDir", "==", "\"", "\"", "{", "metadataDir", "=", "defaultRuntimeMetadataDir", "\n", "}", "\n", "filename", ":=", "filepath", ".", "Join", "(", "metadataDir", ",", "clitypes", ".", "RuntimeMetadataName", "+", "\"", "\"", ")", "\n\n", "data", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "res", "clitypes", ".", "RuntimeMetadata", "\n", "err", "=", "json", ".", "Unmarshal", "(", "data", ",", "&", "res", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "filename", ")", "\n", "}", "\n", "return", "&", "res", ",", "nil", "\n", "}" ]

[ "GetCurrentRuntimeMetadata", "loads", "the", "current", "daemon", "runtime", "metadata", "information", "from", "the", "local", "host" ]

[ "func", "WriteRuntimeMetadata", "(", "metadataDir", "string", ",", "metadata", "*", "clitypes", ".", "RuntimeMetadata", ")", "error", "{", "if", "metadataDir", "==", "\"", "\"", "{", "metadataDir", "=", "defaultRuntimeMetadataDir", "\n", "}", "\n", "filename", ":=", "filepath", ".", "Join", "(", "metadataDir", ",", "clitypes", ".", "RuntimeMetadataName", "+", "\"", "\"", ")", "\n\n", "data", ",", "err", ":=", "json", ".", "Marshal", "(", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "os", ".", "Remove", "(", "filename", ")", "\n", "return", "ioutil", ".", "WriteFile", "(", "filename", ",", "data", ",", "0644", ")", "\n", "}" ]

[ "WriteRuntimeMetadata", "stores", "the", "metadata", "on", "the", "local", "system" ]

[ "func", "newPruneCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "options", ":=", "pruneOptions", "{", "filter", ":", "opts", ".", "NewFilterOpt", "(", ")", "}", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "options", ".", "pruneBuildCache", "=", "versions", ".", "GreaterThanOrEqualTo", "(", "dockerCli", ".", "Client", "(", ")", ".", "ClientVersion", "(", ")", ",", "\"", "\"", ")", "\n", "return", "runPrune", "(", "dockerCli", ",", "options", ")", "\n", "}", ",", "Annotations", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "force", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "all", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "options", ".", "pruneVolumes", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "Var", "(", "&", "options", ".", "filter", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "// \"filter\" flag is available in 1.28 (docker 17.04) and up", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "newPruneCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "prune" ]

[ "func", "confirmationMessage", "(", "dockerCli", "command", ".", "Cli", ",", "options", "pruneOptions", ")", "string", "{", "t", ":=", "template", ".", "Must", "(", "template", ".", "New", "(", "\"", "\"", ")", ".", "Parse", "(", "confirmationTemplate", ")", ")", "\n\n", "warnings", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "if", "options", ".", "pruneVolumes", "{", "warnings", "=", "append", "(", "warnings", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "options", ".", "all", "{", "warnings", "=", "append", "(", "warnings", ",", "\"", "\"", ")", "\n", "}", "else", "{", "warnings", "=", "append", "(", "warnings", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "options", ".", "pruneBuildCache", "{", "if", "options", ".", "all", "{", "warnings", "=", "append", "(", "warnings", ",", "\"", "\"", ")", "\n", "}", "else", "{", "warnings", "=", "append", "(", "warnings", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "var", "filters", "[", "]", "string", "\n", "pruneFilters", ":=", "command", ".", "PruneFilters", "(", "dockerCli", ",", "options", ".", "filter", ".", "Value", "(", ")", ")", "\n", "if", "pruneFilters", ".", "Len", "(", ")", ">", "0", "{", "// TODO remove fixed list of filters, and print all filters instead,", "// because the list of filters that is supported by the engine may evolve over time.", "for", "_", ",", "name", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "{", "for", "_", ",", "v", ":=", "range", "pruneFilters", ".", "Get", "(", "name", ")", "{", "filters", "=", "append", "(", "filters", ",", "name", "+", "\"", "\"", "+", "v", ")", "\n", "}", "\n", "}", "\n", "sort", ".", "Slice", "(", "filters", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "sortorder", ".", "NaturalLess", "(", "filters", "[", "i", "]", ",", "filters", "[", "j", "]", ")", "\n", "}", ")", "\n", "}", "\n\n", "var", "buffer", "bytes", ".", "Buffer", "\n", "t", ".", "Execute", "(", "&", "buffer", ",", "map", "[", "string", "]", "[", "]", "string", "{", "\"", "\"", ":", "warnings", ",", "\"", "\"", ":", "filters", "}", ")", "\n", "return", "buffer", ".", "String", "(", ")", "\n", "}" ]

[ "confirmationMessage", "constructs", "a", "confirmation", "message", "that", "depends", "on", "the", "cli", "options", "." ]

[ "func", "SetupConfigFile", "(", "t", "*", "testing", ".", "T", ")", "fs", ".", "Dir", "{", "t", ".", "Helper", "(", ")", "\n", "return", "SetupConfigWithNotaryURL", "(", "t", ",", "\"", "\"", ",", "NotaryURL", ")", "\n", "}" ]

[ "SetupConfigFile", "creates", "a", "config", ".", "json", "file", "for", "testing" ]

[ "func", "SetupConfigWithNotaryURL", "(", "t", "*", "testing", ".", "T", ",", "path", ",", "notaryURL", "string", ")", "fs", ".", "Dir", "{", "t", ".", "Helper", "(", ")", "\n", "dir", ":=", "fs", ".", "NewDir", "(", "t", ",", "path", ",", "fs", ".", "WithMode", "(", "0700", ")", ",", "fs", ".", "WithFile", "(", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "`\n\t{\n\t\t\"auths\": {\n\t\t\t\"registry:5000\": {\n\t\t\t\t\"auth\": \"ZWlhaXM6cGFzc3dvcmQK\"\n\t\t\t},\n\t\t\t\"%s\": {\n\t\t\t\t\"auth\": \"ZWlhaXM6cGFzc3dvcmQK\"\n\t\t\t}\n\t\t},\n\t\t\"experimental\": \"enabled\"\n\t}\n\t`", ",", "notaryURL", ")", ")", ",", "fs", ".", "WithDir", "(", "\"", "\"", ",", "fs", ".", "WithDir", "(", "\"", "\"", ")", ")", ")", "\n", "return", "*", "dir", "\n", "}" ]

[ "SetupConfigWithNotaryURL", "creates", "a", "config", ".", "json", "file", "for", "testing", "in", "the", "given", "path", "with", "the", "given", "notaryURL" ]

[ "func", "WithConfig", "(", "dir", "string", ")", "func", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "return", "func", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "env", ":=", "append", "(", "os", ".", "Environ", "(", ")", ",", "\"", "\"", "+", "dir", ",", ")", "\n", "cmd", ".", "Env", "=", "append", "(", "cmd", ".", "Env", ",", "env", "...", ")", "\n", "}", "\n", "}" ]

[ "WithConfig", "sets", "an", "environment", "variable", "for", "the", "docker", "config", "location" ]

[ "func", "WithPassphrase", "(", "rootPwd", ",", "repositoryPwd", "string", ")", "func", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "return", "func", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "env", ":=", "append", "(", "os", ".", "Environ", "(", ")", ",", "\"", "\"", "+", "rootPwd", ",", "\"", "\"", "+", "repositoryPwd", ",", ")", "\n", "cmd", ".", "Env", "=", "append", "(", "cmd", ".", "Env", ",", "env", "...", ")", "\n", "}", "\n", "}" ]

[ "WithPassphrase", "sets", "environment", "variables", "for", "passphrases" ]

[ "func", "WithTrust", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "env", ":=", "append", "(", "os", ".", "Environ", "(", ")", ",", "\"", "\"", ",", ")", "\n", "cmd", ".", "Env", "=", "append", "(", "cmd", ".", "Env", ",", "env", "...", ")", "\n", "}" ]

[ "WithTrust", "sets", "DOCKER_CONTENT_TRUST", "to", "1" ]

[ "func", "WithNotary", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "env", ":=", "append", "(", "os", ".", "Environ", "(", ")", ",", "\"", "\"", "+", "NotaryURL", ",", ")", "\n", "cmd", ".", "Env", "=", "append", "(", "cmd", ".", "Env", ",", "env", "...", ")", "\n", "}" ]

[ "WithNotary", "sets", "the", "location", "of", "the", "notary", "server" ]

[ "func", "WithHome", "(", "path", "string", ")", "func", "(", "*", "icmd", ".", "Cmd", ")", "{", "return", "func", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "cmd", ".", "Env", "=", "append", "(", "cmd", ".", "Env", ",", "\"", "\"", "+", "path", ")", "\n", "}", "\n", "}" ]

[ "WithHome", "sets", "the", "HOME", "environment", "variable" ]

[ "func", "WithNotaryServer", "(", "notaryURL", "string", ")", "func", "(", "*", "icmd", ".", "Cmd", ")", "{", "return", "func", "(", "cmd", "*", "icmd", ".", "Cmd", ")", "{", "env", ":=", "append", "(", "os", ".", "Environ", "(", ")", ",", "\"", "\"", "+", "notaryURL", ",", ")", "\n", "cmd", ".", "Env", "=", "append", "(", "cmd", ".", "Env", ",", "env", "...", ")", "\n", "}", "\n", "}" ]

[ "WithNotaryServer", "sets", "the", "location", "of", "the", "notary", "server" ]

[ "func", "CreateMaskedTrustedRemoteImage", "(", "t", "*", "testing", ".", "T", ",", "registryPrefix", ",", "repo", ",", "tag", "string", ")", "string", "{", "t", ".", "Helper", "(", ")", "\n", "image", ":=", "createTrustedRemoteImage", "(", "t", ",", "registryPrefix", ",", "repo", ",", "tag", ")", "\n", "createNamedUnsignedImageFromBusyBox", "(", "t", ",", "image", ")", "\n", "return", "image", "\n", "}" ]

[ "CreateMaskedTrustedRemoteImage", "creates", "a", "remote", "image", "that", "is", "signed", "with", "content", "trust", "then", "pushes", "a", "different", "untrusted", "image", "at", "the", "same", "tag", "." ]

[ "func", "RunUse", "(", "dockerCli", "command", ".", "Cli", ",", "name", "string", ")", "error", "{", "if", "err", ":=", "validateContextName", "(", "name", ")", ";", "err", "!=", "nil", "&&", "name", "!=", "\"", "\"", "{", "return", "err", "\n", "}", "\n", "if", "_", ",", "err", ":=", "dockerCli", ".", "ContextStore", "(", ")", ".", "GetMetadata", "(", "name", ")", ";", "err", "!=", "nil", "&&", "name", "!=", "\"", "\"", "{", "return", "err", "\n", "}", "\n", "configValue", ":=", "name", "\n", "if", "configValue", "==", "\"", "\"", "{", "configValue", "=", "\"", "\"", "\n", "}", "\n", "dockerConfig", ":=", "dockerCli", ".", "ConfigFile", "(", ")", "\n", "dockerConfig", ".", "CurrentContext", "=", "configValue", "\n", "if", "err", ":=", "dockerConfig", ".", "Save", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Out", "(", ")", ",", "name", ")", "\n", "fmt", ".", "Fprintf", "(", "dockerCli", ".", "Err", "(", ")", ",", "\"", "\\n", "\"", ",", "name", ")", "\n", "if", "os", ".", "Getenv", "(", "\"", "\"", ")", "!=", "\"", "\"", "{", "fmt", ".", "Fprintf", "(", "dockerCli", ".", "Err", "(", ")", ",", "\"", "\"", "+", "\"", "\\n", "\"", ",", "name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RunUse", "set", "the", "current", "Docker", "context" ]

[ "func", "ValidateContextDirectory", "(", "srcPath", "string", ",", "excludes", "[", "]", "string", ")", "error", "{", "contextRoot", ",", "err", ":=", "getContextRoot", "(", "srcPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "pm", ",", "err", ":=", "fileutils", ".", "NewPatternMatcher", "(", "excludes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "filepath", ".", "Walk", "(", "contextRoot", ",", "func", "(", "filePath", "string", ",", "f", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "if", "os", ".", "IsPermission", "(", "err", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "filePath", ")", "\n", "}", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "filePath", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n\n", "// skip this directory/file if it's not in the path, it won't get added to the context", "if", "relFilePath", ",", "err", ":=", "filepath", ".", "Rel", "(", "contextRoot", ",", "filePath", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "skip", ",", "err", ":=", "filepathMatches", "(", "pm", ",", "relFilePath", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "skip", "{", "if", "f", ".", "IsDir", "(", ")", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// skip checking if symlinks point to non-existing files, such symlinks can be useful", "// also skip named pipes, because they hanging on open", "if", "f", ".", "Mode", "(", ")", "&", "(", "os", ".", "ModeSymlink", "|", "os", ".", "ModeNamedPipe", ")", "!=", "0", "{", "return", "nil", "\n", "}", "\n\n", "if", "!", "f", ".", "IsDir", "(", ")", "{", "currentFile", ",", "err", ":=", "os", ".", "Open", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "&&", "os", ".", "IsPermission", "(", "err", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "filePath", ")", "\n", "}", "\n", "currentFile", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "ValidateContextDirectory", "checks", "if", "all", "the", "contents", "of", "the", "directory", "can", "be", "read", "and", "returns", "an", "error", "if", "some", "files", "can", "t", "be", "read", "symlinks", "which", "point", "to", "non", "-", "existing", "files", "don", "t", "trigger", "an", "error" ]

[ "func", "DetectArchiveReader", "(", "input", "io", ".", "ReadCloser", ")", "(", "rc", "io", ".", "ReadCloser", ",", "isArchive", "bool", ",", "err", "error", ")", "{", "buf", ":=", "bufio", ".", "NewReader", "(", "input", ")", "\n\n", "magic", ",", "err", ":=", "buf", ".", "Peek", "(", "archiveHeaderSize", "*", "2", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "return", "nil", ",", "false", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "ioutils", ".", "NewReadCloserWrapper", "(", "buf", ",", "func", "(", ")", "error", "{", "return", "input", ".", "Close", "(", ")", "}", ")", ",", "IsArchive", "(", "magic", ")", ",", "nil", "\n", "}" ]

[ "DetectArchiveReader", "detects", "whether", "the", "input", "stream", "is", "an", "archive", "or", "a", "Dockerfile", "and", "returns", "a", "buffered", "version", "of", "input", "safe", "to", "consume", "in", "lieu", "of", "input", ".", "If", "an", "archive", "is", "detected", "isArchive", "is", "set", "to", "true", "and", "to", "false", "otherwise", "in", "which", "case", "it", "is", "safe", "to", "assume", "input", "represents", "the", "contents", "of", "a", "Dockerfile", "." ]

[ "func", "WriteTempDockerfile", "(", "rc", "io", ".", "ReadCloser", ")", "(", "dockerfileDir", "string", ",", "err", "error", ")", "{", "// err is a named return value, due to the defer call below.", "dockerfileDir", ",", "err", "=", "ioutil", ".", "TempDir", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "os", ".", "RemoveAll", "(", "dockerfileDir", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "f", ",", "err", ":=", "os", ".", "Create", "(", "filepath", ".", "Join", "(", "dockerfileDir", ",", "DefaultDockerfileName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "f", ",", "rc", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "dockerfileDir", ",", "rc", ".", "Close", "(", ")", "\n", "}" ]

[ "WriteTempDockerfile", "writes", "a", "Dockerfile", "stream", "to", "a", "temporary", "file", "with", "a", "name", "specified", "by", "DefaultDockerfileName", "and", "returns", "the", "path", "to", "the", "temporary", "directory", "containing", "the", "Dockerfile", "." ]

[ "func", "GetContextFromReader", "(", "rc", "io", ".", "ReadCloser", ",", "dockerfileName", "string", ")", "(", "out", "io", ".", "ReadCloser", ",", "relDockerfile", "string", ",", "err", "error", ")", "{", "rc", ",", "isArchive", ",", "err", ":=", "DetectArchiveReader", "(", "rc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "isArchive", "{", "return", "rc", ",", "dockerfileName", ",", "nil", "\n", "}", "\n\n", "// Input should be read as a Dockerfile.", "if", "dockerfileName", "==", "\"", "\"", "{", "return", "nil", ",", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "dockerfileDir", ",", "err", ":=", "WriteTempDockerfile", "(", "rc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "tar", ",", "err", ":=", "archive", ".", "Tar", "(", "dockerfileDir", ",", "archive", ".", "Uncompressed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "ioutils", ".", "NewReadCloserWrapper", "(", "tar", ",", "func", "(", ")", "error", "{", "err", ":=", "tar", ".", "Close", "(", ")", "\n", "os", ".", "RemoveAll", "(", "dockerfileDir", ")", "\n", "return", "err", "\n", "}", ")", ",", "DefaultDockerfileName", ",", "nil", "\n", "}" ]

[ "GetContextFromReader", "will", "read", "the", "contents", "of", "the", "given", "reader", "as", "either", "a", "Dockerfile", "or", "tar", "archive", ".", "Returns", "a", "tar", "archive", "used", "as", "a", "context", "and", "a", "path", "to", "the", "Dockerfile", "inside", "the", "tar", "." ]

[ "func", "IsArchive", "(", "header", "[", "]", "byte", ")", "bool", "{", "compression", ":=", "archive", ".", "DetectCompression", "(", "header", ")", "\n", "if", "compression", "!=", "archive", ".", "Uncompressed", "{", "return", "true", "\n", "}", "\n", "r", ":=", "tar", ".", "NewReader", "(", "bytes", ".", "NewBuffer", "(", "header", ")", ")", "\n", "_", ",", "err", ":=", "r", ".", "Next", "(", ")", "\n", "return", "err", "==", "nil", "\n", "}" ]

[ "IsArchive", "checks", "for", "the", "magic", "bytes", "of", "a", "tar", "or", "any", "supported", "compression", "algorithm", "." ]

[ "func", "GetContextFromGitURL", "(", "gitURL", ",", "dockerfileName", "string", ")", "(", "string", ",", "string", ",", "error", ")", "{", "if", "_", ",", "err", ":=", "exec", ".", "LookPath", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "absContextDir", ",", "err", ":=", "git", ".", "Clone", "(", "gitURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "absContextDir", ",", "err", "=", "ResolveAndValidateContextPath", "(", "absContextDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "relDockerfile", ",", "err", ":=", "getDockerfileRelPath", "(", "absContextDir", ",", "dockerfileName", ")", "\n", "if", "err", "==", "nil", "&&", "strings", ".", "HasPrefix", "(", "relDockerfile", ",", "\"", "\"", "+", "string", "(", "filepath", ".", "Separator", ")", ")", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "dockerfileName", ")", "\n", "}", "\n\n", "return", "absContextDir", ",", "relDockerfile", ",", "err", "\n", "}" ]

[ "GetContextFromGitURL", "uses", "a", "Git", "URL", "as", "context", "for", "a", "docker", "build", ".", "The", "git", "repo", "is", "cloned", "into", "a", "temporary", "directory", "used", "as", "the", "context", "directory", ".", "Returns", "the", "absolute", "path", "to", "the", "temporary", "context", "directory", "the", "relative", "path", "of", "the", "dockerfile", "in", "that", "context", "directory", "and", "a", "non", "-", "nil", "error", "on", "success", "." ]

[ "func", "GetContextFromURL", "(", "out", "io", ".", "Writer", ",", "remoteURL", ",", "dockerfileName", "string", ")", "(", "io", ".", "ReadCloser", ",", "string", ",", "error", ")", "{", "response", ",", "err", ":=", "getWithStatusError", "(", "remoteURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "remoteURL", ",", "err", ")", "\n", "}", "\n", "progressOutput", ":=", "streamformatter", ".", "NewProgressOutput", "(", "out", ")", "\n\n", "// Pass the response body through a progress reader.", "progReader", ":=", "progress", ".", "NewProgressReader", "(", "response", ".", "Body", ",", "progressOutput", ",", "response", ".", "ContentLength", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "remoteURL", ")", ")", "\n\n", "return", "GetContextFromReader", "(", "ioutils", ".", "NewReadCloserWrapper", "(", "progReader", ",", "func", "(", ")", "error", "{", "return", "response", ".", "Body", ".", "Close", "(", ")", "}", ")", ",", "dockerfileName", ")", "\n", "}" ]

[ "GetContextFromURL", "uses", "a", "remote", "URL", "as", "context", "for", "a", "docker", "build", ".", "The", "remote", "resource", "is", "downloaded", "as", "either", "a", "Dockerfile", "or", "a", "tar", "archive", ".", "Returns", "the", "tar", "archive", "used", "for", "the", "context", "and", "a", "path", "of", "the", "dockerfile", "inside", "the", "tar", "." ]

[ "func", "GetContextFromLocalDir", "(", "localDir", ",", "dockerfileName", "string", ")", "(", "string", ",", "string", ",", "error", ")", "{", "localDir", ",", "err", ":=", "ResolveAndValidateContextPath", "(", "localDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// When using a local context directory, and the Dockerfile is specified", "// with the `-f/--file` option then it is considered relative to the", "// current directory and not the context directory.", "if", "dockerfileName", "!=", "\"", "\"", "&&", "dockerfileName", "!=", "\"", "\"", "{", "if", "dockerfileName", ",", "err", "=", "filepath", ".", "Abs", "(", "dockerfileName", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "relDockerfile", ",", "err", ":=", "getDockerfileRelPath", "(", "localDir", ",", "dockerfileName", ")", "\n", "return", "localDir", ",", "relDockerfile", ",", "err", "\n", "}" ]

[ "GetContextFromLocalDir", "uses", "the", "given", "local", "directory", "as", "context", "for", "a", "docker", "build", ".", "Returns", "the", "absolute", "path", "to", "the", "local", "context", "directory", "the", "relative", "path", "of", "the", "dockerfile", "in", "that", "context", "directory", "and", "a", "non", "-", "nil", "error", "on", "success", "." ]

[ "func", "ResolveAndValidateContextPath", "(", "givenContextDir", "string", ")", "(", "string", ",", "error", ")", "{", "absContextDir", ",", "err", ":=", "filepath", ".", "Abs", "(", "givenContextDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "givenContextDir", ",", "err", ")", "\n", "}", "\n\n", "// The context dir might be a symbolic link, so follow it to the actual", "// target directory.", "//", "// FIXME. We use isUNC (always false on non-Windows platforms) to workaround", "// an issue in golang. On Windows, EvalSymLinks does not work on UNC file", "// paths (those starting with \\\\). This hack means that when using links", "// on UNC paths, they will not be followed.", "if", "!", "isUNC", "(", "absContextDir", ")", "{", "absContextDir", ",", "err", "=", "filepath", ".", "EvalSymlinks", "(", "absContextDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "stat", ",", "err", ":=", "os", ".", "Lstat", "(", "absContextDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "absContextDir", ",", "err", ")", "\n", "}", "\n\n", "if", "!", "stat", ".", "IsDir", "(", ")", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "absContextDir", ")", "\n", "}", "\n", "return", "absContextDir", ",", "err", "\n", "}" ]

[ "ResolveAndValidateContextPath", "uses", "the", "given", "context", "directory", "for", "a", "docker", "build", "and", "returns", "the", "absolute", "path", "to", "the", "context", "directory", "." ]

[ "func", "getDockerfileRelPath", "(", "absContextDir", ",", "givenDockerfile", "string", ")", "(", "string", ",", "error", ")", "{", "var", "err", "error", "\n\n", "if", "givenDockerfile", "==", "\"", "\"", "{", "return", "givenDockerfile", ",", "nil", "\n", "}", "\n\n", "absDockerfile", ":=", "givenDockerfile", "\n", "if", "absDockerfile", "==", "\"", "\"", "{", "// No -f/--file was specified so use the default relative to the", "// context directory.", "absDockerfile", "=", "filepath", ".", "Join", "(", "absContextDir", ",", "DefaultDockerfileName", ")", "\n\n", "// Just to be nice ;-) look for 'dockerfile' too but only", "// use it if we found it, otherwise ignore this check", "if", "_", ",", "err", "=", "os", ".", "Lstat", "(", "absDockerfile", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "altPath", ":=", "filepath", ".", "Join", "(", "absContextDir", ",", "strings", ".", "ToLower", "(", "DefaultDockerfileName", ")", ")", "\n", "if", "_", ",", "err", "=", "os", ".", "Lstat", "(", "altPath", ")", ";", "err", "==", "nil", "{", "absDockerfile", "=", "altPath", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// If not already an absolute path, the Dockerfile path should be joined to", "// the base directory.", "if", "!", "filepath", ".", "IsAbs", "(", "absDockerfile", ")", "{", "absDockerfile", "=", "filepath", ".", "Join", "(", "absContextDir", ",", "absDockerfile", ")", "\n", "}", "\n\n", "// Evaluate symlinks in the path to the Dockerfile too.", "//", "// FIXME. We use isUNC (always false on non-Windows platforms) to workaround", "// an issue in golang. On Windows, EvalSymLinks does not work on UNC file", "// paths (those starting with \\\\). This hack means that when using links", "// on UNC paths, they will not be followed.", "if", "!", "isUNC", "(", "absDockerfile", ")", "{", "absDockerfile", ",", "err", "=", "filepath", ".", "EvalSymlinks", "(", "absDockerfile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n\n", "}", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "os", ".", "Lstat", "(", "absDockerfile", ")", ";", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "absDockerfile", ")", "\n", "}", "\n", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "relDockerfile", ",", "err", ":=", "filepath", ".", "Rel", "(", "absContextDir", ",", "absDockerfile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "relDockerfile", ",", "nil", "\n", "}" ]

[ "getDockerfileRelPath", "returns", "the", "dockerfile", "path", "relative", "to", "the", "context", "directory" ]

[ "func", "AddDockerfileToBuildContext", "(", "dockerfileCtx", "io", ".", "ReadCloser", ",", "buildCtx", "io", ".", "ReadCloser", ")", "(", "io", ".", "ReadCloser", ",", "string", ",", "error", ")", "{", "file", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "dockerfileCtx", ")", "\n", "dockerfileCtx", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "now", ":=", "time", ".", "Now", "(", ")", "\n", "hdrTmpl", ":=", "&", "tar", ".", "Header", "{", "Mode", ":", "0600", ",", "Uid", ":", "0", ",", "Gid", ":", "0", ",", "ModTime", ":", "now", ",", "Typeflag", ":", "tar", ".", "TypeReg", ",", "AccessTime", ":", "now", ",", "ChangeTime", ":", "now", ",", "}", "\n", "randomName", ":=", "\"", "\"", "+", "stringid", ".", "GenerateRandomID", "(", ")", "[", ":", "20", "]", "\n\n", "buildCtx", "=", "archive", ".", "ReplaceFileTarWrapper", "(", "buildCtx", ",", "map", "[", "string", "]", "archive", ".", "TarModifierFunc", "{", "// Add the dockerfile with a random filename", "randomName", ":", "func", "(", "_", "string", ",", "h", "*", "tar", ".", "Header", ",", "content", "io", ".", "Reader", ")", "(", "*", "tar", ".", "Header", ",", "[", "]", "byte", ",", "error", ")", "{", "return", "hdrTmpl", ",", "file", ",", "nil", "\n", "}", ",", "// Update .dockerignore to include the random filename", "\"", "\"", ":", "func", "(", "_", "string", ",", "h", "*", "tar", ".", "Header", ",", "content", "io", ".", "Reader", ")", "(", "*", "tar", ".", "Header", ",", "[", "]", "byte", ",", "error", ")", "{", "if", "h", "==", "nil", "{", "h", "=", "hdrTmpl", "\n", "}", "\n\n", "b", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "if", "content", "!=", "nil", "{", "if", "_", ",", "err", ":=", "b", ".", "ReadFrom", "(", "content", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}", "else", "{", "b", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n", "b", ".", "WriteString", "(", "\"", "\\n", "\"", "+", "randomName", "+", "\"", "\\n", "\"", ")", "\n", "return", "h", ",", "b", ".", "Bytes", "(", ")", ",", "nil", "\n", "}", ",", "}", ")", "\n", "return", "buildCtx", ",", "randomName", ",", "nil", "\n", "}" ]

[ "AddDockerfileToBuildContext", "from", "a", "ReadCloser", "returns", "a", "new", "archive", "and", "the", "relative", "path", "to", "the", "dockerfile", "in", "the", "context", "." ]

[ "func", "Compress", "(", "buildCtx", "io", ".", "ReadCloser", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "pipeReader", ",", "pipeWriter", ":=", "io", ".", "Pipe", "(", ")", "\n\n", "go", "func", "(", ")", "{", "compressWriter", ",", "err", ":=", "archive", ".", "CompressStream", "(", "pipeWriter", ",", "archive", ".", "Gzip", ")", "\n", "if", "err", "!=", "nil", "{", "pipeWriter", ".", "CloseWithError", "(", "err", ")", "\n", "}", "\n", "defer", "buildCtx", ".", "Close", "(", ")", "\n\n", "if", "_", ",", "err", ":=", "pools", ".", "Copy", "(", "compressWriter", ",", "buildCtx", ")", ";", "err", "!=", "nil", "{", "pipeWriter", ".", "CloseWithError", "(", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", ")", "\n", "compressWriter", ".", "Close", "(", ")", "\n", "return", "\n", "}", "\n", "compressWriter", ".", "Close", "(", ")", "\n", "pipeWriter", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n\n", "return", "pipeReader", ",", "nil", "\n", "}" ]

[ "Compress", "the", "build", "context", "for", "sending", "to", "the", "API" ]

[ "func", "NewSearchCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "options", ":=", "searchOptions", "{", "filter", ":", "opts", ".", "NewFilterOpt", "(", ")", "}", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "ExactArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "options", ".", "term", "=", "args", "[", "0", "]", "\n", "return", "runSearch", "(", "dockerCli", ",", "options", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "flags", ".", "BoolVar", "(", "&", "options", ".", "noTrunc", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "VarP", "(", "&", "options", ".", "filter", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "IntVar", "(", "&", "options", ".", "limit", ",", "\"", "\"", ",", "registry", ".", "DefaultSearchLimit", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "format", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "flags", ".", "BoolVar", "(", "&", "options", ".", "automated", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "UintVarP", "(", "&", "options", ".", "stars", ",", "\"", "\"", ",", "\"", "\"", ",", "0", ",", "\"", "\"", ")", "\n\n", "flags", ".", "MarkDeprecated", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "MarkDeprecated", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewSearchCommand", "creates", "a", "new", "docker", "search", "command" ]

[ "func", "NewImageCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "}", "\n", "cmd", ".", "AddCommand", "(", "NewBuildCommand", "(", "dockerCli", ")", ",", "NewHistoryCommand", "(", "dockerCli", ")", ",", "NewImportCommand", "(", "dockerCli", ")", ",", "NewLoadCommand", "(", "dockerCli", ")", ",", "NewPullCommand", "(", "dockerCli", ")", ",", "NewPushCommand", "(", "dockerCli", ")", ",", "NewSaveCommand", "(", "dockerCli", ")", ",", "NewTagCommand", "(", "dockerCli", ")", ",", "newListCommand", "(", "dockerCli", ")", ",", "newRemoveCommand", "(", "dockerCli", ")", ",", "newInspectCommand", "(", "dockerCli", ")", ",", "NewPruneCommand", "(", "dockerCli", ")", ",", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewImageCommand", "returns", "a", "cobra", "command", "for", "image", "subcommands" ]

[ "func", "NewPauseCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "pauseOptions", "\n\n", "return", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMinArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "containers", "=", "args", "\n", "return", "runPause", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewPauseCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "pause" ]

[ "func", "ListPlugins", "(", "dockerCli", "command", ".", "Cli", ",", "rootcmd", "*", "cobra", ".", "Command", ")", "(", "[", "]", "Plugin", ",", "error", ")", "{", "pluginDirs", ",", "err", ":=", "getPluginDirs", "(", "dockerCli", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "candidates", ",", "err", ":=", "listPluginCandidates", "(", "pluginDirs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "plugins", "[", "]", "Plugin", "\n", "for", "_", ",", "paths", ":=", "range", "candidates", "{", "if", "len", "(", "paths", ")", "==", "0", "{", "continue", "\n", "}", "\n", "c", ":=", "&", "candidate", "{", "paths", "[", "0", "]", "}", "\n", "p", ",", "err", ":=", "newPlugin", "(", "c", ",", "rootcmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "p", ".", "ShadowedPaths", "=", "paths", "[", "1", ":", "]", "\n", "plugins", "=", "append", "(", "plugins", ",", "p", ")", "\n", "}", "\n\n", "return", "plugins", ",", "nil", "\n", "}" ]

[ "ListPlugins", "produces", "a", "list", "of", "the", "plugins", "available", "on", "the", "system" ]

[ "func", "NewContainerFormat", "(", "source", "string", ",", "quiet", "bool", ",", "size", "bool", ")", "Format", "{", "switch", "source", "{", "case", "TableFormatKey", ":", "if", "quiet", "{", "return", "DefaultQuietFormat", "\n", "}", "\n", "format", ":=", "defaultContainerTableFormat", "\n", "if", "size", "{", "format", "+=", "`\\t{{.Size}}`", "\n", "}", "\n", "return", "Format", "(", "format", ")", "\n", "case", "RawFormatKey", ":", "if", "quiet", "{", "return", "`container_id: {{.ID}}`", "\n", "}", "\n", "format", ":=", "`container_id: {{.ID}}\nimage: {{.Image}}\ncommand: {{.Command}}\ncreated_at: {{.CreatedAt}}\nstatus: {{- pad .Status 1 0}}\nnames: {{.Names}}\nlabels: {{- pad .Labels 1 0}}\nports: {{- pad .Ports 1 0}}\n`", "\n", "if", "size", "{", "format", "+=", "`size: {{.Size}}\\n`", "\n", "}", "\n", "return", "Format", "(", "format", ")", "\n", "}", "\n", "return", "Format", "(", "source", ")", "\n", "}" ]

[ "NewContainerFormat", "returns", "a", "Format", "for", "rendering", "using", "a", "Context" ]

[ "func", "ContainerWrite", "(", "ctx", "Context", ",", "containers", "[", "]", "types", ".", "Container", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "container", ":=", "range", "containers", "{", "err", ":=", "format", "(", "&", "containerContext", "{", "trunc", ":", "ctx", ".", "Trunc", ",", "c", ":", "container", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "Write", "(", "newContainerContext", "(", ")", ",", "render", ")", "\n", "}" ]

[ "ContainerWrite", "renders", "the", "context", "for", "a", "list", "of", "containers" ]

[ "func", "(", "s", "*", "stackV1Beta1", ")", "IsColliding", "(", "servicesClient", "corev1", ".", "ServiceInterface", ",", "st", "Stack", ")", "error", "{", "for", "_", ",", "srv", ":=", "range", "st", ".", "getServices", "(", ")", "{", "if", "err", ":=", "verify", "(", "servicesClient", ",", "st", ".", "Name", ",", "srv", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "IsColliding", "verifies", "that", "services", "defined", "in", "the", "stack", "collides", "with", "already", "deployed", "services" ]

[ "func", "(", "s", "*", "stackV1Beta2", ")", "IsColliding", "(", "servicesClient", "corev1", ".", "ServiceInterface", ",", "st", "Stack", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "IsColliding", "is", "handle", "server", "side", "with", "the", "compose", "api", "v1beta2", "so", "nothing", "to", "do", "here" ]

[ "func", "RunConfigRemove", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "RemoveOptions", ")", "error", "{", "client", ":=", "dockerCli", ".", "Client", "(", ")", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n\n", "var", "errs", "[", "]", "string", "\n\n", "for", "_", ",", "name", ":=", "range", "opts", ".", "Names", "{", "if", "err", ":=", "client", ".", "ConfigRemove", "(", "ctx", ",", "name", ")", ";", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ".", "Error", "(", ")", ")", "\n", "continue", "\n", "}", "\n\n", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Out", "(", ")", ",", "name", ")", "\n", "}", "\n\n", "if", "len", "(", "errs", ")", ">", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "errs", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "RunConfigRemove", "removes", "the", "given", "Swarm", "configs", "." ]

[ "func", "(", "r", "repositoryEndpoint", ")", "Name", "(", ")", "string", "{", "repoName", ":=", "r", ".", "info", ".", "Name", ".", "Name", "(", ")", "\n", "// If endpoint does not support CanonicalName, use the RemoteName instead", "if", "r", ".", "endpoint", ".", "TrimHostname", "{", "repoName", "=", "reference", ".", "Path", "(", "r", ".", "info", ".", "Name", ")", "\n", "}", "\n", "return", "repoName", "\n", "}" ]

[ "Name", "returns", "the", "repository", "name" ]

[ "func", "getHTTPTransport", "(", "authConfig", "authtypes", ".", "AuthConfig", ",", "endpoint", "registry", ".", "APIEndpoint", ",", "repoName", "string", ",", "userAgent", "string", ")", "(", "http", ".", "RoundTripper", ",", "error", ")", "{", "// get the http transport, this will be used in a client to upload manifest", "base", ":=", "&", "http", ".", "Transport", "{", "Proxy", ":", "http", ".", "ProxyFromEnvironment", ",", "Dial", ":", "(", "&", "net", ".", "Dialer", "{", "Timeout", ":", "30", "*", "time", ".", "Second", ",", "KeepAlive", ":", "30", "*", "time", ".", "Second", ",", "DualStack", ":", "true", ",", "}", ")", ".", "Dial", ",", "TLSHandshakeTimeout", ":", "10", "*", "time", ".", "Second", ",", "TLSClientConfig", ":", "endpoint", ".", "TLSConfig", ",", "DisableKeepAlives", ":", "true", ",", "}", "\n\n", "modifiers", ":=", "registry", ".", "Headers", "(", "userAgent", ",", "http", ".", "Header", "{", "}", ")", "\n", "authTransport", ":=", "transport", ".", "NewTransport", "(", "base", ",", "modifiers", "...", ")", "\n", "challengeManager", ",", "confirmedV2", ",", "err", ":=", "registry", ".", "PingV2Registry", "(", "endpoint", ".", "URL", ",", "authTransport", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "confirmedV2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "authConfig", ".", "RegistryToken", "!=", "\"", "\"", "{", "passThruTokenHandler", ":=", "&", "existingTokenHandler", "{", "token", ":", "authConfig", ".", "RegistryToken", "}", "\n", "modifiers", "=", "append", "(", "modifiers", ",", "auth", ".", "NewAuthorizer", "(", "challengeManager", ",", "passThruTokenHandler", ")", ")", "\n", "}", "else", "{", "creds", ":=", "registry", ".", "NewStaticCredentialStore", "(", "&", "authConfig", ")", "\n", "tokenHandler", ":=", "auth", ".", "NewTokenHandler", "(", "authTransport", ",", "creds", ",", "repoName", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "basicHandler", ":=", "auth", ".", "NewBasicHandler", "(", "creds", ")", "\n", "modifiers", "=", "append", "(", "modifiers", ",", "auth", ".", "NewAuthorizer", "(", "challengeManager", ",", "tokenHandler", ",", "basicHandler", ")", ")", "\n", "}", "\n", "return", "transport", ".", "NewTransport", "(", "base", ",", "modifiers", "...", ")", ",", "nil", "\n", "}" ]

[ "getHTTPTransport", "builds", "a", "transport", "for", "use", "in", "communicating", "with", "a", "registry" ]

[ "func", "RepoNameForReference", "(", "ref", "reference", ".", "Named", ")", "(", "string", ",", "error", ")", "{", "// insecure is fine since this only returns the name", "repo", ",", "err", ":=", "newDefaultRepositoryEndpoint", "(", "ref", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "repo", ".", "Name", "(", ")", ",", "nil", "\n", "}" ]

[ "RepoNameForReference", "returns", "the", "repository", "name", "from", "a", "reference" ]

[ "func", "LoadFile", "(", "reader", "io", ".", "Reader", ")", "(", "*", "Bundlefile", ",", "error", ")", "{", "bundlefile", ":=", "&", "Bundlefile", "{", "}", "\n\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "reader", ")", "\n", "if", "err", ":=", "decoder", ".", "Decode", "(", "bundlefile", ")", ";", "err", "!=", "nil", "{", "switch", "jsonErr", ":=", "err", ".", "(", "type", ")", "{", "case", "*", "json", ".", "SyntaxError", ":", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "jsonErr", ".", "Offset", ",", "jsonErr", ".", "Error", "(", ")", ")", "\n", "case", "*", "json", ".", "UnmarshalTypeError", ":", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "jsonErr", ".", "Offset", ",", "jsonErr", ".", "Type", ",", "jsonErr", ".", "Value", ")", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "bundlefile", ",", "nil", "\n", "}" ]

[ "LoadFile", "loads", "a", "bundlefile", "from", "a", "path", "to", "the", "file" ]

[ "func", "Print", "(", "out", "io", ".", "Writer", ",", "bundle", "*", "Bundlefile", ")", "error", "{", "bytes", ",", "err", ":=", "json", ".", "MarshalIndent", "(", "*", "bundle", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "out", ".", "Write", "(", "bytes", ")", "\n", "return", "err", "\n", "}" ]

[ "Print", "writes", "the", "contents", "of", "the", "bundlefile", "to", "the", "output", "writer", "as", "human", "readable", "json" ]

[ "func", "DefaultFormat", "(", "configFile", "*", "configfile", ".", "ConfigFile", ",", "quiet", "bool", ")", "string", "{", "if", "len", "(", "configFile", ".", "TasksFormat", ")", ">", "0", "&&", "!", "quiet", "{", "return", "configFile", ".", "TasksFormat", "\n", "}", "\n", "return", "formatter", ".", "TableFormatKey", "\n", "}" ]

[ "DefaultFormat", "returns", "the", "default", "format", "from", "the", "config", "file", "or", "table", "format", "if", "nothing", "is", "set", "in", "the", "config", "." ]

[ "func", "ReadDockerignore", "(", "contextDir", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "excludes", "[", "]", "string", "\n\n", "f", ",", "err", ":=", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "contextDir", ",", "\"", "\"", ")", ")", "\n", "switch", "{", "case", "os", ".", "IsNotExist", "(", "err", ")", ":", "return", "excludes", ",", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "return", "dockerignore", ".", "ReadAll", "(", "f", ")", "\n", "}" ]

[ "ReadDockerignore", "reads", "the", ".", "dockerignore", "file", "in", "the", "context", "directory", "and", "returns", "the", "list", "of", "paths", "to", "exclude" ]

[ "func", "TrimBuildFilesFromExcludes", "(", "excludes", "[", "]", "string", ",", "dockerfile", "string", ",", "dockerfileFromStdin", "bool", ")", "[", "]", "string", "{", "if", "keep", ",", "_", ":=", "fileutils", ".", "Matches", "(", "\"", "\"", ",", "excludes", ")", ";", "keep", "{", "excludes", "=", "append", "(", "excludes", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "keep", ",", "_", ":=", "fileutils", ".", "Matches", "(", "dockerfile", ",", "excludes", ")", ";", "keep", "&&", "!", "dockerfileFromStdin", "{", "excludes", "=", "append", "(", "excludes", ",", "\"", "\"", "+", "dockerfile", ")", "\n", "}", "\n", "return", "excludes", "\n", "}" ]

[ "TrimBuildFilesFromExcludes", "removes", "the", "named", "Dockerfile", "and", ".", "dockerignore", "from", "the", "list", "of", "excluded", "files", ".", "The", "daemon", "will", "remove", "them", "from", "the", "final", "context", "but", "they", "must", "be", "in", "available", "in", "the", "context", "when", "passed", "to", "the", "API", "." ]

[ "func", "newTrustSignerCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "}", "\n", "cmd", ".", "AddCommand", "(", "newSignerAddCommand", "(", "dockerCli", ")", ",", "newSignerRemoveCommand", "(", "dockerCli", ")", ",", ")", "\n", "return", "cmd", "\n", "}" ]

[ "newTrustSignerCommand", "returns", "a", "cobra", "command", "for", "trust", "signer", "subcommands" ]

[ "func", "ParseSecrets", "(", "client", "client", ".", "SecretAPIClient", ",", "requestedSecrets", "[", "]", "*", "swarmtypes", ".", "SecretReference", ")", "(", "[", "]", "*", "swarmtypes", ".", "SecretReference", ",", "error", ")", "{", "if", "len", "(", "requestedSecrets", ")", "==", "0", "{", "return", "[", "]", "*", "swarmtypes", ".", "SecretReference", "{", "}", ",", "nil", "\n", "}", "\n\n", "secretRefs", ":=", "make", "(", "map", "[", "string", "]", "*", "swarmtypes", ".", "SecretReference", ")", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n\n", "for", "_", ",", "secret", ":=", "range", "requestedSecrets", "{", "if", "_", ",", "exists", ":=", "secretRefs", "[", "secret", ".", "File", ".", "Name", "]", ";", "exists", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "secret", ".", "SecretName", ")", "\n", "}", "\n", "secretRef", ":=", "new", "(", "swarmtypes", ".", "SecretReference", ")", "\n", "*", "secretRef", "=", "*", "secret", "\n", "secretRefs", "[", "secret", ".", "File", ".", "Name", "]", "=", "secretRef", "\n", "}", "\n\n", "args", ":=", "filters", ".", "NewArgs", "(", ")", "\n", "for", "_", ",", "s", ":=", "range", "secretRefs", "{", "args", ".", "Add", "(", "\"", "\"", ",", "s", ".", "SecretName", ")", "\n", "}", "\n\n", "secrets", ",", "err", ":=", "client", ".", "SecretList", "(", "ctx", ",", "types", ".", "SecretListOptions", "{", "Filters", ":", "args", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "foundSecrets", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "secret", ":=", "range", "secrets", "{", "foundSecrets", "[", "secret", ".", "Spec", ".", "Annotations", ".", "Name", "]", "=", "secret", ".", "ID", "\n", "}", "\n\n", "addedSecrets", ":=", "[", "]", "*", "swarmtypes", ".", "SecretReference", "{", "}", "\n\n", "for", "_", ",", "ref", ":=", "range", "secretRefs", "{", "id", ",", "ok", ":=", "foundSecrets", "[", "ref", ".", "SecretName", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "ref", ".", "SecretName", ")", "\n", "}", "\n\n", "// set the id for the ref to properly assign in swarm", "// since swarm needs the ID instead of the name", "ref", ".", "SecretID", "=", "id", "\n", "addedSecrets", "=", "append", "(", "addedSecrets", ",", "ref", ")", "\n", "}", "\n\n", "return", "addedSecrets", ",", "nil", "\n", "}" ]

[ "ParseSecrets", "retrieves", "the", "secrets", "with", "the", "requested", "names", "and", "fills", "secret", "IDs", "into", "the", "secret", "references", "." ]

[ "func", "RunCreate", "(", "cli", "command", ".", "Cli", ",", "o", "*", "CreateOptions", ")", "error", "{", "s", ":=", "cli", ".", "ContextStore", "(", ")", "\n", "if", "err", ":=", "checkContextNameForCreation", "(", "s", ",", "o", ".", "Name", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "stackOrchestrator", ",", "err", ":=", "command", ".", "NormalizeOrchestrator", "(", "o", ".", "DefaultStackOrchestrator", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "o", ".", "From", "==", "\"", "\"", "&&", "o", ".", "Docker", "==", "nil", "&&", "o", ".", "Kubernetes", "==", "nil", "{", "return", "createFromExistingContext", "(", "s", ",", "cli", ".", "CurrentContext", "(", ")", ",", "stackOrchestrator", ",", "o", ")", "\n", "}", "\n", "if", "o", ".", "From", "!=", "\"", "\"", "{", "return", "createFromExistingContext", "(", "s", ",", "o", ".", "From", ",", "stackOrchestrator", ",", "o", ")", "\n", "}", "\n", "return", "createNewContext", "(", "o", ",", "stackOrchestrator", ",", "cli", ",", "s", ")", "\n", "}" ]

[ "RunCreate", "creates", "a", "Docker", "context" ]

[ "func", "NewRmCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "rmOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMinArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "containers", "=", "args", "\n", "return", "runRm", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "rmVolumes", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "rmLink", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "force", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewRmCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "rm" ]

[ "func", "GetServicesStatus", "(", "services", "[", "]", "swarm", ".", "Service", ",", "nodes", "[", "]", "swarm", ".", "Node", ",", "tasks", "[", "]", "swarm", ".", "Task", ")", "map", "[", "string", "]", "ListInfo", "{", "running", ":=", "map", "[", "string", "]", "int", "{", "}", "\n", "tasksNoShutdown", ":=", "map", "[", "string", "]", "int", "{", "}", "\n\n", "activeNodes", ":=", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", "\n", "for", "_", ",", "n", ":=", "range", "nodes", "{", "if", "n", ".", "Status", ".", "State", "!=", "swarm", ".", "NodeStateDown", "{", "activeNodes", "[", "n", ".", "ID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "task", ":=", "range", "tasks", "{", "if", "task", ".", "DesiredState", "!=", "swarm", ".", "TaskStateShutdown", "{", "tasksNoShutdown", "[", "task", ".", "ServiceID", "]", "++", "\n", "}", "\n\n", "if", "_", ",", "nodeActive", ":=", "activeNodes", "[", "task", ".", "NodeID", "]", ";", "nodeActive", "&&", "task", ".", "Status", ".", "State", "==", "swarm", ".", "TaskStateRunning", "{", "running", "[", "task", ".", "ServiceID", "]", "++", "\n", "}", "\n", "}", "\n\n", "info", ":=", "map", "[", "string", "]", "ListInfo", "{", "}", "\n", "for", "_", ",", "service", ":=", "range", "services", "{", "info", "[", "service", ".", "ID", "]", "=", "ListInfo", "{", "}", "\n", "if", "service", ".", "Spec", ".", "Mode", ".", "Replicated", "!=", "nil", "&&", "service", ".", "Spec", ".", "Mode", ".", "Replicated", ".", "Replicas", "!=", "nil", "{", "if", "service", ".", "Spec", ".", "TaskTemplate", ".", "Placement", "!=", "nil", "&&", "service", ".", "Spec", ".", "TaskTemplate", ".", "Placement", ".", "MaxReplicas", ">", "0", "{", "info", "[", "service", ".", "ID", "]", "=", "ListInfo", "{", "Mode", ":", "\"", "\"", ",", "Replicas", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "running", "[", "service", ".", "ID", "]", ",", "*", "service", ".", "Spec", ".", "Mode", ".", "Replicated", ".", "Replicas", ",", "service", ".", "Spec", ".", "TaskTemplate", ".", "Placement", ".", "MaxReplicas", ")", ",", "}", "\n", "}", "else", "{", "info", "[", "service", ".", "ID", "]", "=", "ListInfo", "{", "Mode", ":", "\"", "\"", ",", "Replicas", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "running", "[", "service", ".", "ID", "]", ",", "*", "service", ".", "Spec", ".", "Mode", ".", "Replicated", ".", "Replicas", ")", ",", "}", "\n", "}", "\n", "}", "else", "if", "service", ".", "Spec", ".", "Mode", ".", "Global", "!=", "nil", "{", "info", "[", "service", ".", "ID", "]", "=", "ListInfo", "{", "Mode", ":", "\"", "\"", ",", "Replicas", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "running", "[", "service", ".", "ID", "]", ",", "tasksNoShutdown", "[", "service", ".", "ID", "]", ")", ",", "}", "\n", "}", "\n", "}", "\n", "return", "info", "\n", "}" ]

[ "GetServicesStatus", "returns", "a", "map", "of", "mode", "and", "replicas" ]

[ "func", "(", "e", "*", "pluginError", ")", "MarshalText", "(", ")", "(", "text", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "[", "]", "byte", "(", "e", ".", "cause", ".", "Error", "(", ")", ")", ",", "nil", "\n", "}" ]

[ "MarshalText", "marshalls", "the", "pluginError", "into", "a", "textual", "form", "." ]

[ "func", "wrapAsPluginError", "(", "err", "error", ",", "msg", "string", ")", "error", "{", "return", "&", "pluginError", "{", "cause", ":", "errors", ".", "Wrap", "(", "err", ",", "msg", ")", "}", "\n", "}" ]

[ "wrapAsPluginError", "wraps", "an", "error", "in", "a", "pluginError", "with", "an", "additional", "message", "analogous", "to", "errors", ".", "Wrapf", "." ]

[ "func", "NewPluginError", "(", "msg", "string", ",", "args", "...", "interface", "{", "}", ")", "error", "{", "return", "&", "pluginError", "{", "cause", ":", "errors", ".", "Errorf", "(", "msg", ",", "args", "...", ")", "}", "\n", "}" ]

[ "NewPluginError", "creates", "a", "new", "pluginError", "analogous", "to", "errors", ".", "Errorf", "." ]

[ "func", "resizeTtyTo", "(", "ctx", "context", ".", "Context", ",", "client", "client", ".", "ContainerAPIClient", ",", "id", "string", ",", "height", ",", "width", "uint", ",", "isExec", "bool", ")", "error", "{", "if", "height", "==", "0", "&&", "width", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "options", ":=", "types", ".", "ResizeOptions", "{", "Height", ":", "height", ",", "Width", ":", "width", ",", "}", "\n\n", "var", "err", "error", "\n", "if", "isExec", "{", "err", "=", "client", ".", "ContainerExecResize", "(", "ctx", ",", "id", ",", "options", ")", "\n", "}", "else", "{", "err", "=", "client", ".", "ContainerResize", "(", "ctx", ",", "id", ",", "options", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Debugf", "(", "\"", "\\r", "\"", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "resizeTtyTo", "resizes", "tty", "to", "specific", "height", "and", "width" ]

[ "func", "resizeTty", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "id", "string", ",", "isExec", "bool", ")", "error", "{", "height", ",", "width", ":=", "cli", ".", "Out", "(", ")", ".", "GetTtySize", "(", ")", "\n", "return", "resizeTtyTo", "(", "ctx", ",", "cli", ".", "Client", "(", ")", ",", "id", ",", "height", ",", "width", ",", "isExec", ")", "\n", "}" ]

[ "resizeTty", "is", "to", "resize", "the", "tty", "with", "cli", "out", "s", "tty", "size" ]

[ "func", "initTtySize", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "id", "string", ",", "isExec", "bool", ",", "resizeTtyFunc", "func", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "id", "string", ",", "isExec", "bool", ")", "error", ")", "{", "rttyFunc", ":=", "resizeTtyFunc", "\n", "if", "rttyFunc", "==", "nil", "{", "rttyFunc", "=", "resizeTty", "\n", "}", "\n", "if", "err", ":=", "rttyFunc", "(", "ctx", ",", "cli", ",", "id", ",", "isExec", ")", ";", "err", "!=", "nil", "{", "go", "func", "(", ")", "{", "var", "err", "error", "\n", "for", "retry", ":=", "0", ";", "retry", "<", "5", ";", "retry", "++", "{", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "if", "err", "=", "rttyFunc", "(", "ctx", ",", "cli", ",", "id", ",", "isExec", ")", ";", "err", "==", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "cli", ".", "Err", "(", ")", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "initTtySize", "is", "to", "init", "the", "tty", "s", "size", "to", "the", "same", "as", "the", "window", "if", "there", "is", "an", "error", "it", "will", "retry", "5", "times", "." ]

[ "func", "MonitorTtySize", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "id", "string", ",", "isExec", "bool", ")", "error", "{", "initTtySize", "(", "ctx", ",", "cli", ",", "id", ",", "isExec", ",", "resizeTty", ")", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "go", "func", "(", ")", "{", "prevH", ",", "prevW", ":=", "cli", ".", "Out", "(", ")", ".", "GetTtySize", "(", ")", "\n", "for", "{", "time", ".", "Sleep", "(", "time", ".", "Millisecond", "*", "250", ")", "\n", "h", ",", "w", ":=", "cli", ".", "Out", "(", ")", ".", "GetTtySize", "(", ")", "\n\n", "if", "prevW", "!=", "w", "||", "prevH", "!=", "h", "{", "resizeTty", "(", "ctx", ",", "cli", ",", "id", ",", "isExec", ")", "\n", "}", "\n", "prevH", "=", "h", "\n", "prevW", "=", "w", "\n", "}", "\n", "}", "(", ")", "\n", "}", "else", "{", "sigchan", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "gosignal", ".", "Notify", "(", "sigchan", ",", "signal", ".", "SIGWINCH", ")", "\n", "go", "func", "(", ")", "{", "for", "range", "sigchan", "{", "resizeTty", "(", "ctx", ",", "cli", ",", "id", ",", "isExec", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "MonitorTtySize", "updates", "the", "container", "tty", "size", "when", "the", "terminal", "tty", "changes", "size" ]

[ "func", "ForwardAllSignals", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "cid", "string", ")", "chan", "os", ".", "Signal", "{", "sigc", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "128", ")", "\n", "signal", ".", "CatchAll", "(", "sigc", ")", "\n", "go", "func", "(", ")", "{", "for", "s", ":=", "range", "sigc", "{", "if", "s", "==", "signal", ".", "SIGCHLD", "||", "s", "==", "signal", ".", "SIGPIPE", "{", "continue", "\n", "}", "\n", "var", "sig", "string", "\n", "for", "sigStr", ",", "sigN", ":=", "range", "signal", ".", "SignalMap", "{", "if", "sigN", "==", "s", "{", "sig", "=", "sigStr", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "sig", "==", "\"", "\"", "{", "fmt", ".", "Fprintf", "(", "cli", ".", "Err", "(", ")", ",", "\"", "\\n", "\"", ",", "s", ")", "\n", "continue", "\n", "}", "\n\n", "if", "err", ":=", "cli", ".", "Client", "(", ")", ".", "ContainerKill", "(", "ctx", ",", "cid", ",", "sig", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "sigc", "\n", "}" ]

[ "ForwardAllSignals", "forwards", "signals", "to", "the", "container" ]

[ "func", "(", "cs", "*", "Stats", ")", "GetError", "(", ")", "error", "{", "cs", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cs", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "cs", ".", "err", "\n", "}" ]

[ "GetError", "returns", "the", "container", "statistics", "error", ".", "This", "is", "used", "to", "determine", "whether", "the", "statistics", "are", "valid", "or", "not" ]

[ "func", "(", "cs", "*", "Stats", ")", "SetErrorAndReset", "(", "err", "error", ")", "{", "cs", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cs", ".", "mutex", ".", "Unlock", "(", ")", "\n", "cs", ".", "CPUPercentage", "=", "0", "\n", "cs", ".", "Memory", "=", "0", "\n", "cs", ".", "MemoryPercentage", "=", "0", "\n", "cs", ".", "MemoryLimit", "=", "0", "\n", "cs", ".", "NetworkRx", "=", "0", "\n", "cs", ".", "NetworkTx", "=", "0", "\n", "cs", ".", "BlockRead", "=", "0", "\n", "cs", ".", "BlockWrite", "=", "0", "\n", "cs", ".", "PidsCurrent", "=", "0", "\n", "cs", ".", "err", "=", "err", "\n", "cs", ".", "IsInvalid", "=", "true", "\n", "}" ]

[ "SetErrorAndReset", "zeroes", "all", "the", "container", "statistics", "and", "store", "the", "error", ".", "It", "is", "used", "when", "receiving", "time", "out", "error", "during", "statistics", "collecting", "to", "reduce", "lock", "overhead" ]

[ "func", "(", "cs", "*", "Stats", ")", "SetError", "(", "err", "error", ")", "{", "cs", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cs", ".", "mutex", ".", "Unlock", "(", ")", "\n", "cs", ".", "err", "=", "err", "\n", "if", "err", "!=", "nil", "{", "cs", ".", "IsInvalid", "=", "true", "\n", "}", "\n", "}" ]

[ "SetError", "sets", "container", "statistics", "error" ]

[ "func", "(", "cs", "*", "Stats", ")", "SetStatistics", "(", "s", "StatsEntry", ")", "{", "cs", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cs", ".", "mutex", ".", "Unlock", "(", ")", "\n", "s", ".", "Container", "=", "cs", ".", "Container", "\n", "cs", ".", "StatsEntry", "=", "s", "\n", "}" ]

[ "SetStatistics", "set", "the", "container", "statistics" ]

[ "func", "(", "cs", "*", "Stats", ")", "GetStatistics", "(", ")", "StatsEntry", "{", "cs", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cs", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "cs", ".", "StatsEntry", "\n", "}" ]

[ "GetStatistics", "returns", "container", "statistics", "with", "other", "meta", "data", "such", "as", "the", "container", "name" ]

[ "func", "NewStatsFormat", "(", "source", ",", "osType", "string", ")", "formatter", ".", "Format", "{", "if", "source", "==", "formatter", ".", "TableFormatKey", "{", "if", "osType", "==", "winOSType", "{", "return", "formatter", ".", "Format", "(", "winDefaultStatsTableFormat", ")", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "defaultStatsTableFormat", ")", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

[ "NewStatsFormat", "returns", "a", "format", "for", "rendering", "an", "CStatsContext" ]

[ "func", "statsFormatWrite", "(", "ctx", "formatter", ".", "Context", ",", "Stats", "[", "]", "StatsEntry", ",", "osType", "string", ",", "trunc", "bool", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "cstats", ":=", "range", "Stats", "{", "statsCtx", ":=", "&", "statsContext", "{", "s", ":", "cstats", ",", "os", ":", "osType", ",", "trunc", ":", "trunc", ",", "}", "\n", "if", "err", ":=", "format", "(", "statsCtx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "memUsage", ":=", "memUseHeader", "\n", "if", "osType", "==", "winOSType", "{", "memUsage", "=", "winMemUseHeader", "\n", "}", "\n", "statsCtx", ":=", "statsContext", "{", "}", "\n", "statsCtx", ".", "Header", "=", "formatter", ".", "SubHeaderContext", "{", "\"", "\"", ":", "containerHeader", ",", "\"", "\"", ":", "formatter", ".", "NameHeader", ",", "\"", "\"", ":", "formatter", ".", "ContainerIDHeader", ",", "\"", "\"", ":", "cpuPercHeader", ",", "\"", "\"", ":", "memUsage", ",", "\"", "\"", ":", "memPercHeader", ",", "\"", "\"", ":", "netIOHeader", ",", "\"", "\"", ":", "blockIOHeader", ",", "\"", "\"", ":", "pidsHeader", ",", "}", "\n", "statsCtx", ".", "os", "=", "osType", "\n", "return", "ctx", ".", "Write", "(", "&", "statsCtx", ",", "render", ")", "\n", "}" ]

[ "statsFormatWrite", "renders", "the", "context", "for", "a", "list", "of", "containers", "statistics" ]

[ "func", "NewLogsCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "logsOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "ExactArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "container", "=", "args", "[", "0", "]", "\n", "return", "runLogs", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "follow", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "opts", ".", "since", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "opts", ".", "until", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "timestamps", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "opts", ".", "details", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "opts", ".", "tail", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewLogsCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "logs" ]

[ "func", "WithNewSnapshot", "(", "i", "containerd", ".", "Image", ")", "containerd", ".", "NewContainerOpts", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "client", "*", "containerd", ".", "Client", ",", "c", "*", "containers", ".", "Container", ")", "error", "{", "if", "c", ".", "Snapshotter", "==", "\"", "\"", "{", "c", ".", "Snapshotter", "=", "containerd", ".", "DefaultSnapshotter", "\n", "}", "\n", "r", ",", "err", ":=", "create", "(", "ctx", ",", "client", ",", "i", ",", "c", ".", "ID", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "SnapshotKey", "=", "r", ".", "Key", "\n", "c", ".", "Image", "=", "i", ".", "Name", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithNewSnapshot", "creates", "a", "new", "snapshot", "managed", "by", "containerized" ]

[ "func", "WithUpgrade", "(", "i", "containerd", ".", "Image", ")", "containerd", ".", "UpdateContainerOpts", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "client", "*", "containerd", ".", "Client", ",", "c", "*", "containers", ".", "Container", ")", "error", "{", "revision", ",", "err", ":=", "save", "(", "ctx", ",", "client", ",", "i", ",", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "Image", "=", "i", ".", "Name", "(", ")", "\n", "c", ".", "SnapshotKey", "=", "revision", ".", "Key", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithUpgrade", "upgrades", "an", "existing", "container", "s", "image", "to", "a", "new", "one" ]

[ "func", "WithRollback", "(", "ctx", "context", ".", "Context", ",", "client", "*", "containerd", ".", "Client", ",", "c", "*", "containers", ".", "Container", ")", "error", "{", "prev", ",", "err", ":=", "previous", "(", "ctx", ",", "client", ",", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "ss", ":=", "client", ".", "SnapshotService", "(", "c", ".", "Snapshotter", ")", "\n", "sInfo", ",", "err", ":=", "ss", ".", "Stat", "(", "ctx", ",", "prev", ".", "Key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "snapshotImage", ",", "ok", ":=", "sInfo", ".", "Labels", "[", "imageLabel", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "prev", ".", "Key", ")", "\n", "}", "\n", "if", "snapshotImage", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "prev", ".", "Key", ")", "\n", "}", "\n", "c", ".", "Image", "=", "snapshotImage", "\n", "c", ".", "SnapshotKey", "=", "prev", ".", "Key", "\n", "return", "nil", "\n", "}" ]

[ "WithRollback", "rolls", "back", "to", "the", "previous", "container", "s", "revision" ]