Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "NewBuilderCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "Annotations", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", "}", ",", "}", "\n", "cmd", ".", "AddCommand", "(", "NewPruneCommand", "(", "dockerCli", ")", ",", "image", ".", "NewBuildCommand", "(", "dockerCli", ")", ",", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewBuilderCommand", "returns", "a", "cobra", "command", "for", "builder", "subcommands" ]

[ "func", "RunRemove", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "RemoveOptions", ",", "names", "[", "]", "string", ")", "error", "{", "var", "errs", "[", "]", "string", "\n", "currentCtx", ":=", "dockerCli", ".", "CurrentContext", "(", ")", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "if", "name", "==", "\"", "\"", "{", "errs", "=", "append", "(", "errs", ",", "`default: context \"default\" cannot be removed`", ")", "\n", "}", "else", "if", "err", ":=", "doRemove", "(", "dockerCli", ",", "name", ",", "name", "==", "currentCtx", ",", "opts", ".", "Force", ")", ";", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ",", "err", ")", ")", "\n", "}", "else", "{", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Out", "(", ")", ",", "name", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "errs", ")", ">", "0", "{", "return", "errors", ".", "New", "(", "strings", ".", "Join", "(", "errs", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RunRemove", "removes", "one", "or", "more", "contexts" ]

[ "func", "NewRenameCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "renameOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "ExactArgs", "(", "2", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "oldName", "=", "args", "[", "0", "]", "\n", "opts", ".", "newName", "=", "args", "[", "1", "]", "\n", "return", "runRename", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n", "return", "cmd", "\n", "}" ]

[ "NewRenameCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "rename" ]

[ "func", "GetStackOrchestrator", "(", "flagValue", ",", "contextValue", ",", "globalDefault", "string", ",", "stderr", "io", ".", "Writer", ")", "(", "Orchestrator", ",", "error", ")", "{", "// Check flag", "if", "o", ",", "err", ":=", "normalize", "(", "flagValue", ")", ";", "o", "!=", "orchestratorUnset", "{", "return", "o", ",", "err", "\n", "}", "\n", "// Check environment variable", "env", ":=", "os", ".", "Getenv", "(", "envVarDockerStackOrchestrator", ")", "\n", "if", "env", "==", "\"", "\"", "&&", "os", ".", "Getenv", "(", "envVarDockerOrchestrator", ")", "!=", "\"", "\"", "{", "fmt", ".", "Fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "envVarDockerOrchestrator", ",", "envVarDockerStackOrchestrator", ")", "\n", "}", "\n", "if", "o", ",", "err", ":=", "normalize", "(", "env", ")", ";", "o", "!=", "orchestratorUnset", "{", "return", "o", ",", "err", "\n", "}", "\n", "if", "o", ",", "err", ":=", "normalize", "(", "contextValue", ")", ";", "o", "!=", "orchestratorUnset", "{", "return", "o", ",", "err", "\n", "}", "\n", "if", "o", ",", "err", ":=", "normalize", "(", "globalDefault", ")", ";", "o", "!=", "orchestratorUnset", "{", "return", "o", ",", "err", "\n", "}", "\n", "// Nothing set, use default orchestrator", "return", "defaultOrchestrator", ",", "nil", "\n", "}" ]

[ "GetStackOrchestrator", "checks", "DOCKER_STACK_ORCHESTRATOR", "environment", "variable", "and", "configuration", "file", "orchestrator", "value", "and", "returns", "user", "defined", "Orchestrator", "." ]

[ "func", "(", "o", "*", "Out", ")", "GetTtySize", "(", ")", "(", "uint", ",", "uint", ")", "{", "if", "!", "o", ".", "isTerminal", "{", "return", "0", ",", "0", "\n", "}", "\n", "ws", ",", "err", ":=", "term", ".", "GetWinsize", "(", "o", ".", "fd", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "if", "ws", "==", "nil", "{", "return", "0", ",", "0", "\n", "}", "\n", "}", "\n", "return", "uint", "(", "ws", ".", "Height", ")", ",", "uint", "(", "ws", ".", "Width", ")", "\n", "}" ]

[ "GetTtySize", "returns", "the", "height", "and", "width", "in", "characters", "of", "the", "tty" ]

[ "func", "NewOut", "(", "out", "io", ".", "Writer", ")", "*", "Out", "{", "fd", ",", "isTerminal", ":=", "term", ".", "GetFdInfo", "(", "out", ")", "\n", "return", "&", "Out", "{", "commonStream", ":", "commonStream", "{", "fd", ":", "fd", ",", "isTerminal", ":", "isTerminal", "}", ",", "out", ":", "out", "}", "\n", "}" ]

[ "NewOut", "returns", "a", "new", "Out", "object", "from", "a", "Writer" ]

[ "func", "GetUnsupportedProperties", "(", "configDicts", "...", "map", "[", "string", "]", "interface", "{", "}", ")", "[", "]", "string", "{", "unsupported", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n\n", "for", "_", ",", "configDict", ":=", "range", "configDicts", "{", "for", "_", ",", "service", ":=", "range", "getServices", "(", "configDict", ")", "{", "serviceDict", ":=", "service", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "_", ",", "property", ":=", "range", "types", ".", "UnsupportedProperties", "{", "if", "_", ",", "isSet", ":=", "serviceDict", "[", "property", "]", ";", "isSet", "{", "unsupported", "[", "property", "]", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "sortedKeys", "(", "unsupported", ")", "\n", "}" ]

[ "GetUnsupportedProperties", "returns", "the", "list", "of", "any", "unsupported", "properties", "that", "are", "used", "in", "the", "Compose", "files", "." ]

[ "func", "GetDeprecatedProperties", "(", "configDicts", "...", "map", "[", "string", "]", "interface", "{", "}", ")", "map", "[", "string", "]", "string", "{", "deprecated", ":=", "map", "[", "string", "]", "string", "{", "}", "\n\n", "for", "_", ",", "configDict", ":=", "range", "configDicts", "{", "deprecatedProperties", ":=", "getProperties", "(", "getServices", "(", "configDict", ")", ",", "types", ".", "DeprecatedProperties", ")", "\n", "for", "key", ",", "value", ":=", "range", "deprecatedProperties", "{", "deprecated", "[", "key", "]", "=", "value", "\n", "}", "\n", "}", "\n\n", "return", "deprecated", "\n", "}" ]

[ "GetDeprecatedProperties", "returns", "the", "list", "of", "any", "deprecated", "properties", "that", "are", "used", "in", "the", "compose", "files", "." ]

[ "func", "Transform", "(", "source", "interface", "{", "}", ",", "target", "interface", "{", "}", ",", "additionalTransformers", "...", "Transformer", ")", "error", "{", "data", ":=", "mapstructure", ".", "Metadata", "{", "}", "\n", "config", ":=", "&", "mapstructure", ".", "DecoderConfig", "{", "DecodeHook", ":", "mapstructure", ".", "ComposeDecodeHookFunc", "(", "createTransformHook", "(", "additionalTransformers", "...", ")", ",", "mapstructure", ".", "StringToTimeDurationHookFunc", "(", ")", ")", ",", "Result", ":", "target", ",", "Metadata", ":", "&", "data", ",", "}", "\n", "decoder", ",", "err", ":=", "mapstructure", ".", "NewDecoder", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "decoder", ".", "Decode", "(", "source", ")", "\n", "}" ]

[ "Transform", "converts", "the", "source", "into", "the", "target", "struct", "with", "compose", "types", "transformer", "and", "the", "specified", "transformers", "if", "any", "." ]

[ "func", "convertToStringKeysRecursive", "(", "value", "interface", "{", "}", ",", "keyPrefix", "string", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "mapping", ",", "ok", ":=", "value", ".", "(", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", ")", ";", "ok", "{", "dict", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "key", ",", "entry", ":=", "range", "mapping", "{", "str", ",", "ok", ":=", "key", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "formatInvalidKeyError", "(", "keyPrefix", ",", "key", ")", "\n", "}", "\n", "var", "newKeyPrefix", "string", "\n", "if", "keyPrefix", "==", "\"", "\"", "{", "newKeyPrefix", "=", "str", "\n", "}", "else", "{", "newKeyPrefix", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "keyPrefix", ",", "str", ")", "\n", "}", "\n", "convertedEntry", ",", "err", ":=", "convertToStringKeysRecursive", "(", "entry", ",", "newKeyPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "dict", "[", "str", "]", "=", "convertedEntry", "\n", "}", "\n", "return", "dict", ",", "nil", "\n", "}", "\n", "if", "list", ",", "ok", ":=", "value", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "var", "convertedList", "[", "]", "interface", "{", "}", "\n", "for", "index", ",", "entry", ":=", "range", "list", "{", "newKeyPrefix", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "keyPrefix", ",", "index", ")", "\n", "convertedEntry", ",", "err", ":=", "convertToStringKeysRecursive", "(", "entry", ",", "newKeyPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "convertedList", "=", "append", "(", "convertedList", ",", "convertedEntry", ")", "\n", "}", "\n", "return", "convertedList", ",", "nil", "\n", "}", "\n", "return", "value", ",", "nil", "\n", "}" ]

[ "keys", "needs", "to", "be", "converted", "to", "strings", "for", "jsonschema" ]

[ "func", "RunDeploy", "(", "dockerCli", "*", "KubeCli", ",", "opts", "options", ".", "Deploy", ",", "cfg", "*", "composetypes", ".", "Config", ")", "error", "{", "cmdOut", ":=", "dockerCli", ".", "Out", "(", ")", "\n\n", "// Initialize clients", "composeClient", ",", "err", ":=", "dockerCli", ".", "composeClient", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "stacks", ",", "err", ":=", "composeClient", ".", "Stacks", "(", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "stack", ",", "err", ":=", "stacks", ".", "FromCompose", "(", "dockerCli", ".", "Err", "(", ")", ",", "opts", ".", "Namespace", ",", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "configMaps", ":=", "composeClient", ".", "ConfigMaps", "(", ")", "\n", "secrets", ":=", "composeClient", ".", "Secrets", "(", ")", "\n", "services", ":=", "composeClient", ".", "Services", "(", ")", "\n\n", "if", "err", ":=", "stacks", ".", "IsColliding", "(", "services", ",", "stack", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "createResources", "(", "stack", ",", "stacks", ",", "configMaps", ",", "secrets", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "fmt", ".", "Fprintln", "(", "cmdOut", ",", "\"", "\"", ")", "\n", "v1beta1Cli", ",", "err", ":=", "dockerCli", ".", "stacksv1beta1", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "pods", ":=", "composeClient", ".", "Pods", "(", ")", "\n", "watcher", ":=", "&", "deployWatcher", "{", "stacks", ":", "v1beta1Cli", ",", "pods", ":", "pods", ",", "}", "\n", "statusUpdates", ":=", "make", "(", "chan", "serviceStatus", ")", "\n", "displayDone", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "go", "func", "(", ")", "{", "defer", "close", "(", "displayDone", ")", "\n", "display", ":=", "newStatusDisplay", "(", "dockerCli", ".", "Out", "(", ")", ")", "\n", "for", "status", ":=", "range", "statusUpdates", "{", "display", ".", "OnStatus", "(", "status", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "err", "=", "watcher", ".", "Watch", "(", "stack", ".", "Name", ",", "stack", ".", "getServices", "(", ")", ",", "statusUpdates", ")", "\n", "close", "(", "statusUpdates", ")", "\n", "<-", "displayDone", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "cmdOut", ",", "\"", "\\n", "\\n", "\\n", "\"", ",", "stack", ".", "Name", ")", "\n", "return", "nil", "\n\n", "}" ]

[ "RunDeploy", "is", "the", "kubernetes", "implementation", "of", "docker", "stack", "deploy" ]

[ "func", "RunPrune", "(", "dockerCli", "command", ".", "Cli", ",", "all", "bool", ",", "filter", "opts", ".", "FilterOpt", ")", "(", "uint64", ",", "string", ",", "error", ")", "{", "output", ",", "err", ":=", "runPrune", "(", "dockerCli", ",", "pruneOptions", "{", "force", ":", "true", ",", "filter", ":", "filter", "}", ")", "\n", "return", "0", ",", "output", ",", "err", "\n", "}" ]

[ "RunPrune", "calls", "the", "Network", "Prune", "API", "This", "returns", "the", "amount", "of", "space", "reclaimed", "and", "a", "detailed", "output", "string" ]

[ "func", "NewImagesCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "options", ":=", "imagesOptions", "{", "filter", ":", "opts", ".", "NewFilterOpt", "(", ")", "}", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMaxArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "if", "len", "(", "args", ")", ">", "0", "{", "options", ".", "matchName", "=", "args", "[", "0", "]", "\n", "}", "\n", "return", "runImages", "(", "dockerCli", ",", "options", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "quiet", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "all", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "options", ".", "noTrunc", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "options", ".", "showDigests", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "format", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "VarP", "(", "&", "options", ".", "filter", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewImagesCommand", "creates", "a", "new", "docker", "images", "command" ]

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

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

[ "func", "InspectFormatWrite", "(", "ctx", "formatter", ".", "Context", ",", "refs", "[", "]", "string", ",", "getRef", "inspect", ".", "GetRefFunc", ")", "error", "{", "if", "ctx", ".", "Format", "!=", "configInspectPrettyTemplate", "{", "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", "{", "configI", ",", "_", ",", "err", ":=", "getRef", "(", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "config", ",", "ok", ":=", "configI", ".", "(", "swarm", ".", "Config", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ok", ")", "\n", "}", "\n", "if", "err", ":=", "format", "(", "&", "configInspectContext", "{", "Config", ":", "config", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "configInspectContext", "{", "}", ",", "render", ")", "\n", "}" ]

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

[ "func", "NewDiskUsageFormat", "(", "source", "string", ",", "verbose", "bool", ")", "Format", "{", "switch", "{", "case", "verbose", "&&", "source", "==", "RawFormatKey", ":", "format", ":=", "`{{range .Images}}type: Image\n`", "+", "NewImageFormat", "(", "source", ",", "false", ",", "true", ")", "+", "`\n{{end -}}\n{{range .Containers}}type: Container\n`", "+", "NewContainerFormat", "(", "source", ",", "false", ",", "true", ")", "+", "`\n{{end -}}\n{{range .Volumes}}type: Volume\n`", "+", "NewVolumeFormat", "(", "source", ",", "false", ")", "+", "`\n{{end -}}\n{{range .BuildCache}}type: Build Cache\n`", "+", "NewBuildCacheFormat", "(", "source", ",", "false", ")", "+", "`\n{{end -}}`", "\n", "return", "format", "\n", "case", "!", "verbose", "&&", "source", "==", "TableFormatKey", ":", "return", "Format", "(", "defaultDiskUsageTableFormat", ")", "\n", "case", "!", "verbose", "&&", "source", "==", "RawFormatKey", ":", "format", ":=", "`type: {{.Type}}\ntotal: {{.TotalCount}}\nactive: {{.Active}}\nsize: {{.Size}}\nreclaimable: {{.Reclaimable}}\n`", "\n", "return", "Format", "(", "format", ")", "\n", "default", ":", "return", "Format", "(", "source", ")", "\n", "}", "\n", "}" ]

[ "NewDiskUsageFormat", "returns", "a", "format", "for", "rendering", "an", "DiskUsageContext" ]

[ "func", "NewDiffCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "diffOptions", "\n\n", "return", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "ExactArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "container", "=", "args", "[", "0", "]", "\n", "return", "runDiff", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewDiffCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "diff" ]

[ "func", "_escDir", "(", "useLocal", "bool", ",", "name", "string", ")", "http", ".", "FileSystem", "{", "if", "useLocal", "{", "return", "_escDirectory", "{", "fs", ":", "_escLocal", ",", "name", ":", "name", "}", "\n", "}", "\n", "return", "_escDirectory", "{", "fs", ":", "_escStatic", ",", "name", ":", "name", "}", "\n", "}" ]

[ "_escDir", "returns", "a", "http", ".", "Filesystem", "for", "the", "embedded", "assets", "on", "a", "given", "prefix", "dir", ".", "If", "useLocal", "is", "true", "the", "filesystem", "s", "contents", "are", "instead", "used", "." ]

[ "func", "_escFSMustByte", "(", "useLocal", "bool", ",", "name", "string", ")", "[", "]", "byte", "{", "b", ",", "err", ":=", "_escFSByte", "(", "useLocal", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "b", "\n", "}" ]

[ "_escFSMustByte", "is", "the", "same", "as", "_escFSByte", "but", "panics", "if", "name", "is", "not", "present", "." ]

[ "func", "_escFSString", "(", "useLocal", "bool", ",", "name", "string", ")", "(", "string", ",", "error", ")", "{", "b", ",", "err", ":=", "_escFSByte", "(", "useLocal", ",", "name", ")", "\n", "return", "string", "(", "b", ")", ",", "err", "\n", "}" ]

[ "_escFSString", "is", "the", "string", "version", "of", "_escFSByte", "." ]

[ "func", "_escFSMustString", "(", "useLocal", "bool", ",", "name", "string", ")", "string", "{", "return", "string", "(", "_escFSMustByte", "(", "useLocal", ",", "name", ")", ")", "\n", "}" ]

[ "_escFSMustString", "is", "the", "string", "version", "of", "_escFSMustByte", "." ]

[ "func", "(", "commonOpts", "*", "CommonOptions", ")", "InstallFlags", "(", "flags", "*", "pflag", ".", "FlagSet", ")", "{", "if", "dockerCertPath", "==", "\"", "\"", "{", "dockerCertPath", "=", "cliconfig", ".", "Dir", "(", ")", "\n", "}", "\n\n", "flags", ".", "BoolVarP", "(", "&", "commonOpts", ".", "Debug", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVarP", "(", "&", "commonOpts", ".", "LogLevel", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "`Set the logging level (\"debug\"|\"info\"|\"warn\"|\"error\"|\"fatal\")`", ")", "\n", "flags", ".", "BoolVar", "(", "&", "commonOpts", ".", "TLS", ",", "\"", "\"", ",", "dockerTLS", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "commonOpts", ".", "TLSVerify", ",", "FlagTLSVerify", ",", "dockerTLSVerify", ",", "\"", "\"", ")", "\n\n", "// TODO use flag flags.String(\"identity\"}, \"i\", \"\", \"Path to libtrust key file\")", "commonOpts", ".", "TLSOptions", "=", "&", "tlsconfig", ".", "Options", "{", "CAFile", ":", "filepath", ".", "Join", "(", "dockerCertPath", ",", "DefaultCaFile", ")", ",", "CertFile", ":", "filepath", ".", "Join", "(", "dockerCertPath", ",", "DefaultCertFile", ")", ",", "KeyFile", ":", "filepath", ".", "Join", "(", "dockerCertPath", ",", "DefaultKeyFile", ")", ",", "}", "\n", "tlsOptions", ":=", "commonOpts", ".", "TLSOptions", "\n", "flags", ".", "Var", "(", "opts", ".", "NewQuotedString", "(", "&", "tlsOptions", ".", "CAFile", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "Var", "(", "opts", ".", "NewQuotedString", "(", "&", "tlsOptions", ".", "CertFile", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "Var", "(", "opts", ".", "NewQuotedString", "(", "&", "tlsOptions", ".", "KeyFile", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "// opts.ValidateHost is not used here, so as to allow connection helpers", "hostOpt", ":=", "opts", ".", "NewNamedListOptsRef", "(", "\"", "\"", ",", "&", "commonOpts", ".", "Hosts", ",", "nil", ")", "\n", "flags", ".", "VarP", "(", "hostOpt", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVarP", "(", "&", "commonOpts", ".", "Context", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "`Name of the context to use to connect to the daemon (overrides DOCKER_HOST env var and default context set with \"docker context use\")`", ")", "\n", "}" ]

[ "InstallFlags", "adds", "flags", "for", "the", "common", "options", "on", "the", "FlagSet" ]

[ "func", "(", "commonOpts", "*", "CommonOptions", ")", "SetDefaultOptions", "(", "flags", "*", "pflag", ".", "FlagSet", ")", "{", "// Regardless of whether the user sets it to true or false, if they", "// specify --tlsverify at all then we need to turn on TLS", "// TLSVerify can be true even if not set due to DOCKER_TLS_VERIFY env var, so we need", "// to check that here as well", "if", "flags", ".", "Changed", "(", "FlagTLSVerify", ")", "||", "commonOpts", ".", "TLSVerify", "{", "commonOpts", ".", "TLS", "=", "true", "\n", "}", "\n\n", "if", "!", "commonOpts", ".", "TLS", "{", "commonOpts", ".", "TLSOptions", "=", "nil", "\n", "}", "else", "{", "tlsOptions", ":=", "commonOpts", ".", "TLSOptions", "\n", "tlsOptions", ".", "InsecureSkipVerify", "=", "!", "commonOpts", ".", "TLSVerify", "\n\n", "// Reset CertFile and KeyFile to empty string if the user did not specify", "// the respective flags and the respective default files were not found.", "if", "!", "flags", ".", "Changed", "(", "\"", "\"", ")", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "tlsOptions", ".", "CertFile", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "tlsOptions", ".", "CertFile", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "if", "!", "flags", ".", "Changed", "(", "\"", "\"", ")", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "tlsOptions", ".", "KeyFile", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "tlsOptions", ".", "KeyFile", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "SetDefaultOptions", "sets", "default", "values", "for", "options", "after", "flag", "parsing", "is", "complete" ]

[ "func", "(", "data", "*", "TLSData", ")", "ToStoreTLSData", "(", ")", "*", "store", ".", "EndpointTLSData", "{", "if", "data", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "result", ":=", "store", ".", "EndpointTLSData", "{", "Files", ":", "make", "(", "map", "[", "string", "]", "[", "]", "byte", ")", ",", "}", "\n", "if", "data", ".", "CA", "!=", "nil", "{", "result", ".", "Files", "[", "caKey", "]", "=", "data", ".", "CA", "\n", "}", "\n", "if", "data", ".", "Cert", "!=", "nil", "{", "result", ".", "Files", "[", "certKey", "]", "=", "data", ".", "Cert", "\n", "}", "\n", "if", "data", ".", "Key", "!=", "nil", "{", "result", ".", "Files", "[", "keyKey", "]", "=", "data", ".", "Key", "\n", "}", "\n", "return", "&", "result", "\n", "}" ]

[ "ToStoreTLSData", "converts", "TLSData", "to", "the", "store", "representation" ]

[ "func", "LoadTLSData", "(", "s", "store", ".", "Reader", ",", "contextName", ",", "endpointName", "string", ")", "(", "*", "TLSData", ",", "error", ")", "{", "tlsFiles", ",", "err", ":=", "s", ".", "ListTLSFiles", "(", "contextName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "contextName", ")", "\n", "}", "\n", "if", "epTLSFiles", ",", "ok", ":=", "tlsFiles", "[", "endpointName", "]", ";", "ok", "{", "var", "tlsData", "TLSData", "\n", "for", "_", ",", "f", ":=", "range", "epTLSFiles", "{", "data", ",", "err", ":=", "s", ".", "GetTLSData", "(", "contextName", ",", "endpointName", ",", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "f", ",", "contextName", ")", "\n", "}", "\n", "switch", "f", "{", "case", "caKey", ":", "tlsData", ".", "CA", "=", "data", "\n", "case", "certKey", ":", "tlsData", ".", "Cert", "=", "data", "\n", "case", "keyKey", ":", "tlsData", ".", "Key", "=", "data", "\n", "default", ":", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "f", ",", "contextName", ")", "\n", "}", "\n", "}", "\n", "return", "&", "tlsData", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "LoadTLSData", "loads", "TLS", "data", "from", "the", "store" ]

[ "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", "{", "spaceReclaimed", ",", "output", ",", "err", ":=", "runPrune", "(", "dockerCli", ",", "options", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "output", "!=", "\"", "\"", "{", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Out", "(", ")", ",", "output", ")", "\n", "}", "\n", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Out", "(", ")", ",", "\"", "\"", ",", "units", ".", "HumanSize", "(", "float64", "(", "spaceReclaimed", ")", ")", ")", "\n", "return", "nil", "\n", "}", ",", "Annotations", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "force", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "all", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "Var", "(", "&", "options", ".", "filter", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewPruneCommand", "returns", "a", "new", "cobra", "prune", "command", "for", "images" ]

[ "func", "NewFactory", "(", "namespace", "string", ",", "config", "*", "restclient", ".", "Config", ",", "clientSet", "*", "kubeclient", ".", "Clientset", ",", "experimental", "bool", ")", "(", "*", "Factory", ",", "error", ")", "{", "coreClientSet", ",", "err", ":=", "corev1", ".", "NewForConfig", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "appsClientSet", ",", "err", ":=", "appsv1beta2", ".", "NewForConfig", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "Factory", "{", "namespace", ":", "namespace", ",", "config", ":", "config", ",", "coreClientSet", ":", "coreClientSet", ",", "appsClientSet", ":", "appsClientSet", ",", "clientSet", ":", "clientSet", ",", "experimental", ":", "experimental", ",", "}", ",", "nil", "\n", "}" ]

[ "NewFactory", "creates", "a", "kubernetes", "client", "factory" ]

[ "func", "(", "s", "*", "Factory", ")", "ConfigMaps", "(", ")", "corev1", ".", "ConfigMapInterface", "{", "return", "s", ".", "coreClientSet", ".", "ConfigMaps", "(", "s", ".", "namespace", ")", "\n", "}" ]

[ "ConfigMaps", "returns", "a", "client", "for", "kubernetes", "s", "config", "maps" ]

[ "func", "(", "s", "*", "Factory", ")", "Secrets", "(", ")", "corev1", ".", "SecretInterface", "{", "return", "s", ".", "coreClientSet", ".", "Secrets", "(", "s", ".", "namespace", ")", "\n", "}" ]

[ "Secrets", "returns", "a", "client", "for", "kubernetes", "s", "secrets" ]

[ "func", "(", "s", "*", "Factory", ")", "Services", "(", ")", "corev1", ".", "ServiceInterface", "{", "return", "s", ".", "coreClientSet", ".", "Services", "(", "s", ".", "namespace", ")", "\n", "}" ]

[ "Services", "returns", "a", "client", "for", "kubernetes", "s", "secrets" ]

[ "func", "(", "s", "*", "Factory", ")", "Pods", "(", ")", "corev1", ".", "PodInterface", "{", "return", "s", ".", "coreClientSet", ".", "Pods", "(", "s", ".", "namespace", ")", "\n", "}" ]

[ "Pods", "returns", "a", "client", "for", "kubernetes", "s", "pods" ]

[ "func", "(", "s", "*", "Factory", ")", "ReplicationControllers", "(", ")", "corev1", ".", "ReplicationControllerInterface", "{", "return", "s", ".", "coreClientSet", ".", "ReplicationControllers", "(", "s", ".", "namespace", ")", "\n", "}" ]

[ "ReplicationControllers", "returns", "a", "client", "for", "kubernetes", "replication", "controllers" ]

[ "func", "(", "s", "*", "Factory", ")", "ReplicaSets", "(", ")", "typesappsv1beta2", ".", "ReplicaSetInterface", "{", "return", "s", ".", "appsClientSet", ".", "ReplicaSets", "(", "s", ".", "namespace", ")", "\n", "}" ]

[ "ReplicaSets", "returns", "a", "client", "for", "kubernetes", "replace", "sets" ]

[ "func", "(", "s", "*", "Factory", ")", "DaemonSets", "(", ")", "typesappsv1beta2", ".", "DaemonSetInterface", "{", "return", "s", ".", "appsClientSet", ".", "DaemonSets", "(", "s", ".", "namespace", ")", "\n", "}" ]

[ "DaemonSets", "returns", "a", "client", "for", "kubernetes", "daemon", "sets" ]

[ "func", "(", "s", "*", "Factory", ")", "Stacks", "(", "allNamespaces", "bool", ")", "(", "StackClient", ",", "error", ")", "{", "version", ",", "err", ":=", "kubernetes", ".", "GetStackAPIVersion", "(", "s", ".", "clientSet", ".", "Discovery", "(", ")", ",", "s", ".", "experimental", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "namespace", ":=", "s", ".", "namespace", "\n", "if", "allNamespaces", "{", "namespace", "=", "metav1", ".", "NamespaceAll", "\n", "}", "\n\n", "switch", "version", "{", "case", "kubernetes", ".", "StackAPIV1Beta1", ":", "return", "newStackV1Beta1", "(", "s", ".", "config", ",", "namespace", ")", "\n", "case", "kubernetes", ".", "StackAPIV1Beta2", ":", "return", "newStackV1Beta2", "(", "s", ".", "config", ",", "namespace", ")", "\n", "case", "kubernetes", ".", "StackAPIV1Alpha3", ":", "return", "newStackV1Alpha3", "(", "s", ".", "config", ",", "namespace", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "version", ")", "\n", "}", "\n", "}" ]

[ "Stacks", "returns", "a", "client", "for", "Docker", "s", "Stack", "on", "Kubernetes" ]

[ "func", "AddTrustVerificationFlags", "(", "fs", "*", "pflag", ".", "FlagSet", ",", "v", "*", "bool", ",", "trusted", "bool", ")", "{", "fs", ".", "BoolVar", "(", "v", ",", "\"", "\"", ",", "!", "trusted", ",", "\"", "\"", ")", "\n", "}" ]

[ "AddTrustVerificationFlags", "adds", "content", "trust", "flags", "to", "the", "provided", "flagset" ]

[ "func", "AddTrustSigningFlags", "(", "fs", "*", "pflag", ".", "FlagSet", ",", "v", "*", "bool", ",", "trusted", "bool", ")", "{", "fs", ".", "BoolVar", "(", "v", ",", "\"", "\"", ",", "!", "trusted", ",", "\"", "\"", ")", "\n", "}" ]

[ "AddTrustSigningFlags", "adds", "signing", "flags", "to", "the", "provided", "flagset" ]

[ "func", "NewUpdatesFormat", "(", "source", "string", ",", "quiet", "bool", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "TableFormatKey", ":", "if", "quiet", "{", "return", "defaultUpdatesQuietFormat", "\n", "}", "\n", "return", "defaultUpdatesTableFormat", "\n", "case", "formatter", ".", "RawFormatKey", ":", "if", "quiet", "{", "return", "`update_version: {{.Version}}`", "\n", "}", "\n", "return", "`update_version: {{.Version}}\\ntype: {{.Type}}\\nnotes: {{.Notes}}\\n`", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

[ "NewUpdatesFormat", "returns", "a", "Format", "for", "rendering", "using", "a", "updates", "context" ]

[ "func", "UpdatesWrite", "(", "ctx", "formatter", ".", "Context", ",", "availableUpdates", "[", "]", "clitypes", ".", "Update", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "update", ":=", "range", "availableUpdates", "{", "updatesCtx", ":=", "&", "updateContext", "{", "trunc", ":", "ctx", ".", "Trunc", ",", "u", ":", "update", "}", "\n", "if", "err", ":=", "format", "(", "updatesCtx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "updatesCtx", ":=", "updateContext", "{", "}", "\n", "updatesCtx", ".", "Header", "=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "updatesTypeHeader", ",", "\"", "\"", ":", "versionHeader", ",", "\"", "\"", ":", "notesHeader", ",", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "updatesCtx", ",", "render", ")", "\n", "}" ]

[ "UpdatesWrite", "writes", "the", "context" ]

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

[ "NewWaitCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "wait" ]

[ "func", "ValidateWeightDevice", "(", "val", "string", ")", "(", "*", "blkiodev", ".", "WeightDevice", ",", "error", ")", "{", "split", ":=", "strings", ".", "SplitN", "(", "val", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "split", ")", "!=", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "split", "[", "0", "]", ",", "\"", "\"", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n", "weight", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "split", "[", "1", "]", ",", "10", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n", "if", "weight", ">", "0", "&&", "(", "weight", "<", "10", "||", "weight", ">", "1000", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n\n", "return", "&", "blkiodev", ".", "WeightDevice", "{", "Path", ":", "split", "[", "0", "]", ",", "Weight", ":", "uint16", "(", "weight", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "ValidateWeightDevice", "validates", "that", "the", "specified", "string", "has", "a", "valid", "device", "-", "weight", "format", "." ]

[ "func", "NewWeightdeviceOpt", "(", "validator", "ValidatorWeightFctType", ")", "WeightdeviceOpt", "{", "values", ":=", "[", "]", "*", "blkiodev", ".", "WeightDevice", "{", "}", "\n", "return", "WeightdeviceOpt", "{", "values", ":", "values", ",", "validator", ":", "validator", ",", "}", "\n", "}" ]

[ "NewWeightdeviceOpt", "creates", "a", "new", "WeightdeviceOpt" ]

[ "func", "(", "opt", "*", "WeightdeviceOpt", ")", "Set", "(", "val", "string", ")", "error", "{", "var", "value", "*", "blkiodev", ".", "WeightDevice", "\n", "if", "opt", ".", "validator", "!=", "nil", "{", "v", ",", "err", ":=", "opt", ".", "validator", "(", "val", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "value", "=", "v", "\n", "}", "\n", "(", "opt", ".", "values", ")", "=", "append", "(", "(", "opt", ".", "values", ")", ",", "value", ")", "\n", "return", "nil", "\n", "}" ]

[ "Set", "validates", "a", "WeightDevice", "and", "sets", "its", "name", "as", "a", "key", "in", "WeightdeviceOpt" ]

[ "func", "RunRemove", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "options", ".", "Remove", ")", "error", "{", "client", ":=", "dockerCli", ".", "Client", "(", ")", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n\n", "var", "errs", "[", "]", "string", "\n", "for", "_", ",", "namespace", ":=", "range", "opts", ".", "Namespaces", "{", "services", ",", "err", ":=", "getStackServices", "(", "ctx", ",", "client", ",", "namespace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "networks", ",", "err", ":=", "getStackNetworks", "(", "ctx", ",", "client", ",", "namespace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "secrets", "[", "]", "swarm", ".", "Secret", "\n", "if", "versions", ".", "GreaterThanOrEqualTo", "(", "client", ".", "ClientVersion", "(", ")", ",", "\"", "\"", ")", "{", "secrets", ",", "err", "=", "getStackSecrets", "(", "ctx", ",", "client", ",", "namespace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "var", "configs", "[", "]", "swarm", ".", "Config", "\n", "if", "versions", ".", "GreaterThanOrEqualTo", "(", "client", ".", "ClientVersion", "(", ")", ",", "\"", "\"", ")", "{", "configs", ",", "err", "=", "getStackConfigs", "(", "ctx", ",", "client", ",", "namespace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "services", ")", "+", "len", "(", "networks", ")", "+", "len", "(", "secrets", ")", "+", "len", "(", "configs", ")", "==", "0", "{", "fmt", ".", "Fprintf", "(", "dockerCli", ".", "Err", "(", ")", ",", "\"", "\\n", "\"", ",", "namespace", ")", "\n", "continue", "\n", "}", "\n\n", "hasError", ":=", "removeServices", "(", "ctx", ",", "dockerCli", ",", "services", ")", "\n", "hasError", "=", "removeSecrets", "(", "ctx", ",", "dockerCli", ",", "secrets", ")", "||", "hasError", "\n", "hasError", "=", "removeConfigs", "(", "ctx", ",", "dockerCli", ",", "configs", ")", "||", "hasError", "\n", "hasError", "=", "removeNetworks", "(", "ctx", ",", "dockerCli", ",", "networks", ")", "||", "hasError", "\n\n", "if", "hasError", "{", "errs", "=", "append", "(", "errs", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "namespace", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "errs", ")", ">", "0", "{", "return", "errors", ".", "Errorf", "(", "strings", ".", "Join", "(", "errs", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RunRemove", "is", "the", "swarm", "implementation", "of", "docker", "stack", "remove" ]

[ "func", "(", "s", "*", "fsStore", ")", "Remove", "(", "listRef", "reference", ".", "Reference", ")", "error", "{", "path", ":=", "filepath", ".", "Join", "(", "s", ".", "root", ",", "makeFilesafeName", "(", "listRef", ".", "String", "(", ")", ")", ")", "\n", "return", "os", ".", "RemoveAll", "(", "path", ")", "\n", "}" ]

[ "Remove", "a", "manifest", "list", "from", "local", "storage" ]

[ "func", "(", "s", "*", "fsStore", ")", "Get", "(", "listRef", "reference", ".", "Reference", ",", "manifest", "reference", ".", "Reference", ")", "(", "types", ".", "ImageManifest", ",", "error", ")", "{", "filename", ":=", "manifestToFilename", "(", "s", ".", "root", ",", "listRef", ".", "String", "(", ")", ",", "manifest", ".", "String", "(", ")", ")", "\n", "return", "s", ".", "getFromFilename", "(", "manifest", ",", "filename", ")", "\n", "}" ]

[ "Get", "returns", "the", "local", "manifest" ]

[ "func", "(", "s", "*", "fsStore", ")", "GetList", "(", "listRef", "reference", ".", "Reference", ")", "(", "[", "]", "types", ".", "ImageManifest", ",", "error", ")", "{", "filenames", ",", "err", ":=", "s", ".", "listManifests", "(", "listRef", ".", "String", "(", ")", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "case", "filenames", "==", "nil", ":", "return", "nil", ",", "newNotFoundError", "(", "listRef", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "manifests", ":=", "[", "]", "types", ".", "ImageManifest", "{", "}", "\n", "for", "_", ",", "filename", ":=", "range", "filenames", "{", "filename", "=", "filepath", ".", "Join", "(", "s", ".", "root", ",", "makeFilesafeName", "(", "listRef", ".", "String", "(", ")", ")", ",", "filename", ")", "\n", "manifest", ",", "err", ":=", "s", ".", "getFromFilename", "(", "listRef", ",", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "manifests", "=", "append", "(", "manifests", ",", "manifest", ")", "\n", "}", "\n", "return", "manifests", ",", "nil", "\n", "}" ]

[ "GetList", "returns", "all", "the", "local", "manifests", "for", "a", "transaction" ]

[ "func", "(", "s", "*", "fsStore", ")", "listManifests", "(", "transaction", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "transactionDir", ":=", "filepath", ".", "Join", "(", "s", ".", "root", ",", "makeFilesafeName", "(", "transaction", ")", ")", "\n", "fileInfos", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "transactionDir", ")", "\n", "switch", "{", "case", "os", ".", "IsNotExist", "(", "err", ")", ":", "return", "nil", ",", "nil", "\n", "case", "err", "!=", "nil", ":", "return", "nil", ",", "err", "\n", "}", "\n\n", "filenames", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "info", ":=", "range", "fileInfos", "{", "filenames", "=", "append", "(", "filenames", ",", "info", ".", "Name", "(", ")", ")", "\n", "}", "\n", "return", "filenames", ",", "nil", "\n", "}" ]

[ "listManifests", "stored", "in", "a", "transaction" ]

[ "func", "(", "s", "*", "fsStore", ")", "Save", "(", "listRef", "reference", ".", "Reference", ",", "manifest", "reference", ".", "Reference", ",", "image", "types", ".", "ImageManifest", ")", "error", "{", "if", "err", ":=", "s", ".", "createManifestListDirectory", "(", "listRef", ".", "String", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "filename", ":=", "manifestToFilename", "(", "s", ".", "root", ",", "listRef", ".", "String", "(", ")", ",", "manifest", ".", "String", "(", ")", ")", "\n", "bytes", ",", "err", ":=", "json", ".", "Marshal", "(", "image", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "ioutil", ".", "WriteFile", "(", "filename", ",", "bytes", ",", "0644", ")", "\n", "}" ]

[ "Save", "a", "manifest", "as", "part", "of", "a", "local", "manifest", "list" ]

[ "func", "New", "(", "ctx", "context", ".", "Context", ",", "cmd", "string", ",", "args", "...", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "var", "(", "c", "commandConn", "\n", "err", "error", "\n", ")", "\n", "c", ".", "cmd", "=", "exec", ".", "CommandContext", "(", "ctx", ",", "cmd", ",", "args", "...", ")", "\n", "// we assume that args never contains sensitive information", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "cmd", ",", "args", ")", "\n", "c", ".", "cmd", ".", "Env", "=", "os", ".", "Environ", "(", ")", "\n", "c", ".", "cmd", ".", "SysProcAttr", "=", "&", "syscall", ".", "SysProcAttr", "{", "}", "\n", "setPdeathsig", "(", "c", ".", "cmd", ")", "\n", "createSession", "(", "c", ".", "cmd", ")", "\n", "c", ".", "stdin", ",", "err", "=", "c", ".", "cmd", ".", "StdinPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ".", "stdout", ",", "err", "=", "c", ".", "cmd", ".", "StdoutPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ".", "cmd", ".", "Stderr", "=", "&", "stderrWriter", "{", "stderrMu", ":", "&", "c", ".", "stderrMu", ",", "stderr", ":", "&", "c", ".", "stderr", ",", "debugPrefix", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cmd", ")", ",", "}", "\n", "c", ".", "localAddr", "=", "dummyAddr", "{", "network", ":", "\"", "\"", ",", "s", ":", "\"", "\"", "}", "\n", "c", ".", "remoteAddr", "=", "dummyAddr", "{", "network", ":", "\"", "\"", ",", "s", ":", "\"", "\"", "}", "\n", "return", "&", "c", ",", "c", ".", "cmd", ".", "Start", "(", ")", "\n", "}" ]

[ "New", "returns", "net", ".", "Conn" ]

[ "func", "(", "c", "*", "commandConn", ")", "killIfStdioClosed", "(", ")", "error", "{", "c", ".", "stdioClosedMu", ".", "Lock", "(", ")", "\n", "stdioClosed", ":=", "c", ".", "stdoutClosed", "&&", "c", ".", "stdinClosed", "\n", "c", ".", "stdioClosedMu", ".", "Unlock", "(", ")", "\n", "if", "!", "stdioClosed", "{", "return", "nil", "\n", "}", "\n", "return", "c", ".", "kill", "(", ")", "\n", "}" ]

[ "killIfStdioClosed", "kills", "the", "cmd", "if", "both", "stdin", "and", "stdout", "are", "closed", "." ]

[ "func", "killAndWait", "(", "cmd", "*", "exec", ".", "Cmd", ")", "error", "{", "var", "werr", "error", "\n", "if", "runtime", ".", "GOOS", "!=", "\"", "\"", "{", "werrCh", ":=", "make", "(", "chan", "error", ")", "\n", "go", "func", "(", ")", "{", "werrCh", "<-", "cmd", ".", "Wait", "(", ")", "}", "(", ")", "\n", "cmd", ".", "Process", ".", "Signal", "(", "syscall", ".", "SIGTERM", ")", "\n", "select", "{", "case", "werr", "=", "<-", "werrCh", ":", "case", "<-", "time", ".", "After", "(", "3", "*", "time", ".", "Second", ")", ":", "cmd", ".", "Process", ".", "Kill", "(", ")", "\n", "werr", "=", "<-", "werrCh", "\n", "}", "\n", "}", "else", "{", "cmd", ".", "Process", ".", "Kill", "(", ")", "\n", "werr", "=", "cmd", ".", "Wait", "(", ")", "\n", "}", "\n", "return", "werr", "\n", "}" ]

[ "killAndWait", "tries", "sending", "SIGTERM", "to", "the", "process", "before", "sending", "SIGKILL", "." ]

[ "func", "(", "c", "*", "commandConn", ")", "kill", "(", ")", "error", "{", "var", "werr", "error", "\n", "c", ".", "cmdMutex", ".", "Lock", "(", ")", "\n", "if", "c", ".", "cmdExited", "{", "werr", "=", "c", ".", "cmdWaitErr", "\n", "}", "else", "{", "werr", "=", "killAndWait", "(", "c", ".", "cmd", ")", "\n", "c", ".", "cmdWaitErr", "=", "werr", "\n", "c", ".", "cmdExited", "=", "true", "\n", "}", "\n", "c", ".", "cmdMutex", ".", "Unlock", "(", ")", "\n", "if", "werr", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "wExitErr", ",", "ok", ":=", "werr", ".", "(", "*", "exec", ".", "ExitError", ")", "\n", "if", "ok", "{", "if", "wExitErr", ".", "ProcessState", ".", "Exited", "(", ")", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "Wrapf", "(", "werr", ",", "\"", "\"", ")", "\n", "}" ]

[ "kill", "returns", "nil", "if", "the", "command", "terminated", "regardless", "to", "the", "exit", "status", "." ]

[ "func", "getManifest", "(", "ctx", "context", ".", "Context", ",", "dockerCli", "command", ".", "Cli", ",", "listRef", ",", "namedRef", "reference", ".", "Named", ",", "insecure", "bool", ")", "(", "types", ".", "ImageManifest", ",", "error", ")", "{", "data", ",", "err", ":=", "dockerCli", ".", "ManifestStore", "(", ")", ".", "Get", "(", "listRef", ",", "namedRef", ")", "\n", "switch", "{", "case", "store", ".", "IsNotFound", "(", "err", ")", ":", "return", "dockerCli", ".", "RegistryClient", "(", "insecure", ")", ".", "GetManifest", "(", "ctx", ",", "namedRef", ")", "\n", "case", "err", "!=", "nil", ":", "return", "types", ".", "ImageManifest", "{", "}", ",", "err", "\n", "default", ":", "return", "data", ",", "nil", "\n", "}", "\n", "}" ]

[ "getManifest", "from", "the", "local", "store", "and", "fallback", "to", "the", "remote", "registry", "if", "it", "doesn", "t", "exist", "locally" ]

[ "func", "NewFormat", "(", "source", "string", ",", "quiet", "bool", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "TableFormatKey", ":", "if", "quiet", "{", "return", "formatter", ".", "DefaultQuietFormat", "\n", "}", "\n", "return", "defaultNetworkTableFormat", "\n", "case", "formatter", ".", "RawFormatKey", ":", "if", "quiet", "{", "return", "`network_id: {{.ID}}`", "\n", "}", "\n", "return", "`network_id: {{.ID}}\\nname: {{.Name}}\\ndriver: {{.Driver}}\\nscope: {{.Scope}}\\n`", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

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

[ "func", "stackFromV1beta1", "(", "in", "*", "v1beta1", ".", "Stack", ")", "(", "Stack", ",", "error", ")", "{", "cfg", ",", "err", ":=", "loadStackData", "(", "in", ".", "Spec", ".", "ComposeFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Stack", "{", "}", ",", "err", "\n", "}", "\n", "spec", ",", "err", ":=", "fromComposeConfig", "(", "ioutil", ".", "Discard", ",", "cfg", ",", "v1beta1Capabilities", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Stack", "{", "}", ",", "err", "\n", "}", "\n", "return", "Stack", "{", "Name", ":", "in", ".", "ObjectMeta", ".", "Name", ",", "Namespace", ":", "in", ".", "ObjectMeta", ".", "Namespace", ",", "ComposeFile", ":", "in", ".", "Spec", ".", "ComposeFile", ",", "Spec", ":", "spec", ",", "}", ",", "nil", "\n", "}" ]

[ "Conversions", "from", "internal", "stack", "to", "different", "stack", "compose", "component", "versions", "." ]

[ "func", "NewDiffFormat", "(", "source", "string", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "TableFormatKey", ":", "return", "defaultDiffTableFormat", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

[ "NewDiffFormat", "returns", "a", "format", "for", "use", "with", "a", "diff", "Context" ]

[ "func", "DiffFormatWrite", "(", "ctx", "formatter", ".", "Context", ",", "changes", "[", "]", "container", ".", "ContainerChangeResponseItem", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "change", ":=", "range", "changes", "{", "if", "err", ":=", "format", "(", "&", "diffContext", "{", "c", ":", "change", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "Write", "(", "newDiffContext", "(", ")", ",", "render", ")", "\n", "}" ]

[ "DiffFormatWrite", "writes", "formatted", "diff", "using", "the", "Context" ]

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

[ "NewTrustCommand", "returns", "a", "cobra", "command", "for", "trust", "subcommands" ]

[ "func", "NewPluginCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "Annotations", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", "}", ",", "}", "\n\n", "cmd", ".", "AddCommand", "(", "newDisableCommand", "(", "dockerCli", ")", ",", "newEnableCommand", "(", "dockerCli", ")", ",", "newInspectCommand", "(", "dockerCli", ")", ",", "newInstallCommand", "(", "dockerCli", ")", ",", "newListCommand", "(", "dockerCli", ")", ",", "newRemoveCommand", "(", "dockerCli", ")", ",", "newSetCommand", "(", "dockerCli", ")", ",", "newPushCommand", "(", "dockerCli", ")", ",", "newCreateCommand", "(", "dockerCli", ")", ",", "newUpgradeCommand", "(", "dockerCli", ")", ",", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewPluginCommand", "returns", "a", "cobra", "command", "for", "plugin", "subcommands" ]

[ "func", "NewTemplateInspector", "(", "outputStream", "io", ".", "Writer", ",", "tmpl", "*", "template", ".", "Template", ")", "Inspector", "{", "return", "&", "TemplateInspector", "{", "outputStream", ":", "outputStream", ",", "buffer", ":", "new", "(", "bytes", ".", "Buffer", ")", ",", "tmpl", ":", "tmpl", ",", "}", "\n", "}" ]

[ "NewTemplateInspector", "creates", "a", "new", "inspector", "with", "a", "template", "." ]

[ "func", "NewTemplateInspectorFromString", "(", "out", "io", ".", "Writer", ",", "tmplStr", "string", ")", "(", "Inspector", ",", "error", ")", "{", "if", "tmplStr", "==", "\"", "\"", "{", "return", "NewIndentedInspector", "(", "out", ")", ",", "nil", "\n", "}", "\n\n", "tmpl", ",", "err", ":=", "templates", ".", "Parse", "(", "tmplStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "NewTemplateInspector", "(", "out", ",", "tmpl", ")", ",", "nil", "\n", "}" ]

[ "NewTemplateInspectorFromString", "creates", "a", "new", "TemplateInspector", "from", "a", "string", "which", "is", "compiled", "into", "a", "template", "." ]

[ "func", "Inspect", "(", "out", "io", ".", "Writer", ",", "references", "[", "]", "string", ",", "tmplStr", "string", ",", "getRef", "GetRefFunc", ")", "error", "{", "inspector", ",", "err", ":=", "NewTemplateInspectorFromString", "(", "out", ",", "tmplStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "cli", ".", "StatusError", "{", "StatusCode", ":", "64", ",", "Status", ":", "err", ".", "Error", "(", ")", "}", "\n", "}", "\n\n", "var", "inspectErrs", "[", "]", "string", "\n", "for", "_", ",", "ref", ":=", "range", "references", "{", "element", ",", "raw", ",", "err", ":=", "getRef", "(", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "inspectErrs", "=", "append", "(", "inspectErrs", ",", "err", ".", "Error", "(", ")", ")", "\n", "continue", "\n", "}", "\n\n", "if", "err", ":=", "inspector", ".", "Inspect", "(", "element", ",", "raw", ")", ";", "err", "!=", "nil", "{", "inspectErrs", "=", "append", "(", "inspectErrs", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "inspector", ".", "Flush", "(", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "len", "(", "inspectErrs", ")", "!=", "0", "{", "return", "cli", ".", "StatusError", "{", "StatusCode", ":", "1", ",", "Status", ":", "strings", ".", "Join", "(", "inspectErrs", ",", "\"", "\\n", "\"", ")", ",", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Inspect", "fetches", "objects", "by", "reference", "using", "GetRefFunc", "and", "writes", "the", "json", "representation", "to", "the", "output", "writer", "." ]

[ "func", "(", "i", "*", "TemplateInspector", ")", "Inspect", "(", "typedElement", "interface", "{", "}", ",", "rawElement", "[", "]", "byte", ")", "error", "{", "buffer", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "if", "err", ":=", "i", ".", "tmpl", ".", "Execute", "(", "buffer", ",", "typedElement", ")", ";", "err", "!=", "nil", "{", "if", "rawElement", "==", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "i", ".", "tryRawInspectFallback", "(", "rawElement", ")", "\n", "}", "\n", "i", ".", "buffer", ".", "Write", "(", "buffer", ".", "Bytes", "(", ")", ")", "\n", "i", ".", "buffer", ".", "WriteByte", "(", "'\\n'", ")", "\n", "return", "nil", "\n", "}" ]

[ "Inspect", "executes", "the", "inspect", "template", ".", "It", "decodes", "the", "raw", "element", "into", "a", "map", "if", "the", "initial", "execution", "fails", ".", "This", "allows", "docker", "cli", "to", "parse", "inspect", "structs", "injected", "with", "Swarm", "fields", "." ]

[ "func", "(", "i", "*", "TemplateInspector", ")", "tryRawInspectFallback", "(", "rawElement", "[", "]", "byte", ")", "error", "{", "var", "raw", "interface", "{", "}", "\n", "buffer", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "rdr", ":=", "bytes", ".", "NewReader", "(", "rawElement", ")", "\n", "dec", ":=", "json", ".", "NewDecoder", "(", "rdr", ")", "\n", "dec", ".", "UseNumber", "(", ")", "\n\n", "if", "rawErr", ":=", "dec", ".", "Decode", "(", "&", "raw", ")", ";", "rawErr", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "rawErr", ")", "\n", "}", "\n\n", "tmplMissingKey", ":=", "i", ".", "tmpl", ".", "Option", "(", "\"", "\"", ")", "\n", "if", "rawErr", ":=", "tmplMissingKey", ".", "Execute", "(", "buffer", ",", "raw", ")", ";", "rawErr", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "rawErr", ")", "\n", "}", "\n\n", "i", ".", "buffer", ".", "Write", "(", "buffer", ".", "Bytes", "(", ")", ")", "\n", "i", ".", "buffer", ".", "WriteByte", "(", "'\\n'", ")", "\n", "return", "nil", "\n", "}" ]

[ "tryRawInspectFallback", "executes", "the", "inspect", "template", "with", "a", "raw", "interface", ".", "This", "allows", "docker", "cli", "to", "parse", "inspect", "structs", "injected", "with", "Swarm", "fields", "." ]

[ "func", "(", "i", "*", "IndentedInspector", ")", "Inspect", "(", "typedElement", "interface", "{", "}", ",", "rawElement", "[", "]", "byte", ")", "error", "{", "if", "rawElement", "!=", "nil", "{", "i", ".", "rawElements", "=", "append", "(", "i", ".", "rawElements", ",", "rawElement", ")", "\n", "}", "else", "{", "i", ".", "elements", "=", "append", "(", "i", ".", "elements", ",", "typedElement", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Inspect", "writes", "the", "raw", "element", "with", "an", "indented", "json", "format", "." ]

[ "func", "New", "(", "client", "client", ".", "APIClient", ",", "noResolve", "bool", ")", "*", "IDResolver", "{", "return", "&", "IDResolver", "{", "client", ":", "client", ",", "noResolve", ":", "noResolve", ",", "cache", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "IDResolver", "." ]

[ "func", "ParseVolume", "(", "spec", "string", ")", "(", "types", ".", "ServiceVolumeConfig", ",", "error", ")", "{", "volume", ":=", "types", ".", "ServiceVolumeConfig", "{", "}", "\n\n", "switch", "len", "(", "spec", ")", "{", "case", "0", ":", "return", "volume", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "1", ",", "2", ":", "volume", ".", "Target", "=", "spec", "\n", "volume", ".", "Type", "=", "string", "(", "mount", ".", "TypeVolume", ")", "\n", "return", "volume", ",", "nil", "\n", "}", "\n\n", "buffer", ":=", "[", "]", "rune", "{", "}", "\n", "for", "_", ",", "char", ":=", "range", "spec", "+", "string", "(", "endOfSpec", ")", "{", "switch", "{", "case", "isWindowsDrive", "(", "buffer", ",", "char", ")", ":", "buffer", "=", "append", "(", "buffer", ",", "char", ")", "\n", "case", "char", "==", "':'", "||", "char", "==", "endOfSpec", ":", "if", "err", ":=", "populateFieldFromBuffer", "(", "char", ",", "buffer", ",", "&", "volume", ")", ";", "err", "!=", "nil", "{", "populateType", "(", "&", "volume", ")", "\n", "return", "volume", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "spec", ")", "\n", "}", "\n", "buffer", "=", "[", "]", "rune", "{", "}", "\n", "default", ":", "buffer", "=", "append", "(", "buffer", ",", "char", ")", "\n", "}", "\n", "}", "\n\n", "populateType", "(", "&", "volume", ")", "\n", "return", "volume", ",", "nil", "\n", "}" ]

[ "ParseVolume", "parses", "a", "volume", "spec", "without", "any", "knowledge", "of", "the", "target", "platform" ]

[ "func", "newDialStdioCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "Hidden", ":", "true", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "return", "runDialStdio", "(", "dockerCli", ")", "\n", "}", ",", "}", "\n", "return", "cmd", "\n", "}" ]

[ "newDialStdioCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "system", "dial", "-", "stdio" ]

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

[ "NewUnpauseCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "unpause" ]

[ "func", "NewConfigCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "Annotations", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "}", ",", "}", "\n", "cmd", ".", "AddCommand", "(", "newConfigListCommand", "(", "dockerCli", ")", ",", "newConfigCreateCommand", "(", "dockerCli", ")", ",", "newConfigInspectCommand", "(", "dockerCli", ")", ",", "newConfigRemoveCommand", "(", "dockerCli", ")", ",", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewConfigCommand", "returns", "a", "cobra", "command", "for", "config", "subcommands" ]

[ "func", "GetStackAPIVersion", "(", "serverGroups", "discovery", ".", "ServerGroupsInterface", ",", "experimental", "bool", ")", "(", "StackVersion", ",", "error", ")", "{", "groups", ",", "err", ":=", "serverGroups", ".", "ServerGroups", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "getAPIVersion", "(", "groups", ",", "experimental", ")", "\n", "}" ]

[ "GetStackAPIVersion", "returns", "the", "most", "appropriate", "stack", "API", "version", "installed", "." ]

[ "func", "RunServices", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "options", ".", "Services", ")", "error", "{", "ctx", ":=", "context", ".", "Background", "(", ")", "\n", "client", ":=", "dockerCli", ".", "Client", "(", ")", "\n\n", "filter", ":=", "getStackFilterFromOpt", "(", "opts", ".", "Namespace", ",", "opts", ".", "Filter", ")", "\n", "services", ",", "err", ":=", "client", ".", "ServiceList", "(", "ctx", ",", "types", ".", "ServiceListOptions", "{", "Filters", ":", "filter", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// if no services in this stack, print message and exit 0", "if", "len", "(", "services", ")", "==", "0", "{", "fmt", ".", "Fprintf", "(", "dockerCli", ".", "Err", "(", ")", ",", "\"", "\\n", "\"", ",", "opts", ".", "Namespace", ")", "\n", "return", "nil", "\n", "}", "\n\n", "info", ":=", "map", "[", "string", "]", "service", ".", "ListInfo", "{", "}", "\n", "if", "!", "opts", ".", "Quiet", "{", "taskFilter", ":=", "filters", ".", "NewArgs", "(", ")", "\n", "for", "_", ",", "service", ":=", "range", "services", "{", "taskFilter", ".", "Add", "(", "\"", "\"", ",", "service", ".", "ID", ")", "\n", "}", "\n\n", "tasks", ",", "err", ":=", "client", ".", "TaskList", "(", "ctx", ",", "types", ".", "TaskListOptions", "{", "Filters", ":", "taskFilter", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "nodes", ",", "err", ":=", "client", ".", "NodeList", "(", "ctx", ",", "types", ".", "NodeListOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "info", "=", "service", ".", "GetServicesStatus", "(", "services", ",", "nodes", ",", "tasks", ")", "\n", "}", "\n\n", "format", ":=", "opts", ".", "Format", "\n", "if", "len", "(", "format", ")", "==", "0", "{", "if", "len", "(", "dockerCli", ".", "ConfigFile", "(", ")", ".", "ServicesFormat", ")", ">", "0", "&&", "!", "opts", ".", "Quiet", "{", "format", "=", "dockerCli", ".", "ConfigFile", "(", ")", ".", "ServicesFormat", "\n", "}", "else", "{", "format", "=", "formatter", ".", "TableFormatKey", "\n", "}", "\n", "}", "\n\n", "servicesCtx", ":=", "formatter", ".", "Context", "{", "Output", ":", "dockerCli", ".", "Out", "(", ")", ",", "Format", ":", "service", ".", "NewListFormat", "(", "format", ",", "opts", ".", "Quiet", ")", ",", "}", "\n", "return", "service", ".", "ListFormatWrite", "(", "servicesCtx", ",", "services", ",", "info", ")", "\n", "}" ]

[ "RunServices", "is", "the", "swarm", "implementation", "of", "docker", "stack", "services" ]

[ "func", "RunExport", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "*", "ExportOptions", ")", "error", "{", "if", "err", ":=", "validateContextName", "(", "opts", ".", "ContextName", ")", ";", "err", "!=", "nil", "&&", "opts", ".", "ContextName", "!=", "command", ".", "DefaultContextName", "{", "return", "err", "\n", "}", "\n", "ctxMeta", ",", "err", ":=", "dockerCli", ".", "ContextStore", "(", ")", ".", "GetMetadata", "(", "opts", ".", "ContextName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "opts", ".", "Kubeconfig", "{", "reader", ":=", "store", ".", "Export", "(", "opts", ".", "ContextName", ",", "dockerCli", ".", "ContextStore", "(", ")", ")", "\n", "defer", "reader", ".", "Close", "(", ")", "\n", "return", "writeTo", "(", "dockerCli", ",", "reader", ",", "opts", ".", "Dest", ")", "\n", "}", "\n", "kubernetesEndpointMeta", ":=", "kubernetes", ".", "EndpointFromContext", "(", "ctxMeta", ")", "\n", "if", "kubernetesEndpointMeta", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "opts", ".", "ContextName", ")", "\n", "}", "\n", "kubernetesEndpoint", ",", "err", ":=", "kubernetesEndpointMeta", ".", "WithTLSData", "(", "dockerCli", ".", "ContextStore", "(", ")", ",", "opts", ".", "ContextName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "kubeConfig", ":=", "kubernetesEndpoint", ".", "KubernetesConfig", "(", ")", "\n", "rawCfg", ",", "err", ":=", "kubeConfig", ".", "RawConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "data", ",", "err", ":=", "clientcmd", ".", "Write", "(", "rawCfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "writeTo", "(", "dockerCli", ",", "bytes", ".", "NewBuffer", "(", "data", ")", ",", "opts", ".", "Dest", ")", "\n", "}" ]

[ "RunExport", "exports", "a", "Docker", "context" ]

[ "func", "waitOnService", "(", "ctx", "context", ".", "Context", ",", "dockerCli", "command", ".", "Cli", ",", "serviceID", "string", ",", "quiet", "bool", ")", "error", "{", "errChan", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "pipeReader", ",", "pipeWriter", ":=", "io", ".", "Pipe", "(", ")", "\n\n", "go", "func", "(", ")", "{", "errChan", "<-", "progress", ".", "ServiceProgress", "(", "ctx", ",", "dockerCli", ".", "Client", "(", ")", ",", "serviceID", ",", "pipeWriter", ")", "\n", "}", "(", ")", "\n\n", "if", "quiet", "{", "go", "io", ".", "Copy", "(", "ioutil", ".", "Discard", ",", "pipeReader", ")", "\n", "return", "<-", "errChan", "\n", "}", "\n\n", "err", ":=", "jsonmessage", ".", "DisplayJSONMessagesToStream", "(", "pipeReader", ",", "dockerCli", ".", "Out", "(", ")", ",", "nil", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "<-", "errChan", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "waitOnService", "waits", "for", "the", "service", "to", "converge", ".", "It", "outputs", "a", "progress", "bar", "if", "appropriate", "based", "on", "the", "CLI", "flags", "." ]

[ "func", "NewImportCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "options", "importOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMinArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "options", ".", "source", "=", "args", "[", "0", "]", "\n", "if", "len", "(", "args", ")", ">", "1", "{", "options", ".", "reference", "=", "args", "[", "1", "]", "\n", "}", "\n", "return", "runImport", "(", "dockerCli", ",", "options", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "options", ".", "changes", "=", "dockeropts", ".", "NewListOpts", "(", "nil", ")", "\n", "flags", ".", "VarP", "(", "&", "options", ".", "changes", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVarP", "(", "&", "options", ".", "message", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "command", ".", "AddPlatformFlag", "(", "flags", ",", "&", "options", ".", "platform", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewImportCommand", "creates", "a", "new", "docker", "import", "command" ]

[ "func", "NewPushCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "pushOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "ExactArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "remote", "=", "args", "[", "0", "]", "\n", "return", "RunPush", "(", "dockerCli", ",", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "command", ".", "AddTrustSigningFlags", "(", "flags", ",", "&", "opts", ".", "untrusted", ",", "dockerCli", ".", "ContentTrustEnabled", "(", ")", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewPushCommand", "creates", "a", "new", "docker", "push", "command" ]

[ "func", "RunPush", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "pushOptions", ")", "error", "{", "ref", ",", "err", ":=", "reference", ".", "ParseNormalizedNamed", "(", "opts", ".", "remote", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Resolve the Repository name from fqn to RepositoryInfo", "repoInfo", ",", "err", ":=", "registry", ".", "ParseRepositoryInfo", "(", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n\n", "// Resolve the Auth config relevant for this server", "authConfig", ":=", "command", ".", "ResolveAuthConfig", "(", "ctx", ",", "dockerCli", ",", "repoInfo", ".", "Index", ")", "\n", "requestPrivilege", ":=", "command", ".", "RegistryAuthenticationPrivilegedFunc", "(", "dockerCli", ",", "repoInfo", ".", "Index", ",", "\"", "\"", ")", "\n\n", "if", "!", "opts", ".", "untrusted", "{", "return", "TrustedPush", "(", "ctx", ",", "dockerCli", ",", "repoInfo", ",", "ref", ",", "authConfig", ",", "requestPrivilege", ")", "\n", "}", "\n\n", "responseBody", ",", "err", ":=", "imagePushPrivileged", "(", "ctx", ",", "dockerCli", ",", "authConfig", ",", "ref", ",", "requestPrivilege", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "responseBody", ".", "Close", "(", ")", "\n", "return", "jsonmessage", ".", "DisplayJSONMessagesToStream", "(", "responseBody", ",", "dockerCli", ".", "Out", "(", ")", ",", "nil", ")", "\n", "}" ]

[ "RunPush", "performs", "a", "push", "against", "the", "engine", "based", "on", "the", "specified", "options" ]

[ "func", "ReadKVStrings", "(", "files", "[", "]", "string", ",", "override", "[", "]", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "readKVStrings", "(", "files", ",", "override", ",", "nil", ")", "\n", "}" ]

[ "ReadKVStrings", "reads", "a", "file", "of", "line", "terminated", "key", "=", "value", "pairs", "and", "overrides", "any", "keys", "present", "in", "the", "file", "with", "additional", "pairs", "specified", "in", "the", "override", "parameter" ]

[ "func", "ReadKVEnvStrings", "(", "files", "[", "]", "string", ",", "override", "[", "]", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "readKVStrings", "(", "files", ",", "override", ",", "os", ".", "LookupEnv", ")", "\n", "}" ]

[ "ReadKVEnvStrings", "reads", "a", "file", "of", "line", "terminated", "key", "=", "value", "pairs", "and", "overrides", "any", "keys", "present", "in", "the", "file", "with", "additional", "pairs", "specified", "in", "the", "override", "parameter", ".", "If", "a", "key", "has", "no", "value", "it", "will", "get", "the", "value", "from", "the", "environment", "." ]

[ "func", "ParseRestartPolicy", "(", "policy", "string", ")", "(", "container", ".", "RestartPolicy", ",", "error", ")", "{", "p", ":=", "container", ".", "RestartPolicy", "{", "}", "\n\n", "if", "policy", "==", "\"", "\"", "{", "return", "p", ",", "nil", "\n", "}", "\n\n", "parts", ":=", "strings", ".", "Split", "(", "policy", ",", "\"", "\"", ")", "\n\n", "if", "len", "(", "parts", ")", ">", "2", "{", "return", "p", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "parts", ")", "==", "2", "{", "count", ",", "err", ":=", "strconv", ".", "Atoi", "(", "parts", "[", "1", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "p", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "p", ".", "MaximumRetryCount", "=", "count", "\n", "}", "\n\n", "p", ".", "Name", "=", "parts", "[", "0", "]", "\n\n", "return", "p", ",", "nil", "\n", "}" ]

[ "ParseRestartPolicy", "returns", "the", "parsed", "policy", "or", "an", "error", "indicating", "what", "is", "incorrect" ]

[ "func", "NewInfoCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "infoOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "return", "runInfo", "(", "cmd", ",", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "flags", ".", "StringVarP", "(", "&", "opts", ".", "format", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewInfoCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "info" ]

[ "func", "RunConfigInspect", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "InspectOptions", ")", "error", "{", "client", ":=", "dockerCli", ".", "Client", "(", ")", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n\n", "if", "opts", ".", "Pretty", "{", "opts", ".", "Format", "=", "\"", "\"", "\n", "}", "\n\n", "getRef", ":=", "func", "(", "id", "string", ")", "(", "interface", "{", "}", ",", "[", "]", "byte", ",", "error", ")", "{", "return", "client", ".", "ConfigInspectWithRaw", "(", "ctx", ",", "id", ")", "\n", "}", "\n", "f", ":=", "opts", ".", "Format", "\n\n", "// check if the user is trying to apply a template to the pretty format, which", "// is not supported", "if", "strings", ".", "HasPrefix", "(", "f", ",", "\"", "\"", ")", "&&", "f", "!=", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "configCtx", ":=", "formatter", ".", "Context", "{", "Output", ":", "dockerCli", ".", "Out", "(", ")", ",", "Format", ":", "NewFormat", "(", "f", ",", "false", ")", ",", "}", "\n\n", "if", "err", ":=", "InspectFormatWrite", "(", "configCtx", ",", "opts", ".", "Names", ",", "getRef", ")", ";", "err", "!=", "nil", "{", "return", "cli", ".", "StatusError", "{", "StatusCode", ":", "1", ",", "Status", ":", "err", ".", "Error", "(", ")", "}", "\n", "}", "\n", "return", "nil", "\n\n", "}" ]

[ "RunConfigInspect", "inspects", "the", "given", "Swarm", "config", "." ]

[ "func", "NewClientContextFormat", "(", "source", "string", ",", "quiet", "bool", ")", "Format", "{", "if", "quiet", "{", "return", "Format", "(", "quietContextFormat", ")", "\n", "}", "\n", "if", "source", "==", "TableFormatKey", "{", "return", "Format", "(", "ClientContextTableFormat", ")", "\n", "}", "\n", "return", "Format", "(", "source", ")", "\n", "}" ]

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

[ "func", "ClientContextWrite", "(", "ctx", "Context", ",", "contexts", "[", "]", "*", "ClientContext", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "context", ":=", "range", "contexts", "{", "if", "err", ":=", "format", "(", "&", "clientContextContext", "{", "c", ":", "context", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "Write", "(", "newClientContextContext", "(", ")", ",", "render", ")", "\n", "}" ]

[ "ClientContextWrite", "writes", "formatted", "contexts", "using", "the", "Context" ]

[ "func", "Version", "(", "config", "map", "[", "string", "]", "interface", "{", "}", ")", "string", "{", "version", ",", "ok", ":=", "config", "[", "versionField", "]", "\n", "if", "!", "ok", "{", "return", "defaultVersion", "\n", "}", "\n", "return", "normalizeVersion", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "version", ")", ")", "\n", "}" ]

[ "Version", "returns", "the", "version", "of", "the", "config", "defaulting", "to", "version", "1", ".", "0" ]

[ "func", "NewTaskFormat", "(", "source", "string", ",", "quiet", "bool", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "TableFormatKey", ":", "if", "quiet", "{", "return", "formatter", ".", "DefaultQuietFormat", "\n", "}", "\n", "return", "defaultTaskTableFormat", "\n", "case", "formatter", ".", "RawFormatKey", ":", "if", "quiet", "{", "return", "`id: {{.ID}}`", "\n", "}", "\n", "return", "`id: {{.ID}}\\nname: {{.Name}}\\nimage: {{.Image}}\\nnode: {{.Node}}\\ndesired_state: {{.DesiredState}}\\ncurrent_state: {{.CurrentState}}\\nerror: {{.Error}}\\nports: {{.Ports}}\\n`", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

[ "NewTaskFormat", "returns", "a", "Format", "for", "rendering", "using", "a", "task", "Context" ]

[ "func", "NewHistoryFormat", "(", "source", "string", ",", "quiet", "bool", ",", "human", "bool", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "TableFormatKey", ":", "switch", "{", "case", "quiet", ":", "return", "formatter", ".", "DefaultQuietFormat", "\n", "case", "!", "human", ":", "return", "nonHumanHistoryTableFormat", "\n", "default", ":", "return", "defaultHistoryTableFormat", "\n", "}", "\n", "}", "\n\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

[ "NewHistoryFormat", "returns", "a", "format", "for", "rendering", "an", "HistoryContext" ]

[ "func", "HistoryWrite", "(", "ctx", "formatter", ".", "Context", ",", "human", "bool", ",", "histories", "[", "]", "image", ".", "HistoryResponseItem", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "history", ":=", "range", "histories", "{", "historyCtx", ":=", "&", "historyContext", "{", "trunc", ":", "ctx", ".", "Trunc", ",", "h", ":", "history", ",", "human", ":", "human", "}", "\n", "if", "err", ":=", "format", "(", "historyCtx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "historyCtx", ":=", "&", "historyContext", "{", "}", "\n", "historyCtx", ".", "Header", "=", "formatter", ".", "SubHeaderContext", "{", "\"", "\"", ":", "historyIDHeader", ",", "\"", "\"", ":", "formatter", ".", "CreatedSinceHeader", ",", "\"", "\"", ":", "formatter", ".", "CreatedAtHeader", ",", "\"", "\"", ":", "createdByHeader", ",", "\"", "\"", ":", "formatter", ".", "SizeHeader", ",", "\"", "\"", ":", "commentHeader", ",", "}", "\n", "return", "ctx", ".", "Write", "(", "historyCtx", ",", "render", ")", "\n", "}" ]

[ "HistoryWrite", "writes", "the", "context" ]

[ "func", "newActivateCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "options", "activateOptions", "\n", "options", ".", "licenseLoginFunc", "=", "licenseutils", ".", "Login", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Long", ":", "`Activate Enterprise Edition.\n\nWith this command you may apply an existing Docker enterprise license, or\ninteractively download one from Docker. In the interactive exchange, you can\nsign up for a new trial, or download an existing license. If you are\ncurrently running a Community Edition engine, the daemon will be updated to\nthe Enterprise Edition Docker engine with additional capabilities and long\nterm support.\n\nFor more information about different Docker Enterprise license types visit\nhttps://www.docker.com/licenses\n\nFor non-interactive scriptable deployments, download your license from\nhttps://hub.docker.com/ then specify the file with the '--license' flag.\n`", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "return", "runActivate", "(", "dockerCli", ",", "options", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "flags", ".", "StringVar", "(", "&", "options", ".", "licenseFile", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "version", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "registryPrefix", ",", "\"", "\"", ",", "clitypes", ".", "RegistryPrefix", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "image", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "format", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "options", ".", "displayOnly", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "options", ".", "quiet", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "sockPath", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "newActivateCommand", "creates", "a", "new", "docker", "engine", "activate", "command" ]

[ "func", "newPlugin", "(", "c", "Candidate", ",", "rootcmd", "*", "cobra", ".", "Command", ")", "(", "Plugin", ",", "error", ")", "{", "path", ":=", "c", ".", "Path", "(", ")", "\n", "if", "path", "==", "\"", "\"", "{", "return", "Plugin", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// The candidate listing process should have skipped anything", "// which would fail here, so there are all real errors.", "fullname", ":=", "filepath", ".", "Base", "(", "path", ")", "\n", "if", "fullname", "==", "\"", "\"", "{", "return", "Plugin", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "var", "err", "error", "\n", "if", "fullname", ",", "err", "=", "trimExeSuffix", "(", "fullname", ")", ";", "err", "!=", "nil", "{", "return", "Plugin", "{", "}", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "fullname", ",", "NamePrefix", ")", "{", "return", "Plugin", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "NamePrefix", ")", "\n", "}", "\n\n", "p", ":=", "Plugin", "{", "Name", ":", "strings", ".", "TrimPrefix", "(", "fullname", ",", "NamePrefix", ")", ",", "Path", ":", "path", ",", "}", "\n\n", "// Now apply the candidate tests, so these update p.Err.", "if", "!", "pluginNameRe", ".", "MatchString", "(", "p", ".", "Name", ")", "{", "p", ".", "Err", "=", "NewPluginError", "(", "\"", "\"", ",", "p", ".", "Name", ",", "pluginNameRe", ".", "String", "(", ")", ")", "\n", "return", "p", ",", "nil", "\n", "}", "\n\n", "if", "rootcmd", "!=", "nil", "{", "for", "_", ",", "cmd", ":=", "range", "rootcmd", ".", "Commands", "(", ")", "{", "// Ignore conflicts with commands which are", "// just plugin stubs (i.e. from a previous", "// call to AddPluginCommandStubs).", "if", "p", ":=", "cmd", ".", "Annotations", "[", "CommandAnnotationPlugin", "]", ";", "p", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "cmd", ".", "Name", "(", ")", "==", "p", ".", "Name", "{", "p", ".", "Err", "=", "NewPluginError", "(", "\"", "\"", ",", "p", ".", "Name", ")", "\n", "return", "p", ",", "nil", "\n", "}", "\n", "if", "cmd", ".", "HasAlias", "(", "p", ".", "Name", ")", "{", "p", ".", "Err", "=", "NewPluginError", "(", "\"", "\"", ",", "p", ".", "Name", ",", "cmd", ".", "Name", "(", ")", ")", "\n", "return", "p", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// We are supposed to check for relevant execute permissions here. Instead we rely on an attempt to execute.", "meta", ",", "err", ":=", "c", ".", "Metadata", "(", ")", "\n", "if", "err", "!=", "nil", "{", "p", ".", "Err", "=", "wrapAsPluginError", "(", "err", ",", "\"", "\"", ")", "\n", "return", "p", ",", "nil", "\n", "}", "\n\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "meta", ",", "&", "p", ".", "Metadata", ")", ";", "err", "!=", "nil", "{", "p", ".", "Err", "=", "wrapAsPluginError", "(", "err", ",", "\"", "\"", ")", "\n", "return", "p", ",", "nil", "\n", "}", "\n\n", "if", "p", ".", "Metadata", ".", "SchemaVersion", "!=", "\"", "\"", "{", "p", ".", "Err", "=", "NewPluginError", "(", "\"", "\"", ",", "p", ".", "Metadata", ".", "SchemaVersion", ")", "\n", "return", "p", ",", "nil", "\n", "}", "\n", "if", "p", ".", "Metadata", ".", "Vendor", "==", "\"", "\"", "{", "p", ".", "Err", "=", "NewPluginError", "(", "\"", "\"", ")", "\n", "return", "p", ",", "nil", "\n", "}", "\n", "return", "p", ",", "nil", "\n", "}" ]

[ "newPlugin", "determines", "if", "the", "given", "candidate", "is", "valid", "and", "returns", "a", "Plugin", ".", "If", "the", "candidate", "fails", "one", "of", "the", "tests", "then", "Plugin", ".", "Err", "is", "set", "and", "is", "always", "a", "pluginError", "but", "the", "Plugin", "is", "still", "returned", "with", "no", "error", ".", "An", "error", "is", "only", "returned", "due", "to", "a", "non", "-", "recoverable", "error", "." ]

[ "func", "NewStackCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "commonOptions", "\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "PersistentPreRunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "orchestrator", ",", "err", ":=", "getOrchestrator", "(", "dockerCli", ",", "cmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "opts", ".", "orchestrator", "=", "orchestrator", "\n", "hideOrchestrationFlags", "(", "cmd", ",", "orchestrator", ")", "\n", "return", "checkSupportedFlag", "(", "cmd", ",", "orchestrator", ")", "\n", "}", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "Annotations", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "}", ",", "}", "\n", "defaultHelpFunc", ":=", "cmd", ".", "HelpFunc", "(", ")", "\n", "cmd", ".", "SetHelpFunc", "(", "func", "(", "c", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "{", "if", "err", ":=", "cmd", ".", "Root", "(", ")", ".", "PersistentPreRunE", "(", "c", ",", "args", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Err", "(", ")", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "err", ":=", "cmd", ".", "PersistentPreRunE", "(", "c", ",", "args", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Err", "(", ")", ",", "err", ")", "\n", "return", "\n", "}", "\n", "hideOrchestrationFlags", "(", "c", ",", "opts", ".", "orchestrator", ")", "\n", "defaultHelpFunc", "(", "c", ",", "args", ")", "\n", "}", ")", "\n", "cmd", ".", "AddCommand", "(", "newDeployCommand", "(", "dockerCli", ",", "&", "opts", ")", ",", "newListCommand", "(", "dockerCli", ",", "&", "opts", ")", ",", "newPsCommand", "(", "dockerCli", ",", "&", "opts", ")", ",", "newRemoveCommand", "(", "dockerCli", ",", "&", "opts", ")", ",", "newServicesCommand", "(", "dockerCli", ",", "&", "opts", ")", ",", ")", "\n", "flags", ":=", "cmd", ".", "PersistentFlags", "(", ")", "\n", "flags", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "nil", ")", "\n", "flags", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewStackCommand", "returns", "a", "cobra", "command", "for", "stack", "subcommands" ]

[ "func", "NewTopLevelDeployCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "newDeployCommand", "(", "dockerCli", ",", "nil", ")", "\n", "// Remove the aliases at the top level", "cmd", ".", "Aliases", "=", "[", "]", "string", "{", "}", "\n", "cmd", ".", "Annotations", "=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "\"", "\"", ",", "}", "\n", "return", "cmd", "\n", "}" ]

[ "NewTopLevelDeployCommand", "returns", "a", "command", "for", "docker", "deploy" ]

[ "func", "NewLoadCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "loadOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "return", "runLoad", "(", "dockerCli", ",", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "flags", ".", "StringVarP", "(", "&", "opts", ".", "input", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "quiet", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewLoadCommand", "creates", "a", "new", "docker", "load", "command" ]

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

[ "NewEngineCommand", "returns", "a", "cobra", "command", "for", "engine", "subcommands" ]

[ "func", "NewExecCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "options", ":=", "newExecOptions", "(", ")", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMinArgs", "(", "2", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "options", ".", "container", "=", "args", "[", "0", "]", "\n", "options", ".", "command", "=", "args", "[", "1", ":", "]", "\n", "return", "runExec", "(", "dockerCli", ",", "options", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "SetInterspersed", "(", "false", ")", "\n\n", "flags", ".", "StringVarP", "(", "&", "options", ".", "detachKeys", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "interactive", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "tty", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "detach", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVarP", "(", "&", "options", ".", "user", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "options", ".", "privileged", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "VarP", "(", "&", "options", ".", "env", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n", "flags", ".", "StringVarP", "(", "&", "options", ".", "workdir", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewExecCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "exec" ]

[ "func", "parseExec", "(", "opts", "execOptions", ",", "configFile", "*", "configfile", ".", "ConfigFile", ")", "*", "types", ".", "ExecConfig", "{", "execConfig", ":=", "&", "types", ".", "ExecConfig", "{", "User", ":", "opts", ".", "user", ",", "Privileged", ":", "opts", ".", "privileged", ",", "Tty", ":", "opts", ".", "tty", ",", "Cmd", ":", "opts", ".", "command", ",", "Detach", ":", "opts", ".", "detach", ",", "Env", ":", "opts", ".", "env", ".", "GetAll", "(", ")", ",", "WorkingDir", ":", "opts", ".", "workdir", ",", "}", "\n\n", "// If -d is not set, attach to everything by default", "if", "!", "opts", ".", "detach", "{", "execConfig", ".", "AttachStdout", "=", "true", "\n", "execConfig", ".", "AttachStderr", "=", "true", "\n", "if", "opts", ".", "interactive", "{", "execConfig", ".", "AttachStdin", "=", "true", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "detachKeys", "!=", "\"", "\"", "{", "execConfig", ".", "DetachKeys", "=", "opts", ".", "detachKeys", "\n", "}", "else", "{", "execConfig", ".", "DetachKeys", "=", "configFile", ".", "DetachKeys", "\n", "}", "\n", "return", "execConfig", "\n", "}" ]

[ "parseExec", "parses", "the", "specified", "args", "for", "the", "specified", "command", "and", "generates", "an", "ExecConfig", "from", "it", "." ]

[ "func", "(", "s", "*", "commonStream", ")", "RestoreTerminal", "(", ")", "{", "if", "s", ".", "state", "!=", "nil", "{", "term", ".", "RestoreTerminal", "(", "s", ".", "fd", ",", "s", ".", "state", ")", "\n", "}", "\n", "}" ]

[ "RestoreTerminal", "restores", "normal", "mode", "to", "the", "terminal" ]

[ "func", "NewSystemCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "}", "\n", "cmd", ".", "AddCommand", "(", "NewEventsCommand", "(", "dockerCli", ")", ",", "NewInfoCommand", "(", "dockerCli", ")", ",", "newDiskUsageCommand", "(", "dockerCli", ")", ",", "newPruneCommand", "(", "dockerCli", ")", ",", "newDialStdioCommand", "(", "dockerCli", ")", ",", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewSystemCommand", "returns", "a", "cobra", "command", "for", "system", "subcommands" ]

[ "func", "Path", "(", "p", "...", "string", ")", "(", "string", ",", "error", ")", "{", "path", ":=", "filepath", ".", "Join", "(", "append", "(", "[", "]", "string", "{", "Dir", "(", ")", "}", ",", "p", "...", ")", "...", ")", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "path", ",", "Dir", "(", ")", "+", "string", "(", "filepath", ".", "Separator", ")", ")", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "Dir", "(", ")", ")", "\n", "}", "\n", "return", "path", ",", "nil", "\n", "}" ]

[ "Path", "returns", "the", "path", "to", "a", "file", "relative", "to", "the", "config", "dir" ]