Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "CopyToFile", "(", "outfile", "string", ",", "r", "io", ".", "Reader", ")", "error", "{", "// We use sequential file access here to avoid depleting the standby list", "// on Windows. On Linux, this is a call directly to ioutil.TempFile", "tmpFile", ",", "err", ":=", "system", ".", "TempFileSequential", "(", "filepath", ".", "Dir", "(", "outfile", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "tmpPath", ":=", "tmpFile", ".", "Name", "(", ")", "\n\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "tmpFile", ",", "r", ")", "\n", "tmpFile", ".", "Close", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "os", ".", "Remove", "(", "tmpPath", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "os", ".", "Rename", "(", "tmpPath", ",", "outfile", ")", ";", "err", "!=", "nil", "{", "os", ".", "Remove", "(", "tmpPath", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CopyToFile", "writes", "the", "content", "of", "the", "reader", "to", "the", "specified", "file" ]

[ "func", "capitalizeFirst", "(", "s", "string", ")", "string", "{", "switch", "l", ":=", "len", "(", "s", ")", ";", "l", "{", "case", "0", ":", "return", "s", "\n", "case", "1", ":", "return", "strings", ".", "ToLower", "(", "s", ")", "\n", "default", ":", "return", "strings", ".", "ToUpper", "(", "string", "(", "s", "[", "0", "]", ")", ")", "+", "strings", ".", "ToLower", "(", "s", "[", "1", ":", "]", ")", "\n", "}", "\n", "}" ]

[ "capitalizeFirst", "capitalizes", "the", "first", "character", "of", "string" ]

[ "func", "PrettyPrint", "(", "i", "interface", "{", "}", ")", "string", "{", "switch", "t", ":=", "i", ".", "(", "type", ")", "{", "case", "nil", ":", "return", "\"", "\"", "\n", "case", "string", ":", "return", "capitalizeFirst", "(", "t", ")", "\n", "default", ":", "return", "capitalizeFirst", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "t", ")", ")", "\n", "}", "\n", "}" ]

[ "PrettyPrint", "outputs", "arbitrary", "data", "for", "human", "formatted", "output", "by", "uppercasing", "the", "first", "letter", "." ]

[ "func", "PruneFilters", "(", "dockerCli", "Cli", ",", "pruneFilters", "filters", ".", "Args", ")", "filters", ".", "Args", "{", "if", "dockerCli", ".", "ConfigFile", "(", ")", "==", "nil", "{", "return", "pruneFilters", "\n", "}", "\n", "for", "_", ",", "f", ":=", "range", "dockerCli", ".", "ConfigFile", "(", ")", ".", "PruneFilters", "{", "parts", ":=", "strings", ".", "SplitN", "(", "f", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "continue", "\n", "}", "\n", "if", "parts", "[", "0", "]", "==", "\"", "\"", "{", "// CLI label filter supersede config.json.", "// If CLI label filter conflict with config.json,", "// skip adding label! filter in config.json.", "if", "pruneFilters", ".", "Contains", "(", "\"", "\"", ")", "&&", "pruneFilters", ".", "ExactMatch", "(", "\"", "\"", ",", "parts", "[", "1", "]", ")", "{", "continue", "\n", "}", "\n", "}", "else", "if", "parts", "[", "0", "]", "==", "\"", "\"", "{", "// CLI label! filter supersede config.json.", "// If CLI label! filter conflict with config.json,", "// skip adding label filter in config.json.", "if", "pruneFilters", ".", "Contains", "(", "\"", "\"", ")", "&&", "pruneFilters", ".", "ExactMatch", "(", "\"", "\"", ",", "parts", "[", "1", "]", ")", "{", "continue", "\n", "}", "\n", "}", "\n", "pruneFilters", ".", "Add", "(", "parts", "[", "0", "]", ",", "parts", "[", "1", "]", ")", "\n", "}", "\n\n", "return", "pruneFilters", "\n", "}" ]

[ "PruneFilters", "returns", "consolidated", "prune", "filters", "obtained", "from", "config", ".", "json", "and", "cli" ]

[ "func", "AddPlatformFlag", "(", "flags", "*", "pflag", ".", "FlagSet", ",", "target", "*", "string", ")", "{", "flags", ".", "StringVar", "(", "target", ",", "\"", "\"", ",", "os", ".", "Getenv", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "nil", ")", "\n", "}" ]

[ "AddPlatformFlag", "adds", "platform", "to", "a", "set", "of", "flags", "for", "API", "version", "1", ".", "32", "and", "later", "." ]

[ "func", "ValidateOutputPath", "(", "path", "string", ")", "error", "{", "dir", ":=", "filepath", ".", "Dir", "(", "path", ")", "\n", "if", "dir", "!=", "\"", "\"", "&&", "dir", "!=", "\"", "\"", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "dir", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "dir", ")", "\n", "}", "\n", "}", "\n", "// check whether `path` points to a regular file", "// (if the path exists and doesn't point to a directory)", "if", "fileInfo", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "if", "fileInfo", ".", "Mode", "(", ")", ".", "IsDir", "(", ")", "||", "fileInfo", ".", "Mode", "(", ")", ".", "IsRegular", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "ValidateOutputPathFileMode", "(", "fileInfo", ".", "Mode", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "path", ")", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateOutputPath", "validates", "the", "output", "paths", "of", "the", "export", "and", "save", "commands", "." ]

[ "func", "ValidateOutputPathFileMode", "(", "fileMode", "os", ".", "FileMode", ")", "error", "{", "switch", "{", "case", "fileMode", "&", "os", ".", "ModeDevice", "!=", "0", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "fileMode", "&", "os", ".", "ModeIrregular", "!=", "0", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateOutputPathFileMode", "validates", "the", "output", "paths", "of", "the", "cp", "command", "and", "serves", "as", "a", "helper", "to", "ValidateOutputPath" ]

[ "func", "newDiskUsageCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "diskUsageOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "return", "runDiskUsage", "(", "dockerCli", ",", "opts", ")", "\n", "}", ",", "Annotations", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "verbose", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "opts", ".", "format", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "newDiskUsageCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "df" ]

[ "func", "(", "i", "*", "In", ")", "CheckTty", "(", "attachStdin", ",", "ttyMode", "bool", ")", "error", "{", "// In order to attach to a container tty, input stream for the client must", "// be a tty itself: redirecting or piping the client standard input is", "// incompatible with `docker run -t`, `docker exec -t` or `docker attach`.", "if", "ttyMode", "&&", "attachStdin", "&&", "!", "i", ".", "isTerminal", "{", "eText", ":=", "\"", "\"", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "eText", "+", "\"", "\"", ")", "\n", "}", "\n", "return", "errors", ".", "New", "(", "eText", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckTty", "checks", "if", "we", "are", "trying", "to", "attach", "to", "a", "container", "tty", "from", "a", "non", "-", "tty", "client", "input", "stream", "and", "if", "so", "returns", "an", "error", "." ]

[ "func", "NewIn", "(", "in", "io", ".", "ReadCloser", ")", "*", "In", "{", "fd", ",", "isTerminal", ":=", "term", ".", "GetFdInfo", "(", "in", ")", "\n", "return", "&", "In", "{", "commonStream", ":", "commonStream", "{", "fd", ":", "fd", ",", "isTerminal", ":", "isTerminal", "}", ",", "in", ":", "in", "}", "\n", "}" ]

[ "NewIn", "returns", "a", "new", "In", "object", "from", "a", "ReadCloser" ]

[ "func", "New", "(", "tag", "string", ")", "*", "template", ".", "Template", "{", "return", "template", ".", "New", "(", "tag", ")", ".", "Funcs", "(", "basicFunctions", ")", "\n", "}" ]

[ "New", "creates", "a", "new", "empty", "template", "with", "the", "provided", "tag", "and", "built", "-", "in", "template", "functions", "." ]

[ "func", "(", "lw", "*", "logWriter", ")", "parseContext", "(", "details", "map", "[", "string", "]", "string", ")", "(", "logContext", ",", "error", ")", "{", "nodeID", ",", "ok", ":=", "details", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "logContext", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "details", ")", "\n", "}", "\n", "delete", "(", "details", ",", "\"", "\"", ")", "\n\n", "serviceID", ",", "ok", ":=", "details", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "logContext", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "details", ")", "\n", "}", "\n", "delete", "(", "details", ",", "\"", "\"", ")", "\n\n", "taskID", ",", "ok", ":=", "details", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "logContext", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "details", ")", "\n", "}", "\n", "delete", "(", "details", ",", "\"", "\"", ")", "\n\n", "return", "logContext", "{", "nodeID", ":", "nodeID", ",", "serviceID", ":", "serviceID", ",", "taskID", ":", "taskID", ",", "}", ",", "nil", "\n", "}" ]

[ "parseContext", "returns", "a", "log", "context", "and", "REMOVES", "the", "context", "from", "the", "details", "map" ]

[ "func", "New", "(", "dir", "string", ",", "cfg", "Config", ")", "Store", "{", "metaRoot", ":=", "filepath", ".", "Join", "(", "dir", ",", "metadataDir", ")", "\n", "tlsRoot", ":=", "filepath", ".", "Join", "(", "dir", ",", "tlsDir", ")", "\n\n", "return", "&", "store", "{", "meta", ":", "&", "metadataStore", "{", "root", ":", "metaRoot", ",", "config", ":", "cfg", ",", "}", ",", "tls", ":", "&", "tlsStore", "{", "root", ":", "tlsRoot", ",", "}", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "store", "from", "a", "given", "directory", ".", "If", "the", "directory", "does", "not", "exist", "or", "is", "empty", "initialize", "it" ]

[ "func", "Import", "(", "name", "string", ",", "s", "Writer", ",", "reader", "io", ".", "Reader", ")", "error", "{", "tr", ":=", "tar", ".", "NewReader", "(", "reader", ")", "\n", "tlsData", ":=", "ContextTLSData", "{", "Endpoints", ":", "map", "[", "string", "]", "EndpointTLSData", "{", "}", ",", "}", "\n", "for", "{", "hdr", ",", "err", ":=", "tr", ".", "Next", "(", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "hdr", ".", "Typeflag", "==", "tar", ".", "TypeDir", "{", "// skip this entry, only taking files into account", "continue", "\n", "}", "\n", "if", "hdr", ".", "Name", "==", "metaFile", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "tr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "var", "meta", "Metadata", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "meta", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "meta", ".", "Name", "=", "name", "\n", "if", "err", ":=", "s", ".", "CreateOrUpdate", "(", "meta", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "if", "strings", ".", "HasPrefix", "(", "hdr", ".", "Name", ",", "\"", "\"", ")", "{", "relative", ":=", "strings", ".", "TrimPrefix", "(", "hdr", ".", "Name", ",", "\"", "\"", ")", "\n", "parts", ":=", "strings", ".", "SplitN", "(", "relative", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "endpointName", ":=", "parts", "[", "0", "]", "\n", "fileName", ":=", "parts", "[", "1", "]", "\n", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "tr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "tlsData", ".", "Endpoints", "[", "endpointName", "]", ";", "!", "ok", "{", "tlsData", ".", "Endpoints", "[", "endpointName", "]", "=", "EndpointTLSData", "{", "Files", ":", "map", "[", "string", "]", "[", "]", "byte", "{", "}", ",", "}", "\n", "}", "\n", "tlsData", ".", "Endpoints", "[", "endpointName", "]", ".", "Files", "[", "fileName", "]", "=", "data", "\n", "}", "\n", "}", "\n", "return", "s", ".", "ResetTLSMaterial", "(", "name", ",", "&", "tlsData", ")", "\n", "}" ]

[ "Import", "imports", "an", "exported", "context", "into", "a", "store" ]

[ "func", "TagWrite", "(", "ctx", "formatter", ".", "Context", ",", "signedTagInfoList", "[", "]", "SignedTagInfo", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "signedTag", ":=", "range", "signedTagInfoList", "{", "if", "err", ":=", "format", "(", "&", "trustTagContext", "{", "s", ":", "signedTag", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "trustTagCtx", ":=", "trustTagContext", "{", "}", "\n", "trustTagCtx", ".", "Header", "=", "formatter", ".", "SubHeaderContext", "{", "\"", "\"", ":", "signedTagNameHeader", ",", "\"", "\"", ":", "trustedDigestHeader", ",", "\"", "\"", ":", "signersHeader", ",", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "trustTagCtx", ",", "render", ")", "\n", "}" ]

[ "TagWrite", "writes", "the", "context" ]

[ "func", "(", "c", "*", "trustTagContext", ")", "Signers", "(", ")", "string", "{", "sort", ".", "Strings", "(", "c", ".", "s", ".", "Signers", ")", "\n", "return", "strings", ".", "Join", "(", "c", ".", "s", ".", "Signers", ",", "\"", "\"", ")", "\n", "}" ]

[ "Signers", "returns", "the", "sorted", "list", "of", "entities", "who", "signed", "this", "tag" ]

[ "func", "SignerInfoWrite", "(", "ctx", "formatter", ".", "Context", ",", "signerInfoList", "[", "]", "SignerInfo", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "signerInfo", ":=", "range", "signerInfoList", "{", "if", "err", ":=", "format", "(", "&", "signerInfoContext", "{", "trunc", ":", "ctx", ".", "Trunc", ",", "s", ":", "signerInfo", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "signerInfoCtx", ":=", "signerInfoContext", "{", "}", "\n", "signerInfoCtx", ".", "Header", "=", "formatter", ".", "SubHeaderContext", "{", "\"", "\"", ":", "signerNameHeader", ",", "\"", "\"", ":", "keysHeader", ",", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "signerInfoCtx", ",", "render", ")", "\n", "}" ]

[ "SignerInfoWrite", "writes", "the", "context" ]

[ "func", "(", "c", "*", "signerInfoContext", ")", "Keys", "(", ")", "string", "{", "sort", ".", "Strings", "(", "c", ".", "s", ".", "Keys", ")", "\n", "truncatedKeys", ":=", "[", "]", "string", "{", "}", "\n", "if", "c", ".", "trunc", "{", "for", "_", ",", "keyID", ":=", "range", "c", ".", "s", ".", "Keys", "{", "truncatedKeys", "=", "append", "(", "truncatedKeys", ",", "stringid", ".", "TruncateID", "(", "keyID", ")", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "truncatedKeys", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "c", ".", "s", ".", "Keys", ",", "\"", "\"", ")", "\n", "}" ]

[ "Keys", "returns", "the", "sorted", "list", "of", "keys", "associated", "with", "the", "signer" ]

[ "func", "NewContainerCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "command", ".", "ShowHelp", "(", "dockerCli", ".", "Err", "(", ")", ")", ",", "}", "\n", "cmd", ".", "AddCommand", "(", "NewAttachCommand", "(", "dockerCli", ")", ",", "NewCommitCommand", "(", "dockerCli", ")", ",", "NewCopyCommand", "(", "dockerCli", ")", ",", "NewCreateCommand", "(", "dockerCli", ")", ",", "NewDiffCommand", "(", "dockerCli", ")", ",", "NewExecCommand", "(", "dockerCli", ")", ",", "NewExportCommand", "(", "dockerCli", ")", ",", "NewKillCommand", "(", "dockerCli", ")", ",", "NewLogsCommand", "(", "dockerCli", ")", ",", "NewPauseCommand", "(", "dockerCli", ")", ",", "NewPortCommand", "(", "dockerCli", ")", ",", "NewRenameCommand", "(", "dockerCli", ")", ",", "NewRestartCommand", "(", "dockerCli", ")", ",", "NewRmCommand", "(", "dockerCli", ")", ",", "NewRunCommand", "(", "dockerCli", ")", ",", "NewStartCommand", "(", "dockerCli", ")", ",", "NewStatsCommand", "(", "dockerCli", ")", ",", "NewStopCommand", "(", "dockerCli", ")", ",", "NewTopCommand", "(", "dockerCli", ")", ",", "NewUnpauseCommand", "(", "dockerCli", ")", ",", "NewUpdateCommand", "(", "dockerCli", ")", ",", "NewWaitCommand", "(", "dockerCli", ")", ",", "newListCommand", "(", "dockerCli", ")", ",", "newInspectCommand", "(", "dockerCli", ")", ",", "NewPruneCommand", "(", "dockerCli", ")", ",", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewContainerCommand", "returns", "a", "cobra", "command", "for", "container", "subcommands" ]

[ "func", "RunConfigList", "(", "dockerCli", "command", ".", "Cli", ",", "options", "ListOptions", ")", "error", "{", "client", ":=", "dockerCli", ".", "Client", "(", ")", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n\n", "configs", ",", "err", ":=", "client", ".", "ConfigList", "(", "ctx", ",", "types", ".", "ConfigListOptions", "{", "Filters", ":", "options", ".", "Filter", ".", "Value", "(", ")", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "format", ":=", "options", ".", "Format", "\n", "if", "len", "(", "format", ")", "==", "0", "{", "if", "len", "(", "dockerCli", ".", "ConfigFile", "(", ")", ".", "ConfigFormat", ")", ">", "0", "&&", "!", "options", ".", "Quiet", "{", "format", "=", "dockerCli", ".", "ConfigFile", "(", ")", ".", "ConfigFormat", "\n", "}", "else", "{", "format", "=", "formatter", ".", "TableFormatKey", "\n", "}", "\n", "}", "\n\n", "sort", ".", "Slice", "(", "configs", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "sortorder", ".", "NaturalLess", "(", "configs", "[", "i", "]", ".", "Spec", ".", "Name", ",", "configs", "[", "j", "]", ".", "Spec", ".", "Name", ")", "\n", "}", ")", "\n\n", "configCtx", ":=", "formatter", ".", "Context", "{", "Output", ":", "dockerCli", ".", "Out", "(", ")", ",", "Format", ":", "NewFormat", "(", "format", ",", "options", ".", "Quiet", ")", ",", "}", "\n", "return", "FormatWrite", "(", "configCtx", ",", "configs", ")", "\n", "}" ]

[ "RunConfigList", "lists", "Swarm", "configs", "." ]

[ "func", "DetectDefaultStore", "(", "store", "string", ")", "string", "{", "platformDefault", ":=", "defaultCredentialsStore", "(", ")", "\n\n", "// user defined or no default for platform", "if", "store", "!=", "\"", "\"", "||", "platformDefault", "==", "\"", "\"", "{", "return", "store", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "exec", ".", "LookPath", "(", "remoteCredentialsPrefix", "+", "platformDefault", ")", ";", "err", "==", "nil", "{", "return", "platformDefault", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "DetectDefaultStore", "return", "the", "default", "credentials", "store", "for", "the", "platform", "if", "the", "store", "executable", "is", "available", "." ]

[ "func", "NewPullCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "PullOptions", "\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", "RunPull", "(", "dockerCli", ",", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "all", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "quiet", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n\n", "command", ".", "AddPlatformFlag", "(", "flags", ",", "&", "opts", ".", "platform", ")", "\n", "command", ".", "AddTrustVerificationFlags", "(", "flags", ",", "&", "opts", ".", "untrusted", ",", "dockerCli", ".", "ContentTrustEnabled", "(", ")", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewPullCommand", "creates", "a", "new", "docker", "pull", "command" ]

[ "func", "RunPull", "(", "cli", "command", ".", "Cli", ",", "opts", "PullOptions", ")", "error", "{", "distributionRef", ",", "err", ":=", "reference", ".", "ParseNormalizedNamed", "(", "opts", ".", "remote", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "opts", ".", "all", "&&", "!", "reference", ".", "IsNameOnly", "(", "distributionRef", ")", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "!", "opts", ".", "all", "&&", "reference", ".", "IsNameOnly", "(", "distributionRef", ")", ":", "distributionRef", "=", "reference", ".", "TagNameOnly", "(", "distributionRef", ")", "\n", "if", "tagged", ",", "ok", ":=", "distributionRef", ".", "(", "reference", ".", "Tagged", ")", ";", "ok", "&&", "!", "opts", ".", "quiet", "{", "fmt", ".", "Fprintf", "(", "cli", ".", "Out", "(", ")", ",", "\"", "\\n", "\"", ",", "tagged", ".", "Tag", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n", "imgRefAndAuth", ",", "err", ":=", "trust", ".", "GetImageReferencesAndAuth", "(", "ctx", ",", "nil", ",", "AuthResolver", "(", "cli", ")", ",", "distributionRef", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Check if reference has a digest", "_", ",", "isCanonical", ":=", "distributionRef", ".", "(", "reference", ".", "Canonical", ")", "\n", "if", "!", "opts", ".", "untrusted", "&&", "!", "isCanonical", "{", "err", "=", "trustedPull", "(", "ctx", ",", "cli", ",", "imgRefAndAuth", ",", "opts", ")", "\n", "}", "else", "{", "err", "=", "imagePullPrivileged", "(", "ctx", ",", "cli", ",", "imgRefAndAuth", ",", "opts", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "if", "strings", ".", "Contains", "(", "err", ".", "Error", "(", ")", ",", "\"", "\"", ")", "{", "return", "errors", ".", "New", "(", "err", ".", "Error", "(", ")", "+", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "fmt", ".", "Fprintln", "(", "cli", ".", "Out", "(", ")", ",", "imgRefAndAuth", ".", "Reference", "(", ")", ".", "String", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "RunPull", "performs", "a", "pull", "against", "the", "engine", "based", "on", "the", "specified", "options" ]

[ "func", "NewLogoutCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Long", ":", "\"", "\\n", "\"", ",", "Args", ":", "cli", ".", "RequiresMaxArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "var", "serverAddress", "string", "\n", "if", "len", "(", "args", ")", ">", "0", "{", "serverAddress", "=", "args", "[", "0", "]", "\n", "}", "\n", "return", "runLogout", "(", "dockerCli", ",", "serverAddress", ")", "\n", "}", ",", "}", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewLogoutCommand", "creates", "a", "new", "docker", "logout", "command" ]

[ "func", "WithStandardStreams", "(", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "// Set terminal emulation based on platform as required.", "stdin", ",", "stdout", ",", "stderr", ":=", "term", ".", "StdStreams", "(", ")", "\n", "cli", ".", "in", "=", "streams", ".", "NewIn", "(", "stdin", ")", "\n", "cli", ".", "out", "=", "streams", ".", "NewOut", "(", "stdout", ")", "\n", "cli", ".", "err", "=", "stderr", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithStandardStreams", "sets", "a", "cli", "in", "out", "and", "err", "streams", "with", "the", "standard", "streams", "." ]

[ "func", "WithCombinedStreams", "(", "combined", "io", ".", "Writer", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "cli", ".", "out", "=", "streams", ".", "NewOut", "(", "combined", ")", "\n", "cli", ".", "err", "=", "combined", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithCombinedStreams", "uses", "the", "same", "stream", "for", "the", "output", "and", "error", "streams", "." ]

[ "func", "WithInputStream", "(", "in", "io", ".", "ReadCloser", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "cli", ".", "in", "=", "streams", ".", "NewIn", "(", "in", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithInputStream", "sets", "a", "cli", "input", "stream", "." ]

[ "func", "WithOutputStream", "(", "out", "io", ".", "Writer", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "cli", ".", "out", "=", "streams", ".", "NewOut", "(", "out", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithOutputStream", "sets", "a", "cli", "output", "stream", "." ]

[ "func", "WithErrorStream", "(", "err", "io", ".", "Writer", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "cli", ".", "err", "=", "err", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithErrorStream", "sets", "a", "cli", "error", "stream", "." ]

[ "func", "WithContentTrustFromEnv", "(", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "cli", ".", "contentTrust", "=", "false", "\n", "if", "e", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", ";", "e", "!=", "\"", "\"", "{", "if", "t", ",", "err", ":=", "strconv", ".", "ParseBool", "(", "e", ")", ";", "t", "||", "err", "!=", "nil", "{", "// treat any other value as true", "cli", ".", "contentTrust", "=", "true", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithContentTrustFromEnv", "enables", "content", "trust", "on", "a", "cli", "from", "environment", "variable", "DOCKER_CONTENT_TRUST", "value", "." ]

[ "func", "WithContentTrust", "(", "enabled", "bool", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "cli", ".", "contentTrust", "=", "enabled", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithContentTrust", "enables", "content", "trust", "on", "a", "cli", "." ]

[ "func", "WithContainerizedClient", "(", "containerizedFn", "func", "(", "string", ")", "(", "clitypes", ".", "ContainerizedClient", ",", "error", ")", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "cli", ".", "newContainerizeClient", "=", "containerizedFn", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithContainerizedClient", "sets", "the", "containerized", "client", "constructor", "on", "a", "cli", "." ]

[ "func", "WithContextEndpointType", "(", "endpointName", "string", ",", "endpointType", "store", ".", "TypeGetter", ")", "DockerCliOption", "{", "return", "func", "(", "cli", "*", "DockerCli", ")", "error", "{", "switch", "endpointName", "{", "case", "docker", ".", "DockerEndpoint", ",", "kubernetes", ".", "KubernetesEndpoint", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "endpointName", ")", "\n", "}", "\n", "cli", ".", "contextStoreConfig", ".", "SetEndpoint", "(", "endpointName", ",", "endpointType", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithContextEndpointType", "add", "support", "for", "an", "additional", "typed", "endpoint", "in", "the", "context", "store", "Plugins", "should", "use", "this", "to", "store", "additional", "endpoints", "configuration", "in", "the", "context", "store" ]

[ "func", "NewVersionCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "versionOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "return", "runVersion", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "StringVarP", "(", "&", "opts", ".", "format", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "opts", ".", "kubeConfig", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "SetAnnotation", "(", "\"", "\"", ",", "\"", "\"", ",", "nil", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewVersionCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "version" ]

[ "func", "RootRotationProgress", "(", "ctx", "context", ".", "Context", ",", "dclient", "client", ".", "APIClient", ",", "progressWriter", "io", ".", "WriteCloser", ")", "error", "{", "defer", "progressWriter", ".", "Close", "(", ")", "\n\n", "progressOut", ":=", "streamformatter", ".", "NewJSONProgressOutput", "(", "progressWriter", ",", "false", ")", "\n\n", "sigint", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "sigint", ",", "os", ".", "Interrupt", ")", "\n", "defer", "signal", ".", "Stop", "(", "sigint", ")", "\n\n", "// draw 2 progress bars, 1 for nodes with the correct cert, 1 for nodes with the correct trust root", "progress", ".", "Update", "(", "progressOut", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "progress", ".", "Update", "(", "progressOut", ",", "certsRotatedStr", ",", "certsAction", ")", "\n", "progress", ".", "Update", "(", "progressOut", ",", "rootsRotatedStr", ",", "rootsAction", ")", "\n\n", "var", "done", "bool", "\n\n", "for", "{", "info", ",", "err", ":=", "dclient", ".", "SwarmInspect", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "done", "{", "return", "nil", "\n", "}", "\n\n", "nodes", ",", "err", ":=", "dclient", ".", "NodeList", "(", "ctx", ",", "types", ".", "NodeListOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "done", "=", "updateProgress", "(", "progressOut", ",", "info", ".", "ClusterInfo", ".", "TLSInfo", ",", "nodes", ",", "info", ".", "ClusterInfo", ".", "RootRotationInProgress", ")", "\n\n", "select", "{", "case", "<-", "time", ".", "After", "(", "200", "*", "time", ".", "Millisecond", ")", ":", "case", "<-", "sigint", ":", "if", "!", "done", "{", "progress", ".", "Message", "(", "progressOut", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "progress", ".", "Message", "(", "progressOut", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "RootRotationProgress", "outputs", "progress", "information", "for", "convergence", "of", "a", "root", "rotation", "." ]

[ "func", "(", "c", "*", "baseClient", ")", "ActivateEngine", "(", "ctx", "context", ".", "Context", ",", "opts", "clitypes", ".", "EngineInitOptions", ",", "out", "clitypes", ".", "OutStream", ",", "authConfig", "*", "types", ".", "AuthConfig", ")", "error", "{", "// If the user didn't specify an image, determine the correct enterprise image to use", "if", "opts", ".", "EngineImage", "==", "\"", "\"", "{", "localMetadata", ",", "err", ":=", "versions", ".", "GetCurrentRuntimeMetadata", "(", "opts", ".", "RuntimeMetadataDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "engineImage", ":=", "localMetadata", ".", "EngineImage", "\n", "if", "engineImage", "==", "clitypes", ".", "EnterpriseEngineImage", "||", "engineImage", "==", "clitypes", ".", "CommunityEngineImage", "{", "opts", ".", "EngineImage", "=", "clitypes", ".", "EnterpriseEngineImage", "\n", "}", "else", "{", "// Chop off the standard prefix and retain any trailing OS specific image details", "// e.g., engine-community-dm -> engine-enterprise-dm", "engineImage", "=", "strings", ".", "TrimPrefix", "(", "engineImage", ",", "clitypes", ".", "EnterpriseEngineImage", ")", "\n", "engineImage", "=", "strings", ".", "TrimPrefix", "(", "engineImage", ",", "clitypes", ".", "CommunityEngineImage", ")", "\n", "opts", ".", "EngineImage", "=", "clitypes", ".", "EnterpriseEngineImage", "+", "engineImage", "\n", "}", "\n", "}", "\n\n", "ctx", "=", "namespaces", ".", "WithNamespace", "(", "ctx", ",", "engineNamespace", ")", "\n", "return", "c", ".", "DoUpdate", "(", "ctx", ",", "opts", ",", "out", ",", "authConfig", ")", "\n", "}" ]

[ "ActivateEngine", "will", "switch", "the", "image", "from", "the", "CE", "to", "EE", "image" ]

[ "func", "(", "c", "*", "baseClient", ")", "DoUpdate", "(", "ctx", "context", ".", "Context", ",", "opts", "clitypes", ".", "EngineInitOptions", ",", "out", "clitypes", ".", "OutStream", ",", "authConfig", "*", "types", ".", "AuthConfig", ")", "error", "{", "ctx", "=", "namespaces", ".", "WithNamespace", "(", "ctx", ",", "engineNamespace", ")", "\n", "if", "opts", ".", "EngineVersion", "==", "\"", "\"", "{", "// TODO - Future enhancement: This could be improved to be", "// smart about figuring out the latest patch rev for the", "// current engine version and automatically apply it so users", "// could stay in sync by simply having a scheduled", "// `docker engine update`", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "localMetadata", "*", "clitypes", ".", "RuntimeMetadata", "\n", "if", "opts", ".", "EngineImage", "==", "\"", "\"", "{", "var", "err", "error", "\n", "localMetadata", ",", "err", "=", "versions", ".", "GetCurrentRuntimeMetadata", "(", "opts", ".", "RuntimeMetadataDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "opts", ".", "EngineImage", "=", "localMetadata", ".", "EngineImage", "\n", "}", "\n\n", "imageName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "opts", ".", "RegistryPrefix", ",", "opts", ".", "EngineImage", ",", "opts", ".", "EngineVersion", ")", "\n\n", "// Look for desired image", "image", ",", "err", ":=", "c", ".", "cclient", ".", "GetImage", "(", "ctx", ",", "imageName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errdefs", ".", "IsNotFound", "(", "err", ")", "{", "image", ",", "err", "=", "c", ".", "pullWithAuth", "(", "ctx", ",", "imageName", ",", "out", ",", "authConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "imageName", ")", "\n", "}", "\n", "}", "else", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "imageName", ")", "\n", "}", "\n", "}", "\n\n", "// Make sure we're safe to proceed", "newMetadata", ",", "err", ":=", "c", ".", "PreflightCheck", "(", "ctx", ",", "image", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "localMetadata", "!=", "nil", "{", "if", "localMetadata", ".", "Platform", "!=", "newMetadata", ".", "Platform", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\n", "\\\"", "\\\"", "\\n", "\\n", "\"", ",", "newMetadata", ".", "Platform", ",", "getReleaseNotesURL", "(", "imageName", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "cclient", ".", "Install", "(", "ctx", ",", "image", ",", "containerd", ".", "WithInstallReplace", ",", "containerd", ".", "WithInstallPath", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "versions", ".", "WriteRuntimeMetadata", "(", "opts", ".", "RuntimeMetadataDir", ",", "newMetadata", ")", "\n", "}" ]

[ "DoUpdate", "performs", "the", "underlying", "engine", "update" ]

[ "func", "getReleaseNotesURL", "(", "imageName", "string", ")", "string", "{", "versionTag", ":=", "\"", "\"", "\n", "distributionRef", ",", "err", ":=", "reference", ".", "ParseNormalizedNamed", "(", "imageName", ")", "\n", "if", "err", "==", "nil", "{", "taggedRef", ",", "ok", ":=", "distributionRef", ".", "(", "reference", ".", "NamedTagged", ")", "\n", "if", "ok", "{", "versionTag", "=", "taggedRef", ".", "Tag", "(", ")", "\n", "}", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "clitypes", ".", "ReleaseNotePrefix", ",", "versionTag", ")", "\n", "}" ]

[ "getReleaseNotesURL", "returns", "a", "release", "notes", "url", "If", "the", "image", "name", "does", "not", "contain", "a", "version", "tag", "the", "base", "release", "notes", "URL", "is", "returned" ]

[ "func", "RunImport", "(", "dockerCli", "command", ".", "Cli", ",", "name", "string", ",", "source", "string", ")", "error", "{", "if", "err", ":=", "checkContextNameForCreation", "(", "dockerCli", ".", "ContextStore", "(", ")", ",", "name", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "var", "reader", "io", ".", "Reader", "\n", "if", "source", "==", "\"", "\"", "{", "reader", "=", "dockerCli", ".", "In", "(", ")", "\n", "}", "else", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "source", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "reader", "=", "f", "\n", "}", "\n\n", "if", "err", ":=", "store", ".", "Import", "(", "name", ",", "dockerCli", ".", "ContextStore", "(", ")", ",", "reader", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fmt", ".", "Fprintln", "(", "dockerCli", ".", "Out", "(", ")", ",", "name", ")", "\n", "fmt", ".", "Fprintf", "(", "dockerCli", ".", "Err", "(", ")", ",", "\"", "\\n", "\"", ",", "name", ")", "\n", "return", "nil", "\n", "}" ]

[ "RunImport", "imports", "a", "Docker", "context" ]

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

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

[ "func", "SearchWrite", "(", "ctx", "formatter", ".", "Context", ",", "results", "[", "]", "registry", ".", "SearchResult", ",", "auto", "bool", ",", "stars", "int", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "result", ":=", "range", "results", "{", "// --automated and -s, --stars are deprecated since Docker 1.12", "if", "(", "auto", "&&", "!", "result", ".", "IsAutomated", ")", "||", "(", "stars", ">", "result", ".", "StarCount", ")", "{", "continue", "\n", "}", "\n", "searchCtx", ":=", "&", "searchContext", "{", "trunc", ":", "ctx", ".", "Trunc", ",", "s", ":", "result", "}", "\n", "if", "err", ":=", "format", "(", "searchCtx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "searchCtx", ":=", "searchContext", "{", "}", "\n", "searchCtx", ".", "Header", "=", "formatter", ".", "SubHeaderContext", "{", "\"", "\"", ":", "formatter", ".", "NameHeader", ",", "\"", "\"", ":", "formatter", ".", "DescriptionHeader", ",", "\"", "\"", ":", "starsHeader", ",", "\"", "\"", ":", "officialHeader", ",", "\"", "\"", ":", "automatedHeader", ",", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "searchCtx", ",", "render", ")", "\n", "}" ]

[ "SearchWrite", "writes", "the", "context" ]

[ "func", "GetDockerContext", "(", "storeMetadata", "store", ".", "Metadata", ")", "(", "DockerContext", ",", "error", ")", "{", "if", "storeMetadata", ".", "Metadata", "==", "nil", "{", "// can happen if we save endpoints before assigning a context metadata", "// it is totally valid, and we should return a default initialized value", "return", "DockerContext", "{", "}", ",", "nil", "\n", "}", "\n", "res", ",", "ok", ":=", "storeMetadata", ".", "Metadata", ".", "(", "DockerContext", ")", "\n", "if", "!", "ok", "{", "return", "DockerContext", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "GetDockerContext", "extracts", "metadata", "from", "stored", "context", "metadata" ]

[ "func", "RunPs", "(", "dockerCli", "command", ".", "Cli", ",", "flags", "*", "pflag", ".", "FlagSet", ",", "commonOrchestrator", "command", ".", "Orchestrator", ",", "opts", "options", ".", "PS", ")", "error", "{", "return", "runOrchestratedCommand", "(", "dockerCli", ",", "flags", ",", "commonOrchestrator", ",", "func", "(", ")", "error", "{", "return", "swarm", ".", "RunPS", "(", "dockerCli", ",", "opts", ")", "}", ",", "func", "(", "kli", "*", "kubernetes", ".", "KubeCli", ")", "error", "{", "return", "kubernetes", ".", "RunPS", "(", "kli", ",", "opts", ")", "}", ")", "\n", "}" ]

[ "RunPs", "performs", "a", "stack", "ps", "against", "the", "specified", "orchestrator" ]

[ "func", "AtomicImageUpdate", "(", "ctx", "context", ".", "Context", ",", "container", "containerd", ".", "Container", ",", "image", "containerd", ".", "Image", ",", "healthcheckFn", "func", "(", ")", "error", ")", "error", "{", "updateCompleted", ":=", "false", "\n", "err", ":=", "pauseAndRun", "(", "ctx", ",", "container", ",", "func", "(", ")", "error", "{", "if", "err", ":=", "container", ".", "Update", "(", "ctx", ",", "WithUpgrade", "(", "image", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "updateCompleted", "=", "true", "\n", "task", ",", "err", ":=", "container", ".", "Task", "(", "ctx", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errdefs", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "task", ".", "Kill", "(", "ctx", ",", "sigTERM", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "if", "updateCompleted", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "rollBack", "(", "ctx", ",", "container", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "if", "err", ":=", "healthcheckFn", "(", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "rollBack", "(", "ctx", ",", "container", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AtomicImageUpdate", "will", "perform", "an", "update", "of", "the", "given", "container", "with", "the", "new", "image", "and", "verify", "success", "via", "the", "provided", "healthcheckFn", ".", "If", "the", "healthcheck", "fails", "the", "container", "will", "be", "reverted", "to", "the", "prior", "image" ]

[ "func", "ValidateThrottleBpsDevice", "(", "val", "string", ")", "(", "*", "blkiodev", ".", "ThrottleDevice", ",", "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", "rate", ",", "err", ":=", "units", ".", "RAMInBytes", "(", "split", "[", "1", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n", "if", "rate", "<", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n\n", "return", "&", "blkiodev", ".", "ThrottleDevice", "{", "Path", ":", "split", "[", "0", "]", ",", "Rate", ":", "uint64", "(", "rate", ")", ",", "}", ",", "nil", "\n", "}" ]

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

[ "func", "ValidateThrottleIOpsDevice", "(", "val", "string", ")", "(", "*", "blkiodev", ".", "ThrottleDevice", ",", "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", "rate", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "split", "[", "1", "]", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n", "if", "rate", "<", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ")", "\n", "}", "\n\n", "return", "&", "blkiodev", ".", "ThrottleDevice", "{", "Path", ":", "split", "[", "0", "]", ",", "Rate", ":", "rate", "}", ",", "nil", "\n", "}" ]

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

[ "func", "NewThrottledeviceOpt", "(", "validator", "ValidatorThrottleFctType", ")", "ThrottledeviceOpt", "{", "values", ":=", "[", "]", "*", "blkiodev", ".", "ThrottleDevice", "{", "}", "\n", "return", "ThrottledeviceOpt", "{", "values", ":", "values", ",", "validator", ":", "validator", ",", "}", "\n", "}" ]

[ "NewThrottledeviceOpt", "creates", "a", "new", "ThrottledeviceOpt" ]

[ "func", "(", "opt", "*", "ThrottledeviceOpt", ")", "Set", "(", "val", "string", ")", "error", "{", "var", "value", "*", "blkiodev", ".", "ThrottleDevice", "\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", "ThrottleDevice", "and", "sets", "its", "name", "as", "a", "key", "in", "ThrottledeviceOpt" ]

[ "func", "(", "opt", "*", "ThrottledeviceOpt", ")", "String", "(", ")", "string", "{", "var", "out", "[", "]", "string", "\n", "for", "_", ",", "v", ":=", "range", "opt", ".", "values", "{", "out", "=", "append", "(", "out", ",", "v", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "out", ")", "\n", "}" ]

[ "String", "returns", "ThrottledeviceOpt", "values", "as", "a", "string", "." ]

[ "func", "(", "opt", "*", "ThrottledeviceOpt", ")", "GetList", "(", ")", "[", "]", "*", "blkiodev", ".", "ThrottleDevice", "{", "var", "throttledevice", "[", "]", "*", "blkiodev", ".", "ThrottleDevice", "\n", "throttledevice", "=", "append", "(", "throttledevice", ",", "opt", ".", "values", "...", ")", "\n\n", "return", "throttledevice", "\n", "}" ]

[ "GetList", "returns", "a", "slice", "of", "pointers", "to", "ThrottleDevices", "." ]

[ "func", "NewStopCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "stopOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMinArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "containers", "=", "args", "\n", "opts", ".", "timeChanged", "=", "cmd", ".", "Flags", "(", ")", ".", "Changed", "(", "\"", "\"", ")", "\n", "return", "runStop", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "IntVarP", "(", "&", "opts", ".", "time", ",", "\"", "\"", ",", "\"", "\"", ",", "10", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewStopCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "stop" ]

[ "func", "GetStacks", "(", "kubeCli", "*", "KubeCli", ",", "opts", "options", ".", "List", ")", "(", "[", "]", "*", "formatter", ".", "Stack", ",", "error", ")", "{", "if", "opts", ".", "AllNamespaces", "||", "len", "(", "opts", ".", "Namespaces", ")", "==", "0", "{", "if", "isAllNamespacesDisabled", "(", "kubeCli", ".", "ConfigFile", "(", ")", ".", "Kubernetes", ")", "{", "opts", ".", "AllNamespaces", "=", "true", "\n", "}", "\n", "return", "getStacksWithAllNamespaces", "(", "kubeCli", ",", "opts", ")", "\n", "}", "\n", "return", "getStacksWithNamespaces", "(", "kubeCli", ",", "opts", ",", "removeDuplicates", "(", "opts", ".", "Namespaces", ")", ")", "\n", "}" ]

[ "GetStacks", "lists", "the", "kubernetes", "stacks" ]

[ "func", "NewRegistryClient", "(", "resolver", "AuthConfigResolver", ",", "userAgent", "string", ",", "insecure", "bool", ")", "RegistryClient", "{", "return", "&", "client", "{", "authConfigResolver", ":", "resolver", ",", "insecureRegistry", ":", "insecure", ",", "userAgent", ":", "userAgent", ",", "}", "\n", "}" ]

[ "NewRegistryClient", "returns", "a", "new", "RegistryClient", "with", "a", "resolver" ]

[ "func", "(", "c", "*", "client", ")", "MountBlob", "(", "ctx", "context", ".", "Context", ",", "sourceRef", "reference", ".", "Canonical", ",", "targetRef", "reference", ".", "Named", ")", "error", "{", "repoEndpoint", ",", "err", ":=", "newDefaultRepositoryEndpoint", "(", "targetRef", ",", "c", ".", "insecureRegistry", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "repo", ",", "err", ":=", "c", ".", "getRepositoryForReference", "(", "ctx", ",", "targetRef", ",", "repoEndpoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "lu", ",", "err", ":=", "repo", ".", "Blobs", "(", "ctx", ")", ".", "Create", "(", "ctx", ",", "distributionclient", ".", "WithMountFrom", "(", "sourceRef", ")", ")", "\n", "switch", "err", ".", "(", "type", ")", "{", "case", "distribution", ".", "ErrBlobMounted", ":", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "sourceRef", ")", "\n", "return", "nil", "\n", "case", "nil", ":", "default", ":", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "sourceRef", ",", "targetRef", ")", "\n", "}", "\n", "lu", ".", "Cancel", "(", "ctx", ")", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "sourceRef", ")", "\n", "return", "ErrBlobCreated", "{", "From", ":", "sourceRef", ",", "Target", ":", "targetRef", "}", "\n", "}" ]

[ "MountBlob", "into", "the", "registry", "so", "it", "can", "be", "referenced", "by", "a", "manifest" ]

[ "func", "(", "c", "*", "client", ")", "PutManifest", "(", "ctx", "context", ".", "Context", ",", "ref", "reference", ".", "Named", ",", "manifest", "distribution", ".", "Manifest", ")", "(", "digest", ".", "Digest", ",", "error", ")", "{", "repoEndpoint", ",", "err", ":=", "newDefaultRepositoryEndpoint", "(", "ref", ",", "c", ".", "insecureRegistry", ")", "\n", "if", "err", "!=", "nil", "{", "return", "digest", ".", "Digest", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n\n", "repo", ",", "err", ":=", "c", ".", "getRepositoryForReference", "(", "ctx", ",", "ref", ",", "repoEndpoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "digest", ".", "Digest", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n\n", "manifestService", ",", "err", ":=", "repo", ".", "Manifests", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "digest", ".", "Digest", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n\n", "_", ",", "opts", ",", "err", ":=", "getManifestOptionsFromReference", "(", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "return", "digest", ".", "Digest", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n\n", "dgst", ",", "err", ":=", "manifestService", ".", "Put", "(", "ctx", ",", "manifest", ",", "opts", "...", ")", "\n", "return", "dgst", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "ref", ")", "\n", "}" ]

[ "PutManifest", "sends", "the", "manifest", "to", "a", "registry", "and", "returns", "the", "new", "digest" ]

[ "func", "(", "c", "*", "client", ")", "GetManifest", "(", "ctx", "context", ".", "Context", ",", "ref", "reference", ".", "Named", ")", "(", "manifesttypes", ".", "ImageManifest", ",", "error", ")", "{", "var", "result", "manifesttypes", ".", "ImageManifest", "\n", "fetch", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "repo", "distribution", ".", "Repository", ",", "ref", "reference", ".", "Named", ")", "(", "bool", ",", "error", ")", "{", "var", "err", "error", "\n", "result", ",", "err", "=", "fetchManifest", "(", "ctx", ",", "repo", ",", "ref", ")", "\n", "return", "result", ".", "Ref", "!=", "nil", ",", "err", "\n", "}", "\n\n", "err", ":=", "c", ".", "iterateEndpoints", "(", "ctx", ",", "ref", ",", "fetch", ")", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "GetManifest", "returns", "an", "ImageManifest", "for", "the", "reference" ]

[ "func", "(", "c", "*", "client", ")", "GetManifestList", "(", "ctx", "context", ".", "Context", ",", "ref", "reference", ".", "Named", ")", "(", "[", "]", "manifesttypes", ".", "ImageManifest", ",", "error", ")", "{", "result", ":=", "[", "]", "manifesttypes", ".", "ImageManifest", "{", "}", "\n", "fetch", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "repo", "distribution", ".", "Repository", ",", "ref", "reference", ".", "Named", ")", "(", "bool", ",", "error", ")", "{", "var", "err", "error", "\n", "result", ",", "err", "=", "fetchList", "(", "ctx", ",", "repo", ",", "ref", ")", "\n", "return", "len", "(", "result", ")", ">", "0", ",", "err", "\n", "}", "\n\n", "err", ":=", "c", ".", "iterateEndpoints", "(", "ctx", ",", "ref", ",", "fetch", ")", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "GetManifestList", "returns", "a", "list", "of", "ImageManifest", "for", "the", "reference" ]

[ "func", "GetRegistryAuth", "(", "ctx", "context", ".", "Context", ",", "resolver", "AuthConfigResolver", ",", "imageName", "string", ")", "(", "*", "types", ".", "AuthConfig", ",", "error", ")", "{", "distributionRef", ",", "err", ":=", "reference", ".", "ParseNormalizedNamed", "(", "imageName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "imageName", ",", "err", ")", "\n", "}", "\n", "imgRefAndAuth", ",", "err", ":=", "trust", ".", "GetImageReferencesAndAuth", "(", "ctx", ",", "nil", ",", "resolver", ",", "distributionRef", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "imgRefAndAuth", ".", "AuthConfig", "(", ")", ",", "nil", "\n", "}" ]

[ "GetRegistryAuth", "returns", "the", "auth", "config", "given", "an", "input", "image" ]

[ "func", "parseSecurityOpts", "(", "securityOpts", "[", "]", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "for", "key", ",", "opt", ":=", "range", "securityOpts", "{", "con", ":=", "strings", ".", "SplitN", "(", "opt", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "con", ")", "==", "1", "&&", "con", "[", "0", "]", "!=", "\"", "\"", "{", "if", "strings", ".", "Contains", "(", "opt", ",", "\"", "\"", ")", "{", "con", "=", "strings", ".", "SplitN", "(", "opt", ",", "\"", "\"", ",", "2", ")", "\n", "}", "else", "{", "return", "securityOpts", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "opt", ")", "\n", "}", "\n", "}", "\n", "if", "con", "[", "0", "]", "==", "\"", "\"", "&&", "con", "[", "1", "]", "!=", "\"", "\"", "{", "f", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "con", "[", "1", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "securityOpts", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "con", "[", "1", "]", ",", "err", ")", "\n", "}", "\n", "b", ":=", "bytes", ".", "NewBuffer", "(", "nil", ")", "\n", "if", "err", ":=", "json", ".", "Compact", "(", "b", ",", "f", ")", ";", "err", "!=", "nil", "{", "return", "securityOpts", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "con", "[", "1", "]", ",", "err", ")", "\n", "}", "\n", "securityOpts", "[", "key", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ".", "Bytes", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "securityOpts", ",", "nil", "\n", "}" ]

[ "takes", "a", "local", "seccomp", "daemon", "reads", "the", "file", "contents", "for", "sending", "to", "the", "daemon" ]

[ "func", "parseSystemPaths", "(", "securityOpts", "[", "]", "string", ")", "(", "filtered", ",", "maskedPaths", ",", "readonlyPaths", "[", "]", "string", ")", "{", "filtered", "=", "securityOpts", "[", ":", "0", "]", "\n", "for", "_", ",", "opt", ":=", "range", "securityOpts", "{", "if", "opt", "==", "\"", "\"", "{", "maskedPaths", "=", "[", "]", "string", "{", "}", "\n", "readonlyPaths", "=", "[", "]", "string", "{", "}", "\n", "}", "else", "{", "filtered", "=", "append", "(", "filtered", ",", "opt", ")", "\n", "}", "\n", "}", "\n\n", "return", "filtered", ",", "maskedPaths", ",", "readonlyPaths", "\n", "}" ]

[ "parseSystemPaths", "checks", "if", "systempaths", "=", "unconfined", "security", "option", "is", "set", "and", "returns", "the", "MaskedPaths", "and", "ReadonlyPaths", "accordingly", ".", "An", "updated", "list", "of", "security", "options", "is", "returned", "with", "this", "option", "removed", "because", "the", "unconfined", "option", "is", "handled", "client", "-", "side", "and", "should", "not", "be", "sent", "to", "the", "daemon", "." ]

[ "func", "parseStorageOpts", "(", "storageOpts", "[", "]", "string", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "m", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "option", ":=", "range", "storageOpts", "{", "if", "strings", ".", "Contains", "(", "option", ",", "\"", "\"", ")", "{", "opt", ":=", "strings", ".", "SplitN", "(", "option", ",", "\"", "\"", ",", "2", ")", "\n", "m", "[", "opt", "[", "0", "]", "]", "=", "opt", "[", "1", "]", "\n", "}", "else", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "parses", "storage", "options", "per", "container", "into", "a", "map" ]

[ "func", "parseDevice", "(", "device", ",", "serverOS", "string", ")", "(", "container", ".", "DeviceMapping", ",", "error", ")", "{", "switch", "serverOS", "{", "case", "\"", "\"", ":", "return", "parseLinuxDevice", "(", "device", ")", "\n", "case", "\"", "\"", ":", "return", "parseWindowsDevice", "(", "device", ")", "\n", "}", "\n", "return", "container", ".", "DeviceMapping", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "serverOS", ")", "\n", "}" ]

[ "parseDevice", "parses", "a", "device", "mapping", "string", "to", "a", "container", ".", "DeviceMapping", "struct" ]

[ "func", "parseLinuxDevice", "(", "device", "string", ")", "(", "container", ".", "DeviceMapping", ",", "error", ")", "{", "src", ":=", "\"", "\"", "\n", "dst", ":=", "\"", "\"", "\n", "permissions", ":=", "\"", "\"", "\n", "arr", ":=", "strings", ".", "Split", "(", "device", ",", "\"", "\"", ")", "\n", "switch", "len", "(", "arr", ")", "{", "case", "3", ":", "permissions", "=", "arr", "[", "2", "]", "\n", "fallthrough", "\n", "case", "2", ":", "if", "validDeviceMode", "(", "arr", "[", "1", "]", ")", "{", "permissions", "=", "arr", "[", "1", "]", "\n", "}", "else", "{", "dst", "=", "arr", "[", "1", "]", "\n", "}", "\n", "fallthrough", "\n", "case", "1", ":", "src", "=", "arr", "[", "0", "]", "\n", "default", ":", "return", "container", ".", "DeviceMapping", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "device", ")", "\n", "}", "\n\n", "if", "dst", "==", "\"", "\"", "{", "dst", "=", "src", "\n", "}", "\n\n", "deviceMapping", ":=", "container", ".", "DeviceMapping", "{", "PathOnHost", ":", "src", ",", "PathInContainer", ":", "dst", ",", "CgroupPermissions", ":", "permissions", ",", "}", "\n", "return", "deviceMapping", ",", "nil", "\n", "}" ]

[ "parseLinuxDevice", "parses", "a", "device", "mapping", "string", "to", "a", "container", ".", "DeviceMapping", "struct", "knowing", "that", "the", "target", "is", "a", "Linux", "daemon" ]

[ "func", "parseWindowsDevice", "(", "device", "string", ")", "(", "container", ".", "DeviceMapping", ",", "error", ")", "{", "return", "container", ".", "DeviceMapping", "{", "PathOnHost", ":", "device", "}", ",", "nil", "\n", "}" ]

[ "parseWindowsDevice", "parses", "a", "device", "mapping", "string", "to", "a", "container", ".", "DeviceMapping", "struct", "knowing", "that", "the", "target", "is", "a", "Windows", "daemon" ]

[ "func", "validateDevice", "(", "val", "string", ",", "serverOS", "string", ")", "(", "string", ",", "error", ")", "{", "switch", "serverOS", "{", "case", "\"", "\"", ":", "return", "validateLinuxPath", "(", "val", ",", "validDeviceMode", ")", "\n", "case", "\"", "\"", ":", "// Windows does validation entirely server-side", "return", "val", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "serverOS", ")", "\n", "}" ]

[ "validateDevice", "validates", "a", "path", "for", "devices" ]

[ "func", "validateAttach", "(", "val", "string", ")", "(", "string", ",", "error", ")", "{", "s", ":=", "strings", ".", "ToLower", "(", "val", ")", "\n", "for", "_", ",", "str", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "{", "if", "s", "==", "str", "{", "return", "s", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "val", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "validateAttach", "validates", "that", "the", "specified", "string", "is", "a", "valid", "attach", "option", "." ]

[ "func", "NewRunCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "runOptions", "\n", "var", "copts", "*", "containerOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMinArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "copts", ".", "Image", "=", "args", "[", "0", "]", "\n", "if", "len", "(", "args", ")", ">", "1", "{", "copts", ".", "Args", "=", "args", "[", "1", ":", "]", "\n", "}", "\n", "return", "runRun", "(", "dockerCli", ",", "cmd", ".", "Flags", "(", ")", ",", "&", "opts", ",", "copts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "SetInterspersed", "(", "false", ")", "\n\n", "// These are flags not stored in Config/HostConfig", "flags", ".", "BoolVarP", "(", "&", "opts", ".", "detach", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n", "flags", ".", "BoolVar", "(", "&", "opts", ".", "sigProxy", ",", "\"", "\"", ",", "true", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "opts", ".", "name", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "opts", ".", "detachKeys", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "// Add an explicit help that doesn't have a `-h` to prevent the conflict", "// with hostname", "flags", ".", "Bool", "(", "\"", "\"", ",", "false", ",", "\"", "\"", ")", "\n\n", "command", ".", "AddPlatformFlag", "(", "flags", ",", "&", "opts", ".", "platform", ")", "\n", "command", ".", "AddTrustVerificationFlags", "(", "flags", ",", "&", "opts", ".", "untrusted", ",", "dockerCli", ".", "ContentTrustEnabled", "(", ")", ")", "\n", "copts", "=", "addFlags", "(", "flags", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewRunCommand", "create", "a", "new", "docker", "run", "command" ]

[ "func", "reportError", "(", "stderr", "io", ".", "Writer", ",", "name", "string", ",", "str", "string", ",", "withHelp", "bool", ")", "{", "str", "=", "strings", ".", "TrimSuffix", "(", "str", ",", "\"", "\"", ")", "+", "\"", "\"", "\n", "if", "withHelp", "{", "str", "+=", "\"", "\\n", "\"", "+", "os", ".", "Args", "[", "0", "]", "+", "\"", "\"", "+", "name", "+", "\"", "\"", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "os", ".", "Args", "[", "0", "]", ",", "str", ")", "\n", "}" ]

[ "reportError", "is", "a", "utility", "method", "that", "prints", "a", "user", "-", "friendly", "message", "containing", "the", "error", "that", "occurred", "during", "parsing", "and", "a", "suggestion", "to", "get", "help" ]

[ "func", "validateTag", "(", "rawRepo", "string", ")", "(", "string", ",", "error", ")", "{", "_", ",", "err", ":=", "reference", ".", "ParseNormalizedNamed", "(", "rawRepo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "rawRepo", ",", "nil", "\n", "}" ]

[ "validateTag", "checks", "if", "the", "given", "image", "name", "can", "be", "resolved", "." ]

[ "func", "replaceDockerfileForContentTrust", "(", "ctx", "context", ".", "Context", ",", "inputTarStream", "io", ".", "ReadCloser", ",", "dockerfileName", "string", ",", "translator", "translatorFunc", ",", "resolvedTags", "*", "[", "]", "*", "resolvedTag", ")", "io", ".", "ReadCloser", "{", "pipeReader", ",", "pipeWriter", ":=", "io", ".", "Pipe", "(", ")", "\n", "go", "func", "(", ")", "{", "tarReader", ":=", "tar", ".", "NewReader", "(", "inputTarStream", ")", "\n", "tarWriter", ":=", "tar", ".", "NewWriter", "(", "pipeWriter", ")", "\n\n", "defer", "inputTarStream", ".", "Close", "(", ")", "\n\n", "for", "{", "hdr", ",", "err", ":=", "tarReader", ".", "Next", "(", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "// Signals end of archive.", "tarWriter", ".", "Close", "(", ")", "\n", "pipeWriter", ".", "Close", "(", ")", "\n", "return", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "pipeWriter", ".", "CloseWithError", "(", "err", ")", "\n", "return", "\n", "}", "\n\n", "content", ":=", "io", ".", "Reader", "(", "tarReader", ")", "\n", "if", "hdr", ".", "Name", "==", "dockerfileName", "{", "// This entry is the Dockerfile. Since the tar archive was", "// generated from a directory on the local filesystem, the", "// Dockerfile will only appear once in the archive.", "var", "newDockerfile", "[", "]", "byte", "\n", "newDockerfile", ",", "*", "resolvedTags", ",", "err", "=", "rewriteDockerfileFromForContentTrust", "(", "ctx", ",", "content", ",", "translator", ")", "\n", "if", "err", "!=", "nil", "{", "pipeWriter", ".", "CloseWithError", "(", "err", ")", "\n", "return", "\n", "}", "\n", "hdr", ".", "Size", "=", "int64", "(", "len", "(", "newDockerfile", ")", ")", "\n", "content", "=", "bytes", ".", "NewBuffer", "(", "newDockerfile", ")", "\n", "}", "\n\n", "if", "err", ":=", "tarWriter", ".", "WriteHeader", "(", "hdr", ")", ";", "err", "!=", "nil", "{", "pipeWriter", ".", "CloseWithError", "(", "err", ")", "\n", "return", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "tarWriter", ",", "content", ")", ";", "err", "!=", "nil", "{", "pipeWriter", ".", "CloseWithError", "(", "err", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "pipeReader", "\n", "}" ]

[ "replaceDockerfileForContentTrust", "wraps", "the", "given", "input", "tar", "archive", "stream", "and", "uses", "the", "translator", "to", "replace", "the", "Dockerfile", "which", "uses", "a", "trusted", "reference", ".", "Returns", "a", "new", "tar", "archive", "stream", "with", "the", "replaced", "Dockerfile", "." ]

[ "func", "StackWrite", "(", "ctx", "formatter", ".", "Context", ",", "stacks", "[", "]", "*", "Stack", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "stack", ":=", "range", "stacks", "{", "if", "err", ":=", "format", "(", "&", "stackContext", "{", "s", ":", "stack", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "Write", "(", "newStackContext", "(", ")", ",", "render", ")", "\n", "}" ]

[ "StackWrite", "writes", "formatted", "stacks", "using", "the", "Context" ]

[ "func", "GenYamlTreeCustom", "(", "cmd", "*", "cobra", ".", "Command", ",", "dir", "string", ",", "filePrepender", "func", "(", "string", ")", "string", ")", "error", "{", "for", "_", ",", "c", ":=", "range", "cmd", ".", "Commands", "(", ")", "{", "if", "!", "c", ".", "IsAvailableCommand", "(", ")", "||", "c", ".", "IsAdditionalHelpTopicCommand", "(", ")", "{", "continue", "\n", "}", "\n", "if", "err", ":=", "GenYamlTreeCustom", "(", "c", ",", "dir", ",", "filePrepender", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "basename", ":=", "strings", ".", "Replace", "(", "cmd", ".", "CommandPath", "(", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "+", "\"", "\"", "\n", "filename", ":=", "filepath", ".", "Join", "(", "dir", ",", "basename", ")", "\n", "f", ",", "err", ":=", "os", ".", "Create", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "if", "_", ",", "err", ":=", "io", ".", "WriteString", "(", "f", ",", "filePrepender", "(", "filename", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "GenYamlCustom", "(", "cmd", ",", "f", ")", "\n", "}" ]

[ "GenYamlTreeCustom", "creates", "yaml", "structured", "ref", "files" ]

[ "func", "ConvertDurationPtr", "(", "d", "*", "Duration", ")", "*", "time", ".", "Duration", "{", "if", "d", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "res", ":=", "time", ".", "Duration", "(", "*", "d", ")", "\n", "return", "&", "res", "\n", "}" ]

[ "ConvertDurationPtr", "converts", "a", "typedefined", "Duration", "pointer", "to", "a", "time", ".", "Duration", "pointer", "with", "the", "same", "value", "." ]

[ "func", "(", "cd", "ConfigDetails", ")", "LookupEnv", "(", "key", "string", ")", "(", "string", ",", "bool", ")", "{", "v", ",", "ok", ":=", "cd", ".", "Environment", "[", "key", "]", "\n", "return", "v", ",", "ok", "\n", "}" ]

[ "LookupEnv", "provides", "a", "lookup", "function", "for", "environment", "variables" ]

[ "func", "(", "c", "Config", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "m", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "c", ".", "Version", ",", "\"", "\"", ":", "c", ".", "Services", ",", "}", "\n\n", "if", "len", "(", "c", ".", "Networks", ")", ">", "0", "{", "m", "[", "\"", "\"", "]", "=", "c", ".", "Networks", "\n", "}", "\n", "if", "len", "(", "c", ".", "Volumes", ")", ">", "0", "{", "m", "[", "\"", "\"", "]", "=", "c", ".", "Volumes", "\n", "}", "\n", "if", "len", "(", "c", ".", "Secrets", ")", ">", "0", "{", "m", "[", "\"", "\"", "]", "=", "c", ".", "Secrets", "\n", "}", "\n", "if", "len", "(", "c", ".", "Configs", ")", ">", "0", "{", "m", "[", "\"", "\"", "]", "=", "c", ".", "Configs", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "c", ".", "Extras", "{", "m", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "m", ")", "\n", "}" ]

[ "MarshalJSON", "makes", "Config", "implement", "json", ".", "Marshaler" ]

[ "func", "(", "s", "Services", ")", "MarshalYAML", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "services", ":=", "map", "[", "string", "]", "ServiceConfig", "{", "}", "\n", "for", "_", ",", "service", ":=", "range", "s", "{", "services", "[", "service", ".", "Name", "]", "=", "service", "\n", "}", "\n", "return", "services", ",", "nil", "\n", "}" ]

[ "MarshalYAML", "makes", "Services", "implement", "yaml", ".", "Marshaller" ]

[ "func", "(", "s", "Services", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "data", ",", "err", ":=", "s", ".", "MarshalYAML", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "json", ".", "MarshalIndent", "(", "data", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}" ]

[ "MarshalJSON", "makes", "Services", "implement", "json", ".", "Marshaler" ]

[ "func", "(", "u", "UnitBytes", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "`\"%d\"`", ",", "u", ")", ")", ",", "nil", "\n", "}" ]

[ "MarshalJSON", "makes", "UnitBytes", "implement", "json", ".", "Marshaler" ]

[ "func", "(", "u", "*", "UlimitsConfig", ")", "MarshalYAML", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "u", ".", "Single", "!=", "0", "{", "return", "u", ".", "Single", ",", "nil", "\n", "}", "\n", "return", "u", ",", "nil", "\n", "}" ]

[ "MarshalYAML", "makes", "UlimitsConfig", "implement", "yaml", ".", "Marshaller" ]

[ "func", "(", "u", "*", "UlimitsConfig", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "u", ".", "Single", "!=", "0", "{", "return", "json", ".", "Marshal", "(", "u", ".", "Single", ")", "\n", "}", "\n", "// Pass as a value to avoid re-entering this method and use the default implementation", "return", "json", ".", "Marshal", "(", "*", "u", ")", "\n", "}" ]

[ "MarshalJSON", "makes", "UlimitsConfig", "implement", "json", ".", "Marshaller" ]

[ "func", "(", "e", "External", ")", "MarshalYAML", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "e", ".", "Name", "==", "\"", "\"", "{", "return", "e", ".", "External", ",", "nil", "\n", "}", "\n", "return", "External", "{", "Name", ":", "e", ".", "Name", "}", ",", "nil", "\n", "}" ]

[ "MarshalYAML", "makes", "External", "implement", "yaml", ".", "Marshaller" ]

[ "func", "(", "e", "External", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "e", ".", "Name", "==", "\"", "\"", "{", "return", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "External", ")", ")", ",", "nil", "\n", "}", "\n", "return", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "`{\"name\": %q}`", ",", "e", ".", "Name", ")", ")", ",", "nil", "\n", "}" ]

[ "MarshalJSON", "makes", "External", "implement", "json", ".", "Marshaller" ]

[ "func", "TrustedPush", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "repoInfo", "*", "registry", ".", "RepositoryInfo", ",", "ref", "reference", ".", "Named", ",", "authConfig", "types", ".", "AuthConfig", ",", "requestPrivilege", "types", ".", "RequestPrivilegeFunc", ")", "error", "{", "responseBody", ",", "err", ":=", "imagePushPrivileged", "(", "ctx", ",", "cli", ",", "authConfig", ",", "ref", ",", "requestPrivilege", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "responseBody", ".", "Close", "(", ")", "\n\n", "return", "PushTrustedReference", "(", "cli", ",", "repoInfo", ",", "ref", ",", "authConfig", ",", "responseBody", ")", "\n", "}" ]

[ "TrustedPush", "handles", "content", "trust", "pushing", "of", "an", "image" ]

[ "func", "imagePushPrivileged", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "authConfig", "types", ".", "AuthConfig", ",", "ref", "reference", ".", "Reference", ",", "requestPrivilege", "types", ".", "RequestPrivilegeFunc", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "encodedAuth", ",", "err", ":=", "command", ".", "EncodeAuthToBase64", "(", "authConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "options", ":=", "types", ".", "ImagePushOptions", "{", "RegistryAuth", ":", "encodedAuth", ",", "PrivilegeFunc", ":", "requestPrivilege", ",", "}", "\n\n", "return", "cli", ".", "Client", "(", ")", ".", "ImagePush", "(", "ctx", ",", "reference", ".", "FamiliarString", "(", "ref", ")", ",", "options", ")", "\n", "}" ]

[ "imagePushPrivileged", "push", "the", "image" ]

[ "func", "trustedPull", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "imgRefAndAuth", "trust", ".", "ImageRefAndAuth", ",", "opts", "PullOptions", ")", "error", "{", "refs", ",", "err", ":=", "getTrustedPullTargets", "(", "cli", ",", "imgRefAndAuth", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ref", ":=", "imgRefAndAuth", ".", "Reference", "(", ")", "\n", "for", "i", ",", "r", ":=", "range", "refs", "{", "displayTag", ":=", "r", ".", "name", "\n", "if", "displayTag", "!=", "\"", "\"", "{", "displayTag", "=", "\"", "\"", "+", "displayTag", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "cli", ".", "Out", "(", ")", ",", "\"", "\\n", "\"", ",", "i", "+", "1", ",", "len", "(", "refs", ")", ",", "reference", ".", "FamiliarName", "(", "ref", ")", ",", "displayTag", ",", "r", ".", "digest", ")", "\n\n", "trustedRef", ",", "err", ":=", "reference", ".", "WithDigest", "(", "reference", ".", "TrimNamed", "(", "ref", ")", ",", "r", ".", "digest", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "updatedImgRefAndAuth", ",", "err", ":=", "trust", ".", "GetImageReferencesAndAuth", "(", "ctx", ",", "nil", ",", "AuthResolver", "(", "cli", ")", ",", "trustedRef", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "imagePullPrivileged", "(", "ctx", ",", "cli", ",", "updatedImgRefAndAuth", ",", "PullOptions", "{", "all", ":", "false", ",", "platform", ":", "opts", ".", "platform", ",", "quiet", ":", "opts", ".", "quiet", ",", "remote", ":", "opts", ".", "remote", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "tagged", ",", "err", ":=", "reference", ".", "WithTag", "(", "reference", ".", "TrimNamed", "(", "ref", ")", ",", "r", ".", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "TagTrusted", "(", "ctx", ",", "cli", ",", "trustedRef", ",", "tagged", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "trustedPull", "handles", "content", "trust", "pulling", "of", "an", "image" ]

[ "func", "imagePullPrivileged", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "imgRefAndAuth", "trust", ".", "ImageRefAndAuth", ",", "opts", "PullOptions", ")", "error", "{", "ref", ":=", "reference", ".", "FamiliarString", "(", "imgRefAndAuth", ".", "Reference", "(", ")", ")", "\n\n", "encodedAuth", ",", "err", ":=", "command", ".", "EncodeAuthToBase64", "(", "*", "imgRefAndAuth", ".", "AuthConfig", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "requestPrivilege", ":=", "command", ".", "RegistryAuthenticationPrivilegedFunc", "(", "cli", ",", "imgRefAndAuth", ".", "RepoInfo", "(", ")", ".", "Index", ",", "\"", "\"", ")", "\n", "options", ":=", "types", ".", "ImagePullOptions", "{", "RegistryAuth", ":", "encodedAuth", ",", "PrivilegeFunc", ":", "requestPrivilege", ",", "All", ":", "opts", ".", "all", ",", "Platform", ":", "opts", ".", "platform", ",", "}", "\n", "responseBody", ",", "err", ":=", "cli", ".", "Client", "(", ")", ".", "ImagePull", "(", "ctx", ",", "ref", ",", "options", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "responseBody", ".", "Close", "(", ")", "\n\n", "out", ":=", "cli", ".", "Out", "(", ")", "\n", "if", "opts", ".", "quiet", "{", "out", "=", "streams", ".", "NewOut", "(", "ioutil", ".", "Discard", ")", "\n", "}", "\n", "return", "jsonmessage", ".", "DisplayJSONMessagesToStream", "(", "responseBody", ",", "out", ",", "nil", ")", "\n", "}" ]

[ "imagePullPrivileged", "pulls", "the", "image", "and", "displays", "it", "to", "the", "output" ]

[ "func", "TrustedReference", "(", "ctx", "context", ".", "Context", ",", "cli", "command", ".", "Cli", ",", "ref", "reference", ".", "NamedTagged", ",", "rs", "registry", ".", "Service", ")", "(", "reference", ".", "Canonical", ",", "error", ")", "{", "imgRefAndAuth", ",", "err", ":=", "trust", ".", "GetImageReferencesAndAuth", "(", "ctx", ",", "rs", ",", "AuthResolver", "(", "cli", ")", ",", "ref", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "notaryRepo", ",", "err", ":=", "cli", ".", "NotaryClient", "(", "imgRefAndAuth", ",", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "t", ",", "err", ":=", "notaryRepo", ".", "GetTargetByName", "(", "ref", ".", "Tag", "(", ")", ",", "trust", ".", "ReleasesRole", ",", "data", ".", "CanonicalTargetsRole", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trust", ".", "NotaryError", "(", "imgRefAndAuth", ".", "RepoInfo", "(", ")", ".", "Name", ".", "Name", "(", ")", ",", "err", ")", "\n", "}", "\n", "// Only list tags in the top level targets role or the releases delegation role - ignore", "// all other delegation roles", "if", "t", ".", "Role", "!=", "trust", ".", "ReleasesRole", "&&", "t", ".", "Role", "!=", "data", ".", "CanonicalTargetsRole", "{", "return", "nil", ",", "trust", ".", "NotaryError", "(", "imgRefAndAuth", ".", "RepoInfo", "(", ")", ".", "Name", ".", "Name", "(", ")", ",", "client", ".", "ErrNoSuchTarget", "(", "ref", ".", "Tag", "(", ")", ")", ")", "\n", "}", "\n", "r", ",", "err", ":=", "convertTarget", "(", "t", ".", "Target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n\n", "}", "\n", "return", "reference", ".", "WithDigest", "(", "reference", ".", "TrimNamed", "(", "ref", ")", ",", "r", ".", "digest", ")", "\n", "}" ]

[ "TrustedReference", "returns", "the", "canonical", "trusted", "reference", "for", "an", "image", "reference" ]

[ "func", "AuthResolver", "(", "cli", "command", ".", "Cli", ")", "func", "(", "ctx", "context", ".", "Context", ",", "index", "*", "registrytypes", ".", "IndexInfo", ")", "types", ".", "AuthConfig", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "index", "*", "registrytypes", ".", "IndexInfo", ")", "types", ".", "AuthConfig", "{", "return", "command", ".", "ResolveAuthConfig", "(", "ctx", ",", "cli", ",", "index", ")", "\n", "}", "\n", "}" ]

[ "AuthResolver", "returns", "an", "auth", "resolver", "function", "from", "a", "command", ".", "Cli" ]

[ "func", "NewFormat", "(", "source", "string", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "PrettyFormatKey", ":", "return", "serviceInspectPrettyTemplate", "\n", "default", ":", "return", "formatter", ".", "Format", "(", "strings", ".", "TrimPrefix", "(", "source", ",", "formatter", ".", "RawFormatKey", ")", ")", "\n", "}", "\n", "}" ]

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

[ "func", "InspectFormatWrite", "(", "ctx", "formatter", ".", "Context", ",", "refs", "[", "]", "string", ",", "getRef", ",", "getNetwork", "inspect", ".", "GetRefFunc", ")", "error", "{", "if", "ctx", ".", "Format", "!=", "serviceInspectPrettyTemplate", "{", "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", "{", "serviceI", ",", "_", ",", "err", ":=", "getRef", "(", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "service", ",", "ok", ":=", "serviceI", ".", "(", "swarm", ".", "Service", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "format", "(", "&", "serviceInspectContext", "{", "Service", ":", "service", ",", "networkNames", ":", "resolveNetworks", "(", "service", ",", "getNetwork", ")", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "serviceInspectContext", "{", "}", ",", "render", ")", "\n", "}" ]

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

[ "func", "NewListFormat", "(", "source", "string", ",", "quiet", "bool", ")", "formatter", ".", "Format", "{", "switch", "source", "{", "case", "formatter", ".", "TableFormatKey", ":", "if", "quiet", "{", "return", "formatter", ".", "DefaultQuietFormat", "\n", "}", "\n", "return", "defaultServiceTableFormat", "\n", "case", "formatter", ".", "RawFormatKey", ":", "if", "quiet", "{", "return", "`id: {{.ID}}`", "\n", "}", "\n", "return", "`id: {{.ID}}\\nname: {{.Name}}\\nmode: {{.Mode}}\\nreplicas: {{.Replicas}}\\nimage: {{.Image}}\\nports: {{.Ports}}\\n`", "\n", "}", "\n", "return", "formatter", ".", "Format", "(", "source", ")", "\n", "}" ]

[ "NewListFormat", "returns", "a", "Format", "for", "rendering", "using", "a", "service", "Context" ]

[ "func", "ListFormatWrite", "(", "ctx", "formatter", ".", "Context", ",", "services", "[", "]", "swarm", ".", "Service", ",", "info", "map", "[", "string", "]", "ListInfo", ")", "error", "{", "render", ":=", "func", "(", "format", "func", "(", "subContext", "formatter", ".", "SubContext", ")", "error", ")", "error", "{", "for", "_", ",", "service", ":=", "range", "services", "{", "serviceCtx", ":=", "&", "serviceContext", "{", "service", ":", "service", ",", "mode", ":", "info", "[", "service", ".", "ID", "]", ".", "Mode", ",", "replicas", ":", "info", "[", "service", ".", "ID", "]", ".", "Replicas", "}", "\n", "if", "err", ":=", "format", "(", "serviceCtx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "serviceCtx", ":=", "serviceContext", "{", "}", "\n", "serviceCtx", ".", "Header", "=", "formatter", ".", "SubHeaderContext", "{", "\"", "\"", ":", "serviceIDHeader", ",", "\"", "\"", ":", "formatter", ".", "NameHeader", ",", "\"", "\"", ":", "modeHeader", ",", "\"", "\"", ":", "replicasHeader", ",", "\"", "\"", ":", "formatter", ".", "ImageHeader", ",", "\"", "\"", ":", "formatter", ".", "PortsHeader", ",", "}", "\n", "return", "ctx", ".", "Write", "(", "&", "serviceCtx", ",", "render", ")", "\n", "}" ]

[ "ListFormatWrite", "writes", "the", "context" ]

[ "func", "NewRestartCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "var", "opts", "restartOptions", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "RequiresMinArgs", "(", "1", ")", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "opts", ".", "containers", "=", "args", "\n", "opts", ".", "nSecondsChanged", "=", "cmd", ".", "Flags", "(", ")", ".", "Changed", "(", "\"", "\"", ")", "\n", "return", "runRestart", "(", "dockerCli", ",", "&", "opts", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "IntVarP", "(", "&", "opts", ".", "nSeconds", ",", "\"", "\"", ",", "\"", "\"", ",", "10", ",", "\"", "\"", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewRestartCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "restart" ]

[ "func", "trimExeSuffix", "(", "s", "string", ")", "(", "string", ",", "error", ")", "{", "ext", ":=", "filepath", ".", "Ext", "(", "s", ")", "\n", "if", "ext", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n\n", "exe", ":=", "\"", "\"", "\n", "if", "!", "strings", ".", "EqualFold", "(", "ext", ",", "exe", ")", "{", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "s", ",", "exe", ")", "\n", "}", "\n", "return", "strings", ".", "TrimSuffix", "(", "s", ",", "ext", ")", ",", "nil", "\n", "}" ]

[ "This", "is", "made", "slightly", "more", "complex", "due", "to", "needing", "to", "be", "case", "insensitive", "." ]

[ "func", "validateKeyArgs", "(", "keyName", "string", ",", "targetDir", "string", ")", "error", "{", "if", "!", "validKeyName", "(", "keyName", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\"", ",", "keyName", ")", "\n", "}", "\n\n", "pubKeyFileName", ":=", "keyName", "+", "\"", "\"", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "targetDir", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "targetDir", ")", "\n", "}", "\n", "targetPath", ":=", "filepath", ".", "Join", "(", "targetDir", ",", "pubKeyFileName", ")", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "targetPath", ")", ";", "err", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "targetPath", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "validate", "that", "all", "of", "the", "key", "names", "are", "unique", "and", "are", "alphanumeric", "+", "_", "+", "-", "and", "that", "we", "do", "not", "already", "have", "public", "key", "files", "in", "the", "target", "dir", "on", "disk" ]

[ "func", "WithAllCapabilities", "(", "_", "context", ".", "Context", ",", "_", "oci", ".", "Client", ",", "c", "*", "containers", ".", "Container", ",", "s", "*", "specs", ".", "Spec", ")", "error", "{", "caps", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "if", "s", ".", "Process", ".", "Capabilities", "==", "nil", "{", "s", ".", "Process", ".", "Capabilities", "=", "&", "specs", ".", "LinuxCapabilities", "{", "}", "\n", "}", "\n", "s", ".", "Process", ".", "Capabilities", ".", "Bounding", "=", "caps", "\n", "s", ".", "Process", ".", "Capabilities", ".", "Effective", "=", "caps", "\n", "s", ".", "Process", ".", "Capabilities", ".", "Inheritable", "=", "caps", "\n", "s", ".", "Process", ".", "Capabilities", ".", "Permitted", "=", "caps", "\n", "return", "nil", "\n", "}" ]

[ "WithAllCapabilities", "enables", "all", "capabilities", "required", "to", "run", "privileged", "containers" ]

[ "func", "LoadComposefile", "(", "dockerCli", "command", ".", "Cli", ",", "opts", "options", ".", "Deploy", ")", "(", "*", "composetypes", ".", "Config", ",", "error", ")", "{", "configDetails", ",", "err", ":=", "getConfigDetails", "(", "opts", ".", "Composefiles", ",", "dockerCli", ".", "In", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "dicts", ":=", "getDictsFrom", "(", "configDetails", ".", "ConfigFiles", ")", "\n", "config", ",", "err", ":=", "loader", ".", "Load", "(", "configDetails", ")", "\n", "if", "err", "!=", "nil", "{", "if", "fpe", ",", "ok", ":=", "err", ".", "(", "*", "loader", ".", "ForbiddenPropertiesError", ")", ";", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\\n", "\\n", "\\n", "\"", ",", "propertyWarnings", "(", "fpe", ".", "Properties", ")", ")", "\n", "}", "\n\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "unsupportedProperties", ":=", "loader", ".", "GetUnsupportedProperties", "(", "dicts", "...", ")", "\n", "if", "len", "(", "unsupportedProperties", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "dockerCli", ".", "Err", "(", ")", ",", "\"", "\\n", "\\n", "\"", ",", "strings", ".", "Join", "(", "unsupportedProperties", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "deprecatedProperties", ":=", "loader", ".", "GetDeprecatedProperties", "(", "dicts", "...", ")", "\n", "if", "len", "(", "deprecatedProperties", ")", ">", "0", "{", "fmt", ".", "Fprintf", "(", "dockerCli", ".", "Err", "(", ")", ",", "\"", "\\n", "\\n", "\\n", "\\n", "\"", ",", "propertyWarnings", "(", "deprecatedProperties", ")", ")", "\n", "}", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "LoadComposefile", "parse", "the", "composefile", "specified", "in", "the", "cli", "and", "returns", "its", "Config", "and", "version", "." ]

[ "func", "NewEventsCommand", "(", "dockerCli", "command", ".", "Cli", ")", "*", "cobra", ".", "Command", "{", "options", ":=", "eventsOptions", "{", "filter", ":", "opts", ".", "NewFilterOpt", "(", ")", "}", "\n\n", "cmd", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Args", ":", "cli", ".", "NoArgs", ",", "RunE", ":", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "error", "{", "return", "runEvents", "(", "dockerCli", ",", "&", "options", ")", "\n", "}", ",", "}", "\n\n", "flags", ":=", "cmd", ".", "Flags", "(", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "since", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "until", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "VarP", "(", "&", "options", ".", "filter", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flags", ".", "StringVar", "(", "&", "options", ".", "format", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "return", "cmd", "\n", "}" ]

[ "NewEventsCommand", "creates", "a", "new", "cobra", ".", "Command", "for", "docker", "events" ]

[ "func", "prettyPrintEvent", "(", "out", "io", ".", "Writer", ",", "event", "eventtypes", ".", "Message", ")", "error", "{", "if", "event", ".", "TimeNano", "!=", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\"", ",", "time", ".", "Unix", "(", "0", ",", "event", ".", "TimeNano", ")", ".", "Format", "(", "rfc3339NanoFixed", ")", ")", "\n", "}", "else", "if", "event", ".", "Time", "!=", "0", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\"", ",", "time", ".", "Unix", "(", "event", ".", "Time", ",", "0", ")", ".", "Format", "(", "rfc3339NanoFixed", ")", ")", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\"", ",", "event", ".", "Type", ",", "event", ".", "Action", ",", "event", ".", "Actor", ".", "ID", ")", "\n\n", "if", "len", "(", "event", ".", "Actor", ".", "Attributes", ")", ">", "0", "{", "var", "attrs", "[", "]", "string", "\n", "var", "keys", "[", "]", "string", "\n", "for", "k", ":=", "range", "event", ".", "Actor", ".", "Attributes", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "v", ":=", "event", ".", "Actor", ".", "Attributes", "[", "k", "]", "\n", "attrs", "=", "append", "(", "attrs", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ",", "v", ")", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\"", ",", "strings", ".", "Join", "(", "attrs", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "fmt", ".", "Fprint", "(", "out", ",", "\"", "\\n", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "prettyPrintEvent", "prints", "all", "types", "of", "event", "information", ".", "Each", "output", "includes", "the", "event", "type", "actor", "id", "name", "and", "action", ".", "Actor", "attributes", "are", "printed", "at", "the", "end", "if", "the", "actor", "has", "any", "." ]

[ "func", "(", "d", "*", "PositiveDurationOpt", ")", "Set", "(", "s", "string", ")", "error", "{", "err", ":=", "d", ".", "DurationOpt", ".", "Set", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "*", "d", ".", "DurationOpt", ".", "value", "<", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Set", "a", "new", "value", "on", "the", "option", ".", "Setting", "a", "negative", "duration", "value", "will", "cause", "an", "error", "to", "be", "returned", "." ]