Datasets:

CM

/

codexglue_code2text_go

like 0

[ "func", "IOMuxDir", "(", "root", "string", ",", "appName", "types", ".", "ACName", ")", "string", "{", "return", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "root", ")", ",", "ioMuxDir", ",", "appName", ".", "String", "(", ")", ")", "\n", "}" ]

[ "IOMUxFilePath", "returns", "the", "path", "to", "the", "environment", "file", "for", "the", "given", "app", "name", "." ]

[ "func", "ServiceWantPath", "(", "root", "string", ",", "appName", "types", ".", "ACName", ")", "string", "{", "return", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "root", ")", ",", "defaultWantsDir", ",", "ServiceUnitName", "(", "appName", ")", ")", "\n", "}" ]

[ "ServiceWantPath", "returns", "the", "systemd", "default", ".", "target", "want", "symlink", "path", "for", "the", "given", "app", "name", "." ]

[ "func", "InstantiatedPrepareAppUnitName", "(", "appName", "types", ".", "ACName", ")", "string", "{", "// Naming respecting escaping rules, see systemd.unit(5) and systemd-escape(1)", "escapedRoot", ":=", "unit", ".", "UnitNamePathEscape", "(", "common", ".", "RelAppRootfsPath", "(", "appName", ")", ")", "\n", "return", "\"", "\"", "+", "escapedRoot", "+", "\"", "\"", "\n", "}" ]

[ "InstantiatedPrepareAppUnitName", "returns", "the", "systemd", "service", "unit", "name", "for", "prepare", "-", "app", "instantiated", "for", "the", "given", "root", "." ]

[ "func", "SocketUnitPath", "(", "root", "string", ",", "appName", "types", ".", "ACName", ")", "string", "{", "return", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "root", ")", ",", "UnitsDir", ",", "SocketUnitName", "(", "appName", ")", ")", "\n", "}" ]

[ "SocketUnitPath", "returns", "the", "path", "to", "the", "systemd", "socket", "file", "for", "the", "given", "app", "name", "." ]

[ "func", "SocketWantPath", "(", "root", "string", ",", "appName", "types", ".", "ACName", ")", "string", "{", "return", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "root", ")", ",", "socketsWantsDir", ",", "SocketUnitName", "(", "appName", ")", ")", "\n", "}" ]

[ "SocketWantPath", "returns", "the", "systemd", "sockets", ".", "target", ".", "wants", "symlink", "path", "for", "the", "given", "app", "name", "." ]

[ "func", "TypedUnitPath", "(", "root", "string", ",", "unitName", "string", ",", "unitType", "string", ")", "string", "{", "return", "filepath", ".", "Join", "(", "common", ".", "Stage1RootfsPath", "(", "root", ")", ",", "UnitsDir", ",", "unitName", "+", "\"", "\"", "+", "unitType", ")", "\n", "}" ]

[ "TypedUnitPath", "returns", "the", "path", "to", "a", "custom", "-", "typed", "unit", "file" ]

[ "func", "NewACIArchive", "(", "u", "*", "url", ".", "URL", ")", "(", "Distribution", ",", "error", ")", "{", "c", ",", "err", ":=", "parseCIMD", "(", "u", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "u", ".", "String", "(", ")", ",", "err", ")", "\n", "}", "\n", "if", "c", ".", "Type", "!=", "TypeACIArchive", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "Type", ")", "\n", "}", "\n\n", "// This should be a valid URL", "data", ",", "err", ":=", "url", ".", "QueryUnescape", "(", "c", ".", "Data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "Data", ")", ",", "err", ")", "\n", "}", "\n", "aciu", ",", "err", ":=", "url", ".", "Parse", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "Data", ")", ",", "err", ")", "\n", "}", "\n\n", "// save the URI as sorted to make it ready for comparison", "purell", ".", "NormalizeURL", "(", "u", ",", "purell", ".", "FlagSortQuery", ")", "\n\n", "str", ":=", "u", ".", "String", "(", ")", "\n", "if", "path", ":=", "aciu", ".", "String", "(", ")", ";", "filepath", ".", "Ext", "(", "path", ")", "==", "schema", ".", "ACIExtension", "{", "str", "=", "path", "\n", "}", "\n\n", "return", "&", "ACIArchive", "{", "cimdURL", ":", "u", ",", "transportURL", ":", "aciu", ",", "str", ":", "str", ",", "}", ",", "nil", "\n", "}" ]

[ "NewACIArchive", "creates", "a", "new", "aci", "-", "archive", "distribution", "from", "the", "provided", "distribution", "uri", "." ]

[ "func", "(", "a", "*", "ACIArchive", ")", "TransportURL", "(", ")", "*", "url", ".", "URL", "{", "// Create a copy of the transport URL", "tu", ",", "err", ":=", "url", ".", "Parse", "(", "a", ".", "transportURL", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n\n", "return", "tu", "\n", "}" ]

[ "TransportURL", "returns", "a", "copy", "of", "the", "transport", "URL", "." ]

[ "func", "MountGC", "(", "path", ",", "uuid", "string", ")", "error", "{", "err", ":=", "common", ".", "ChrootPrivateUnmount", "(", "path", ",", "log", ",", "debug", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ")", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "MountGC", "removes", "mounts", "from", "pods", "that", "couldn", "t", "be", "GCed", "cleanly", "." ]

[ "func", "matchUUID", "(", "dataDir", ",", "uuid", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "uuid", "==", "\"", "\"", "{", "return", "nil", ",", "types", ".", "ErrNoEmptyUUID", "\n", "}", "\n\n", "ls", ",", "err", ":=", "listPods", "(", "dataDir", ",", "IncludeMostDirs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "matches", "[", "]", "string", "\n", "for", "_", ",", "p", ":=", "range", "ls", "{", "if", "strings", ".", "HasPrefix", "(", "p", ",", "uuid", ")", "{", "matches", "=", "append", "(", "matches", ",", "p", ")", "\n", "}", "\n", "}", "\n\n", "return", "matches", ",", "nil", "\n", "}" ]

[ "matchUUID", "attempts", "to", "match", "the", "uuid", "specified", "as", "uuid", "against", "all", "pods", "present", ".", "An", "array", "of", "matches", "is", "returned", "which", "may", "be", "empty", "when", "nothing", "matches", "." ]

[ "func", "resolveUUID", "(", "dataDir", ",", "uuid", "string", ")", "(", "*", "types", ".", "UUID", ",", "error", ")", "{", "uuid", "=", "strings", ".", "ToLower", "(", "uuid", ")", "\n", "m", ",", "err", ":=", "matchUUID", "(", "dataDir", ",", "uuid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "m", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ")", "\n", "}", "\n\n", "if", "len", "(", "m", ")", ">", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "m", ")", ")", "\n", "}", "\n\n", "u", ",", "err", ":=", "types", ".", "NewUUID", "(", "m", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "u", ",", "nil", "\n", "}" ]

[ "resolveUUID", "attempts", "to", "resolve", "the", "uuid", "specified", "as", "uuid", "against", "all", "pods", "present", ".", "An", "unambiguously", "matched", "uuid", "or", "nil", "is", "returned", "." ]

[ "func", "ReadUUIDFromFile", "(", "path", "string", ")", "(", "string", ",", "error", ")", "{", "uuid", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "string", "(", "bytes", ".", "TrimSpace", "(", "uuid", ")", ")", ",", "nil", "\n", "}" ]

[ "ReadUUIDFromFile", "reads", "the", "uuid", "string", "from", "the", "given", "path", "." ]

[ "func", "WriteUUIDToFile", "(", "uuid", "*", "types", ".", "UUID", ",", "path", "string", ")", "error", "{", "return", "ioutil", ".", "WriteFile", "(", "path", ",", "[", "]", "byte", "(", "uuid", ".", "String", "(", ")", ")", ",", "0644", ")", "\n", "}" ]

[ "WriteUUIDToFile", "writes", "the", "uuid", "string", "to", "the", "given", "path", "." ]

[ "func", "Setup", "(", "podRoot", "string", ",", "podID", "types", ".", "UUID", ",", "fps", "[", "]", "commonnet", ".", "ForwardedPort", ",", "netList", "common", ".", "NetList", ",", "localConfig", ",", "flavor", "string", ",", "noDNS", ",", "debug", "bool", ")", "(", "*", "Networking", ",", "error", ")", "{", "stderr", "=", "log", ".", "New", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "debug", ")", "\n", "debuglog", "=", "debug", "\n\n", "if", "flavor", "==", "\"", "\"", "{", "return", "kvmSetup", "(", "podRoot", ",", "podID", ",", "fps", ",", "netList", ",", "localConfig", ",", "noDNS", ")", "\n", "}", "\n\n", "// TODO(jonboulle): currently podRoot is _always_ \".\", and behaviour in other", "// circumstances is untested. This should be cleaned up.", "n", ":=", "Networking", "{", "podEnv", ":", "podEnv", "{", "podRoot", ":", "podRoot", ",", "podID", ":", "podID", ",", "netsLoadList", ":", "netList", ",", "localConfig", ":", "localConfig", ",", "}", ",", "}", "\n\n", "err", ":=", "n", ".", "mountNetnsDirectory", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Create the network namespace (and save its name in a file)", "err", "=", "n", ".", "podNSCreate", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "n", ".", "nets", ",", "err", "=", "n", ".", "loadNets", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "n", ".", "setupNets", "(", "n", ".", "nets", ",", "noDNS", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "fps", ")", ">", "0", "{", "if", "err", "=", "n", ".", "enableDefaultLocalnetRouting", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "podIP", ",", "err", ":=", "n", ".", "GetForwardableNetPodIP", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "n", ".", "setupForwarding", "(", ")", ";", "err", "!=", "nil", "{", "n", ".", "teardownForwarding", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "n", ".", "forwardPorts", "(", "fps", ",", "podIP", ")", ";", "err", "!=", "nil", "{", "n", ".", "teardownForwarding", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// Switch to the podNS", "if", "err", ":=", "n", ".", "podNS", ".", "Set", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", "=", "loUp", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "n", ",", "nil", "\n", "}" ]

[ "Setup", "creates", "a", "new", "networking", "namespace", "and", "executes", "network", "plugins", "to", "set", "up", "networking", ".", "It", "returns", "in", "the", "new", "pod", "namespace" ]

[ "func", "(", "n", "*", "Networking", ")", "enableDefaultLocalnetRouting", "(", ")", "error", "{", "routeLocalnetFormat", ":=", "\"", "\"", "\n\n", "defaultHostIP", ",", "err", ":=", "n", ".", "GetForwardableNetHostIP", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defaultHostIPstring", ":=", "defaultHostIP", ".", "String", "(", ")", "\n", "switch", "{", "case", "strings", ".", "Contains", "(", "defaultHostIPstring", ",", "\"", "\"", ")", ":", "routeLocalnetFormat", "=", "\"", "\"", "\n", "case", "strings", ".", "Contains", "(", "defaultHostIPstring", ",", "\"", "\"", ")", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "defaultHostIPstring", ")", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "defaultHostIPstring", ")", "\n", "}", "\n\n", "hostIfaces", ",", "err", ":=", "n", ".", "GetIfacesByIP", "(", "defaultHostIP", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "hostIface", ":=", "range", "hostIfaces", "{", "routeLocalnetPath", ":=", "fmt", ".", "Sprintf", "(", "routeLocalnetFormat", ",", "hostIface", ".", "Name", ")", "\n", "routeLocalnetValue", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "routeLocalnetPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "strings", ".", "TrimSpace", "(", "string", "(", "routeLocalnetValue", ")", ")", "!=", "\"", "\"", "{", "routeLocalnetFile", ",", "err", ":=", "os", ".", "OpenFile", "(", "routeLocalnetPath", ",", "os", ".", "O_WRONLY", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "routeLocalnetFile", ".", "Close", "(", ")", "\n\n", "if", "_", ",", "err", "=", "io", ".", "WriteString", "(", "routeLocalnetFile", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "enableDefaultLocalnetRouting", "enables", "the", "route_localnet", "attribute", "on", "the", "supposedly", "default", "network", "interface", ".", "This", "allows", "setting", "up", "loopback", "NAT", "so", "the", "host", "can", "access", "the", "pod", "s", "forwarded", "ports", "on", "the", "localhost", "address", "." ]

[ "func", "Load", "(", "podRoot", "string", ",", "podID", "*", "types", ".", "UUID", ",", "localConfig", "string", ")", "(", "*", "Networking", ",", "error", ")", "{", "// the current directory is pod root", "pdirfd", ",", "err", ":=", "syscall", ".", "Open", "(", "podRoot", ",", "syscall", ".", "O_RDONLY", "|", "syscall", ".", "O_DIRECTORY", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "podRoot", ")", ",", "err", ")", "\n", "}", "\n", "defer", "syscall", ".", "Close", "(", "pdirfd", ")", "\n\n", "nis", ",", "err", ":=", "netinfo", ".", "LoadAt", "(", "pdirfd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "nets", "[", "]", "activeNet", "\n", "for", "_", ",", "ni", ":=", "range", "nis", "{", "n", ",", "err", ":=", "loadNet", "(", "ni", ".", "ConfPath", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "stderr", ".", "PrintE", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ni", ".", "ConfPath", ")", ",", "err", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "// make a copy of ni to make it a unique object as it's saved via ptr", "rti", ":=", "ni", "\n", "n", ".", "runtime", "=", "&", "rti", "\n", "nets", "=", "append", "(", "nets", ",", "*", "n", ")", "\n", "}", "\n\n", "p", ":=", "podEnv", "{", "podRoot", ":", "podRoot", ",", "podID", ":", "*", "podID", ",", "localConfig", ":", "localConfig", ",", "}", "\n\n", "err", "=", "p", ".", "podNSLoad", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "Networking", "{", "podEnv", ":", "p", ",", "nets", ":", "nets", ",", "}", ",", "nil", "\n", "}" ]

[ "Load", "creates", "the", "Networking", "object", "from", "saved", "state", ".", "Assumes", "the", "current", "netns", "is", "that", "of", "the", "host", "." ]

[ "func", "(", "n", "*", "Networking", ")", "GetIfacesByIP", "(", "ifaceIP", "net", ".", "IP", ")", "(", "[", "]", "net", ".", "Interface", ",", "error", ")", "{", "ifaces", ",", "err", ":=", "net", ".", "Interfaces", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "searchAddr", ":=", "strings", ".", "Split", "(", "ifaceIP", ".", "String", "(", ")", ",", "\"", "\"", ")", "[", "0", "]", "\n", "resultInterfaces", ":=", "make", "(", "[", "]", "net", ".", "Interface", ",", "0", ")", "\n\n", "for", "_", ",", "iface", ":=", "range", "ifaces", "{", "if", "iface", ".", "Flags", "&", "net", ".", "FlagLoopback", "!=", "0", "{", "continue", "\n", "}", "\n\n", "addrs", ",", "err", ":=", "iface", ".", "Addrs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "iface", ".", "Name", ")", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "addr", ":=", "range", "addrs", "{", "currentAddr", ":=", "strings", ".", "Split", "(", "addr", ".", "String", "(", ")", ",", "\"", "\"", ")", "[", "0", "]", "\n", "if", "searchAddr", "==", "currentAddr", "{", "resultInterfaces", "=", "append", "(", "resultInterfaces", ",", "iface", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "resultInterfaces", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ifaceIP", ")", "\n", "}", "\n\n", "return", "resultInterfaces", ",", "nil", "\n", "}" ]

[ "GetIfacesByIP", "searches", "for", "and", "returns", "the", "interfaces", "with", "the", "given", "IP", "Disregards", "the", "subnet", "mask", "since", "not", "every", "net", ".", "IP", "object", "contains", "On", "success", "it", "will", "return", "the", "list", "of", "found", "interfaces" ]

[ "func", "(", "n", "*", "Networking", ")", "Teardown", "(", "flavor", "string", ",", "debug", "bool", ")", "{", "stderr", "=", "log", ".", "New", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "debug", ")", "\n", "debuglog", "=", "debug", "\n\n", "// Teardown everything in reverse order of setup.", "// This should be idempotent -- be tolerant of missing stuff", "if", "flavor", "==", "\"", "\"", "{", "n", ".", "kvmTeardown", "(", ")", "\n", "return", "\n", "}", "\n\n", "if", "err", ":=", "n", ".", "teardownForwarding", "(", ")", ";", "err", "!=", "nil", "{", "stderr", ".", "PrintE", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", ":=", "n", ".", "podNSLoad", "(", ")", "\n", "if", "err", "!=", "nil", "{", "stderr", ".", "PrintE", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "n", ".", "teardownNets", "(", "n", ".", "nets", ")", "\n", "n", ".", "podNSDestroy", "(", ")", "\n", "}" ]

[ "Teardown", "cleans", "up", "a", "produced", "Networking", "object", "." ]

[ "func", "(", "e", "*", "Networking", ")", "Save", "(", ")", "error", "{", "if", "e", ".", "podNS", "!=", "nil", "{", "if", "err", ":=", "e", ".", "podNSPathSave", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "var", "nis", "[", "]", "netinfo", ".", "NetInfo", "\n", "for", "_", ",", "n", ":=", "range", "e", ".", "nets", "{", "nis", "=", "append", "(", "nis", ",", "*", "n", ".", "runtime", ")", "\n", "}", "\n\n", "return", "netinfo", ".", "Save", "(", "e", ".", "podRoot", ",", "nis", ")", "\n", "}" ]

[ "Save", "writes", "out", "the", "info", "about", "active", "nets", "for", "rkt", "list", "and", "friends", "to", "display" ]

[ "func", "CleanUpGarbage", "(", "podRoot", "string", ",", "podID", "*", "types", ".", "UUID", ")", "error", "{", "p", ":=", "podEnv", "{", "podRoot", ":", "podRoot", ",", "podID", ":", "*", "podID", ",", "}", "\n\n", "err", ":=", "p", ".", "podNSLoad", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "p", ".", "podNSDestroy", "(", ")", "\n", "}" ]

[ "CleanUpGarbage", "can", "be", "called", "when", "Load", "fails", "but", "there", "may", "still", "be", "some", "garbage", "lying", "around", ".", "Right", "now", "this", "deletes", "the", "namespace", "." ]

[ "func", "(", "a", "*", "asc", ")", "Get", "(", ")", "(", "readSeekCloser", ",", "error", ")", "{", "if", "a", ".", "Fetcher", "!=", "nil", "{", "return", "a", ".", "Fetcher", ".", "Get", "(", "a", ".", "Location", ")", "\n", "}", "\n", "return", "NopReadSeekCloser", "(", "nil", ")", ",", "nil", "\n", "}" ]

[ "Get", "fetches", "a", "signature", "file", ".", "It", "returns", "nil", "and", "no", "error", "if", "there", "was", "no", "fetcher", "set", "." ]

[ "func", "(", "f", "*", "Finder", ")", "FindImages", "(", "al", "*", "apps", ".", "Apps", ")", "error", "{", "return", "al", ".", "Walk", "(", "func", "(", "app", "*", "apps", ".", "App", ")", "error", "{", "h", ",", "err", ":=", "f", ".", "FindImage", "(", "app", ".", "Image", ",", "app", ".", "Asc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "app", ".", "ImageID", "=", "*", "h", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "FindImages", "uses", "FindImage", "to", "attain", "a", "list", "of", "image", "hashes" ]

[ "func", "(", "f", "*", "Finder", ")", "FindImage", "(", "img", "string", ",", "asc", "string", ")", "(", "*", "types", ".", "Hash", ",", "error", ")", "{", "ensureLogger", "(", "f", ".", "Debug", ")", "\n\n", "// Check if it's an hash", "if", "_", ",", "err", ":=", "types", ".", "NewHash", "(", "img", ")", ";", "err", "==", "nil", "{", "h", ",", "err", ":=", "f", ".", "getHashFromStore", "(", "img", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "h", ",", "nil", "\n", "}", "\n\n", "d", ",", "err", ":=", "DistFromImageString", "(", "img", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// urls, names, paths have to be fetched, potentially remotely", "ft", ":=", "(", "*", "Fetcher", ")", "(", "f", ")", "\n", "h", ",", "err", ":=", "ft", ".", "FetchImage", "(", "d", ",", "img", ",", "asc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "h", ",", "nil", "\n", "}" ]

[ "FindImage", "tries", "to", "get", "a", "hash", "of", "a", "passed", "image", "ideally", "from", "store", ".", "Otherwise", "this", "might", "involve", "fetching", "it", "from", "remote", "with", "the", "Fetcher", "." ]

[ "func", "fileAccessible", "(", "path", "string", ")", "bool", "{", "if", "info", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "err", "==", "nil", "{", "return", "info", ".", "Mode", "(", ")", ".", "IsRegular", "(", ")", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "fileAccessible", "checks", "if", "the", "given", "path", "exists", "and", "is", "a", "regular", "file" ]

[ "func", "generateKeyPair", "(", "private", "string", ")", "error", "{", "out", ",", "err", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "// silence", "\"", "\"", ",", "\"", "\"", ",", "// type", "\"", "\"", ",", "\"", "\"", ",", "// length in bits", "\"", "\"", ",", "private", ",", "// output file", "\"", "\"", ",", "\"", "\"", ",", "// no passphrase", ")", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// out is in form of bytes buffer and we have to turn it into slice ending on first \\0 occurrence", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "string", "(", "out", "[", ":", "]", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "generateKeyPair", "calls", "ssh", "-", "keygen", "with", "private", "key", "location", "for", "key", "generation", "purpose" ]

[ "func", "(", "m", "*", "Mount", ")", "NeedsRemountPrivate", "(", ")", "bool", "{", "for", "_", ",", "key", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "}", "{", "if", "_", ",", "needsRemount", ":=", "m", ".", "Opts", "[", "key", "]", ";", "needsRemount", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "NeedsRemountPrivate", "checks", "if", "this", "mountPoint", "needs", "to", "be", "remounted", "as", "private", "in", "order", "for", "children", "to", "be", "properly", "unmounted", "without", "leaking", "to", "parents", "." ]

[ "func", "(", "ms", "Mounts", ")", "Filter", "(", "f", "FilterFunc", ")", "Mounts", "{", "filtered", ":=", "make", "(", "[", "]", "*", "Mount", ",", "0", ",", "len", "(", "ms", ")", ")", "\n\n", "for", "_", ",", "m", ":=", "range", "ms", "{", "if", "f", "(", "m", ")", "{", "filtered", "=", "append", "(", "filtered", ",", "m", ")", "\n", "}", "\n", "}", "\n\n", "return", "Mounts", "(", "filtered", ")", "\n", "}" ]

[ "Filter", "returns", "a", "filtered", "copy", "of", "Mounts" ]

[ "func", "(", "ms", "Mounts", ")", "mountDepth", "(", "i", "int", ")", "int", "{", "ancestorCount", ":=", "0", "\n", "current", ":=", "ms", "[", "i", "]", "\n", "for", "found", ":=", "true", ";", "found", ";", "{", "found", "=", "false", "\n", "for", "_", ",", "mnt", ":=", "range", "ms", "{", "if", "mnt", ".", "ID", "==", "current", ".", "Parent", "{", "ancestorCount", "++", "\n", "current", "=", "mnt", "\n", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "ancestorCount", "\n", "}" ]

[ "mountDepth", "determines", "and", "returns", "the", "number", "of", "ancestors", "of", "the", "mount", "at", "index", "i" ]

[ "func", "NewBitFlags", "(", "permissibleOptions", "[", "]", "string", ",", "defaultOptions", "string", ",", "flagMap", "map", "[", "string", "]", "int", ")", "(", "*", "BitFlags", ",", "error", ")", "{", "ol", ",", "err", ":=", "NewOptionList", "(", "permissibleOptions", ",", "defaultOptions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "bf", ":=", "&", "BitFlags", "{", "OptionList", ":", "ol", ",", "FlagMap", ":", "flagMap", ",", "}", "\n", "bf", ".", "typeName", "=", "\"", "\"", "\n\n", "if", "err", ":=", "bf", ".", "Set", "(", "defaultOptions", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "bf", ",", "nil", "\n", "}" ]

[ "NewBitFlags", "initializes", "a", "simple", "bitflag", "version", "of", "the", "OptionList", "Type", ".", "flagMap", "is", "the", "mapping", "from", "option", "names", "to", "the", "integer", "value" ]

[ "func", "parseList", "(", "scanner", "*", "bufio", ".", "Scanner", ",", "count", "int", ")", "(", "[", "]", "string", ",", "error", ")", "{", "got", ":=", "0", "\n", "items", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "count", ")", "\n", "for", "{", "if", "!", "scanner", ".", "Scan", "(", ")", "{", "if", "err", ":=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "line", ":=", "scanner", ".", "Text", "(", ")", "\n", "if", "line", "==", "\"", "\"", "{", "if", "got", "<", "count", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "count", ",", "got", ")", "\n", "}", "\n", "break", "\n", "}", "\n", "got", "++", "\n", "if", "got", ">", "count", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "count", ")", "\n", "}", "\n", "items", "=", "append", "(", "items", ",", "line", ")", "\n", "}", "\n", "return", "items", ",", "nil", "\n", "}" ]

[ "parseList", "parses", "the", "list", "part", "of", "a", "block", ".", "It", "makes", "sure", "that", "there", "is", "an", "exactly", "expected", "count", "of", "items", "." ]

[ "func", "(", "list", "*", "Lists", ")", "GenerateFilelist", "(", "out", "io", ".", "Writer", ")", "error", "{", "w", ":=", "bufio", ".", "NewWriter", "(", "out", ")", "\n", "for", "_", ",", "pair", ":=", "range", "list", ".", "getPairs", "(", ")", "{", "dLen", ":=", "len", "(", "*", "pair", ".", "data", ")", "\n", "toWrite", ":=", "[", "]", "string", "{", "pair", ".", "kind", ",", "\"", "\\n", "\"", ",", "strconv", ".", "Itoa", "(", "dLen", ")", ",", "\"", "\\n", "\"", ",", "}", "\n", "if", "dLen", ">", "0", "{", "toWrite", "=", "append", "(", "toWrite", ",", "strings", ".", "Join", "(", "*", "pair", ".", "data", ",", "\"", "\\n", "\"", ")", ",", "\"", "\\n", "\"", ")", "\n", "}", "\n", "toWrite", "=", "append", "(", "toWrite", ",", "\"", "\\n", "\"", ")", "\n", "for", "_", ",", "str", ":=", "range", "toWrite", "{", "if", "_", ",", "err", ":=", "w", ".", "WriteString", "(", "str", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "w", ".", "Flush", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "GenerateFilelist", "generates", "a", "filelist", "duh", ".", "And", "writes", "it", "to", "a", "given", "writer", ".", "The", "format", "of", "generated", "file", "is", "described", "in", "filelist", ".", "ParseFilelist", "." ]

[ "func", "GenerateFileDeps", "(", "target", ",", "filesGenerator", "string", ",", "files", "[", "]", "string", ")", "string", "{", "return", "replacePlaceholders", "(", "fileDepMkTemplate", ",", "\"", "\"", ",", "appName", "(", ")", ",", "\"", "\"", ",", "filesGenerator", ",", "\"", "\"", ",", "strings", ".", "Join", "(", "files", ",", "\"", "\"", ")", ",", "\"", "\"", ",", "target", ",", ")", "\n", "}" ]

[ "GenerateFileDeps", "returns", "contents", "of", "make", "file", "describing", "dependencies", "of", "given", "target", "on", "given", "files", "and", "checking", "if", "files", "weren", "t", "added", "or", "removed", "in", "directories", "where", "given", "files", "are", "." ]

[ "func", "MakeResolvConf", "(", "dns", "cnitypes", ".", "DNS", ",", "comment", "string", ")", "string", "{", "content", ":=", "\"", "\"", "\n", "if", "len", "(", "comment", ")", ">", "0", "{", "content", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\n", "\"", ",", "comment", ")", "\n", "}", "\n\n", "if", "len", "(", "dns", ".", "Search", ")", ">", "0", "{", "content", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "strings", ".", "Join", "(", "dns", ".", "Search", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "for", "_", ",", "ns", ":=", "range", "dns", ".", "Nameservers", "{", "content", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "ns", ")", "\n", "}", "\n", "if", "len", "(", "dns", ".", "Options", ")", ">", "0", "{", "content", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "strings", ".", "Join", "(", "dns", ".", "Options", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "if", "len", "(", "dns", ".", "Domain", ")", ">", "0", "{", "content", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "dns", ".", "Domain", ")", "\n", "}", "\n", "return", "content", "\n", "}" ]

[ "MakeResolvConf", "generates", "resolv", ".", "conf", "contents", "given", "a", "cni", "DNS", "configuration" ]

[ "func", "extractFileFromTar", "(", "tr", "*", "tar", ".", "Reader", ",", "file", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "for", "{", "hdr", ",", "err", ":=", "tr", ".", "Next", "(", ")", "\n", "switch", "err", "{", "case", "io", ".", "EOF", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "case", "nil", ":", "if", "filepath", ".", "Clean", "(", "hdr", ".", "Name", ")", "!=", "filepath", ".", "Clean", "(", "file", ")", "{", "continue", "\n", "}", "\n", "switch", "hdr", ".", "Typeflag", "{", "case", "tar", ".", "TypeReg", ":", "case", "tar", ".", "TypeRegA", ":", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "buf", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "tr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "buf", ",", "nil", "\n", "default", ":", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}" ]

[ "extractFileFromTar", "extracts", "a", "regular", "file", "from", "the", "given", "tar", "returning", "its", "contents", "as", "a", "byte", "slice" ]

[ "func", "(", "n", "*", "Networking", ")", "GetForwardableNet", "(", ")", "(", "*", "activeNet", ",", "error", ")", "{", "numberNets", ":=", "len", "(", "n", ".", "nets", ")", "\n", "if", "numberNets", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "net", ":=", "range", "n", ".", "nets", "{", "if", "net", ".", "IPMasq", "(", ")", "{", "return", "&", "net", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "&", "n", ".", "nets", "[", "numberNets", "-", "1", "]", ",", "nil", "\n", "}" ]

[ "GetForwardableNet", "iterates", "through", "all", "loaded", "networks", "and", "returns", "either", "the", "first", "network", "that", "has", "masquerading", "enabled", "or", "the", "last", "network", "in", "case", "there", "is", "no", "masqueraded", "one", "or", "an", "error", "if", "no", "network", "was", "loaded", "." ]

[ "func", "(", "e", "*", "podEnv", ")", "setupForwarding", "(", ")", "error", "{", "ipt", ",", "err", ":=", "iptables", ".", "New", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Create a separate chain for this pod. This helps with debugging", "// and makes it easier to cleanup", "chainDNAT", ":=", "e", ".", "portFwdChain", "(", "\"", "\"", ")", "\n", "chainSNAT", ":=", "e", ".", "portFwdChain", "(", "\"", "\"", ")", "\n\n", "if", "err", "=", "ipt", ".", "NewChain", "(", "\"", "\"", ",", "chainDNAT", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "ipt", ".", "NewChain", "(", "\"", "\"", ",", "chainSNAT", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "chainRuleDNAT", ":=", "e", ".", "portFwdChainRuleSpec", "(", "chainDNAT", ",", "\"", "\"", ")", "\n", "chainRuleSNAT", ":=", "e", ".", "portFwdChainRuleSpec", "(", "chainSNAT", ",", "\"", "\"", ")", "\n\n", "for", "_", ",", "entry", ":=", "range", "[", "]", "struct", "{", "chain", "string", "\n", "customChainRule", "[", "]", "string", "\n", "}", "{", "{", "\"", "\"", ",", "chainRuleSNAT", "}", ",", "// traffic originating from this host from loopback", "{", "\"", "\"", ",", "chainRuleDNAT", "}", ",", "// outside traffic hitting this host", "{", "\"", "\"", ",", "chainRuleDNAT", "}", ",", "// traffic originating from this host on non-loopback", "}", "{", "exists", ",", "err", ":=", "ipt", ".", "Exists", "(", "\"", "\"", ",", "entry", ".", "chain", ",", "entry", ".", "customChainRule", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "exists", "{", "err", "=", "ipt", ".", "Insert", "(", "\"", "\"", ",", "entry", ".", "chain", ",", "1", ",", "entry", ".", "customChainRule", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setupForwarding", "creates", "the", "iptables", "chains" ]

[ "func", "KvmNetworkingToSystemd", "(", "p", "*", "stage1commontypes", ".", "Pod", ",", "n", "*", "networking", ".", "Networking", ")", "error", "{", "podRoot", ":=", "common", ".", "Stage1RootfsPath", "(", "p", ".", "Root", ")", "\n\n", "// networking", "netDescriptions", ":=", "kvm", ".", "GetNetworkDescriptions", "(", "n", ")", "\n", "if", "err", ":=", "kvm", ".", "GenerateNetworkInterfaceUnits", "(", "filepath", ".", "Join", "(", "podRoot", ",", "stage1initcommon", ".", "UnitsDir", ")", ",", "netDescriptions", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "KvmNetworkingToSystemd", "generates", "systemd", "unit", "files", "for", "a", "pod", "according", "to", "network", "configuration" ]

[ "func", "initPods", "(", "dataDir", "string", ")", "error", "{", "if", "!", "podsInitialized", "{", "dirs", ":=", "[", "]", "string", "{", "embryoDir", "(", "dataDir", ")", ",", "prepareDir", "(", "dataDir", ")", ",", "preparedDir", "(", "dataDir", ")", ",", "runDir", "(", "dataDir", ")", ",", "exitedGarbageDir", "(", "dataDir", ")", ",", "garbageDir", "(", "dataDir", ")", "}", "\n", "for", "_", ",", "d", ":=", "range", "dirs", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "d", ",", "0750", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n", "podsInitialized", "=", "true", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "initPods", "creates", "the", "required", "global", "directories" ]

[ "func", "(", "p", "*", "Pod", ")", "embryoPath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "embryoDir", "(", "p", ".", "dataDir", ")", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", "\n", "}" ]

[ "embryoPath", "returns", "the", "path", "to", "the", "pod", "where", "it", "would", "be", "in", "the", "embryoDir", "in", "its", "embryonic", "state", "." ]

[ "func", "(", "p", "*", "Pod", ")", "preparePath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "prepareDir", "(", "p", ".", "dataDir", ")", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", "\n", "}" ]

[ "preparePath", "returns", "the", "path", "to", "the", "pod", "where", "it", "would", "be", "in", "the", "prepareDir", "in", "its", "preparing", "state", "." ]

[ "func", "(", "p", "*", "Pod", ")", "preparedPath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "preparedDir", "(", "p", ".", "dataDir", ")", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", "\n", "}" ]

[ "preparedPath", "returns", "the", "path", "to", "the", "pod", "where", "it", "would", "be", "in", "the", "preparedDir", "." ]

[ "func", "(", "p", "*", "Pod", ")", "runPath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "runDir", "(", "p", ".", "dataDir", ")", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", "\n", "}" ]

[ "runPath", "returns", "the", "path", "to", "the", "pod", "where", "it", "would", "be", "in", "the", "runDir", "." ]

[ "func", "(", "p", "*", "Pod", ")", "exitedGarbagePath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "exitedGarbageDir", "(", "p", ".", "dataDir", ")", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", "\n", "}" ]

[ "exitedGarbagePath", "returns", "the", "path", "to", "the", "pod", "where", "it", "would", "be", "in", "the", "exitedGarbageDir", "." ]

[ "func", "(", "p", "*", "Pod", ")", "garbagePath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "garbageDir", "(", "p", ".", "dataDir", ")", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", "\n", "}" ]

[ "garbagePath", "returns", "the", "path", "to", "the", "pod", "where", "it", "would", "be", "in", "the", "garbageDir", "." ]

[ "func", "(", "p", "*", "Pod", ")", "ToExitedGarbage", "(", ")", "error", "{", "if", "!", "p", ".", "isExited", "||", "p", ".", "isExitedGarbage", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "os", ".", "Rename", "(", "p", ".", "runPath", "(", ")", ",", "p", ".", "exitedGarbagePath", "(", ")", ")", ";", "err", "!=", "nil", "{", "// TODO(vc): another case where we could race with a concurrent ToExitedGarbage(), let caller deal with the error.", "return", "err", "\n", "}", "\n\n", "df", ",", "err", ":=", "os", ".", "Open", "(", "exitedGarbageDir", "(", "p", ".", "dataDir", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "df", ".", "Close", "(", ")", "\n", "if", "err", ":=", "df", ".", "Sync", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "p", ".", "isExitedGarbage", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "ToExitedGarbage", "transitions", "a", "pod", "from", "run", "-", ">", "exitedGarbage", "This", "method", "refreshes", "the", "pod", "state", "." ]

[ "func", "(", "p", "*", "Pod", ")", "ToGarbage", "(", ")", "error", "{", "if", "!", "p", ".", "isAbortedPrepare", "&&", "!", "p", ".", "isPrepared", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "os", ".", "Rename", "(", "p", ".", "Path", "(", ")", ",", "p", ".", "garbagePath", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "df", ",", "err", ":=", "os", ".", "Open", "(", "garbageDir", "(", "p", ".", "dataDir", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "df", ".", "Close", "(", ")", "\n", "if", "err", ":=", "df", ".", "Sync", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "p", ".", "isAbortedPrepare", "=", "false", "\n", "p", ".", "isPrepared", "=", "false", "\n", "p", ".", "isGarbage", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "ToGarbage", "transitions", "a", "pod", "from", "abortedPrepared", "-", ">", "garbage", "or", "prepared", "-", ">", "garbage", "This", "method", "refreshes", "the", "pod", "state", "." ]

[ "func", "listPods", "(", "dataDir", "string", ",", "include", "IncludeMask", ")", "(", "[", "]", "string", ",", "error", ")", "{", "// uniqued due to the possibility of a pod being renamed from across directories during the list operation", "ups", ":=", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", "\n", "dirs", ":=", "[", "]", "struct", "{", "kind", "IncludeMask", "\n", "path", "string", "\n", "}", "{", "{", "// the order here is significant: embryo -> preparing -> prepared -> running -> exitedGarbage", "kind", ":", "IncludeEmbryoDir", ",", "path", ":", "embryoDir", "(", "dataDir", ")", ",", "}", ",", "{", "kind", ":", "IncludePrepareDir", ",", "path", ":", "prepareDir", "(", "dataDir", ")", ",", "}", ",", "{", "kind", ":", "IncludePreparedDir", ",", "path", ":", "preparedDir", "(", "dataDir", ")", ",", "}", ",", "{", "kind", ":", "IncludeRunDir", ",", "path", ":", "runDir", "(", "dataDir", ")", ",", "}", ",", "{", "kind", ":", "IncludeExitedGarbageDir", ",", "path", ":", "exitedGarbageDir", "(", "dataDir", ")", ",", "}", ",", "{", "kind", ":", "IncludeGarbageDir", ",", "path", ":", "garbageDir", "(", "dataDir", ")", ",", "}", ",", "}", "\n\n", "for", "_", ",", "d", ":=", "range", "dirs", "{", "if", "include", "&", "d", ".", "kind", "!=", "0", "{", "ps", ",", "err", ":=", "listPodsFromDir", "(", "d", ".", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "p", ":=", "range", "ps", "{", "ups", "[", "p", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "ps", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "ups", ")", ")", "\n", "for", "p", ":=", "range", "ups", "{", "ps", "=", "append", "(", "ps", ",", "p", ")", "\n", "}", "\n\n", "return", "ps", ",", "nil", "\n", "}" ]

[ "listPods", "returns", "a", "list", "of", "pod", "uuids", "in", "string", "form", "." ]

[ "func", "listPodsFromDir", "(", "cdir", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "ps", "[", "]", "string", "\n\n", "ls", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "cdir", ")", "\n", "if", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "ps", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "p", ":=", "range", "ls", "{", "if", "!", "p", ".", "IsDir", "(", ")", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "p", ".", "Name", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "ps", "=", "append", "(", "ps", ",", "p", ".", "Name", "(", ")", ")", "\n", "}", "\n\n", "return", "ps", ",", "nil", "\n", "}" ]

[ "listPodsFromDir", "returns", "a", "list", "of", "pod", "uuids", "in", "string", "form", "from", "a", "specific", "directory", "." ]

[ "func", "(", "p", "*", "Pod", ")", "readFile", "(", "path", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "f", ",", "err", ":=", "p", ".", "openFile", "(", "path", ",", "syscall", ".", "O_RDONLY", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "return", "ioutil", ".", "ReadAll", "(", "f", ")", "\n", "}" ]

[ "readFile", "reads", "an", "entire", "file", "from", "a", "pod", "s", "directory", "." ]

[ "func", "(", "p", "*", "Pod", ")", "readIntFromFile", "(", "path", "string", ")", "(", "i", "int", ",", "err", "error", ")", "{", "b", ",", "err", ":=", "p", ".", "readFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "_", ",", "err", "=", "fmt", ".", "Sscanf", "(", "string", "(", "b", ")", ",", "\"", "\"", ",", "&", "i", ")", "\n", "return", "\n", "}" ]

[ "readIntFromFile", "reads", "an", "int", "from", "a", "file", "in", "a", "pod", "s", "directory", "." ]

[ "func", "(", "p", "*", "Pod", ")", "openFile", "(", "path", "string", ",", "flags", "int", ")", "(", "*", "os", ".", "File", ",", "error", ")", "{", "cdirfd", ",", "err", ":=", "p", ".", "Fd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "fd", ",", "err", ":=", "syscall", ".", "Openat", "(", "cdirfd", ",", "path", ",", "flags", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "os", ".", "NewFile", "(", "uintptr", "(", "fd", ")", ",", "path", ")", ",", "nil", "\n", "}" ]

[ "openFile", "opens", "a", "file", "from", "a", "pod", "s", "directory", "returning", "a", "file", "descriptor", "." ]

[ "func", "getChildPID", "(", "ppid", "int", ")", "(", "int", ",", "error", ")", "{", "var", "pid", "int", "\n\n", "// If possible, get the child in O(1). Fallback on O(n) when the kernel does not have", "// either CONFIG_PROC_CHILDREN or CONFIG_CHECKPOINT_RESTORE", "_", ",", "err", ":=", "os", ".", "Stat", "(", "\"", "\"", ")", "\n", "if", "err", "==", "nil", "{", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ppid", ",", "ppid", ")", ")", "\n", "if", "err", "==", "nil", "{", "children", ":=", "strings", ".", "SplitN", "(", "string", "(", "b", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "children", ")", "==", "2", "&&", "children", "[", "1", "]", "!=", "\"", "\"", "{", "return", "-", "1", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ppid", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "fmt", ".", "Sscanf", "(", "children", "[", "0", "]", ",", "\"", "\"", ",", "&", "pid", ")", ";", "err", "==", "nil", "{", "return", "pid", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "-", "1", ",", "ErrChildNotReady", "{", "}", "\n", "}", "\n\n", "// Fallback on the slower method", "fdir", ",", "err", ":=", "os", ".", "Open", "(", "`/proc`", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n", "defer", "fdir", ".", "Close", "(", ")", "\n\n", "for", "{", "fi", ",", "err", ":=", "fdir", ".", "Readdir", "(", "1", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n", "if", "len", "(", "fi", ")", "==", "0", "{", "// See https://github.com/rkt/rkt/issues/3109#issuecomment-242209246", "continue", "\n", "}", "\n", "var", "pid64", "int64", "\n", "if", "pid64", ",", "err", "=", "strconv", ".", "ParseInt", "(", "fi", "[", "0", "]", ".", "Name", "(", ")", ",", "10", ",", "0", ")", ";", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "filename", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pid64", ")", "\n", "statBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "// The process just died? It's not the one we want then.", "continue", "\n", "}", "\n", "statFields", ":=", "strings", ".", "SplitN", "(", "string", "(", "statBytes", ")", ",", "\"", "\"", ",", "5", ")", "\n", "if", "len", "(", "statFields", ")", "!=", "5", "{", "return", "-", "1", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "filename", ")", "\n", "}", "\n", "if", "statFields", "[", "3", "]", "==", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ppid", ")", "{", "return", "int", "(", "pid64", ")", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "-", "1", ",", "ErrChildNotReady", "{", "}", "\n", "}" ]

[ "Returns", "the", "pid", "of", "the", "child", "or", "ErrChildNotReady", "if", "not", "ready" ]

[ "func", "(", "p", "*", "Pod", ")", "getAppsHashes", "(", ")", "(", "[", "]", "types", ".", "Hash", ",", "error", ")", "{", "apps", ",", "err", ":=", "p", ".", "getApps", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "hashes", "[", "]", "types", ".", "Hash", "\n", "for", "_", ",", "a", ":=", "range", "apps", "{", "hashes", "=", "append", "(", "hashes", ",", "a", ".", "Image", ".", "ID", ")", "\n", "}", "\n\n", "return", "hashes", ",", "nil", "\n", "}" ]

[ "getAppsHashes", "returns", "a", "list", "of", "the", "app", "hashes", "in", "the", "pod" ]

[ "func", "(", "p", "*", "Pod", ")", "getApps", "(", ")", "(", "schema", ".", "AppList", ",", "error", ")", "{", "_", ",", "pm", ",", "err", ":=", "p", ".", "PodManifest", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "pm", ".", "Apps", ",", "nil", "\n", "}" ]

[ "getApps", "returns", "a", "list", "of", "apps", "in", "the", "pod" ]

[ "func", "(", "p", "*", "Pod", ")", "getDirNames", "(", "path", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "dir", ",", "err", ":=", "p", ".", "openFile", "(", "path", ",", "syscall", ".", "O_RDONLY", "|", "syscall", ".", "O_DIRECTORY", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "defer", "dir", ".", "Close", "(", ")", "\n\n", "ld", ",", "err", ":=", "dir", ".", "Readdirnames", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "ld", ",", "nil", "\n", "}" ]

[ "getDirNames", "returns", "the", "list", "of", "names", "from", "a", "pod", "s", "directory" ]

[ "func", "(", "p", "*", "Pod", ")", "Sync", "(", ")", "error", "{", "cfd", ",", "err", ":=", "p", ".", "Fd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "sys", ".", "Syncfs", "(", "cfd", ")", ";", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "UUID", ".", "String", "(", ")", ")", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Sync", "syncs", "the", "pod", "data", ".", "By", "now", "it", "calls", "a", "syncfs", "on", "the", "filesystem", "containing", "the", "pod", "s", "directory", "." ]

[ "func", "WalkPods", "(", "dataDir", "string", ",", "include", "IncludeMask", ",", "f", "func", "(", "*", "Pod", ")", ")", "error", "{", "if", "err", ":=", "initPods", "(", "dataDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ls", ",", "err", ":=", "listPods", "(", "dataDir", ",", "include", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "ls", ")", "\n\n", "for", "_", ",", "uuid", ":=", "range", "ls", "{", "u", ",", "err", ":=", "types", ".", "NewUUID", "(", "uuid", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "uuid", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "p", ",", "err", ":=", "getPod", "(", "dataDir", ",", "u", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "uuid", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "// omit pods found in unrequested states", "// this is to cover a race between listPods finding the uuids and pod states changing", "// it's preferable to keep these operations lock-free, for example a `rkt gc` shouldn't block `rkt run`.", "if", "p", ".", "isEmbryo", "&&", "include", "&", "IncludeEmbryoDir", "==", "0", "||", "p", ".", "isExitedGarbage", "&&", "include", "&", "IncludeExitedGarbageDir", "==", "0", "||", "p", ".", "isGarbage", "&&", "include", "&", "IncludeGarbageDir", "==", "0", "||", "p", ".", "isPrepared", "&&", "include", "&", "IncludePreparedDir", "==", "0", "||", "(", "(", "p", ".", "isPreparing", "||", "p", ".", "isAbortedPrepare", ")", "&&", "include", "&", "IncludePrepareDir", "==", "0", ")", "||", "p", ".", "isRunning", "(", ")", "&&", "include", "&", "IncludeRunDir", "==", "0", "{", "p", ".", "Close", "(", ")", "\n", "continue", "\n", "}", "\n\n", "f", "(", "p", ")", "\n", "p", ".", "Close", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "WalkPods", "iterates", "over", "the", "included", "directories", "calling", "function", "f", "for", "every", "pod", "found", ".", "The", "pod", "will", "be", "closed", "after", "the", "function", "f", "is", "executed", "." ]

[ "func", "(", "p", "*", "Pod", ")", "PodManifest", "(", ")", "(", "[", "]", "byte", ",", "*", "schema", ".", "PodManifest", ",", "error", ")", "{", "pmb", ",", "err", ":=", "p", ".", "readFile", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "pm", ":=", "&", "schema", ".", "PodManifest", "{", "}", "\n", "if", "err", "=", "pm", ".", "UnmarshalJSON", "(", "pmb", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "return", "pmb", ",", "pm", ",", "nil", "\n", "}" ]

[ "PodManifest", "reads", "the", "pod", "manifest", "returns", "the", "raw", "bytes", "and", "the", "unmarshalled", "object", "." ]

[ "func", "(", "p", "*", "Pod", ")", "AppImageManifest", "(", "appName", "string", ")", "(", "*", "schema", ".", "ImageManifest", ",", "error", ")", "{", "appACName", ",", "err", ":=", "types", ".", "NewACName", "(", "appName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "imb", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "common", ".", "AppImageManifestPath", "(", "p", ".", "Path", "(", ")", ",", "*", "appACName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "aim", ":=", "&", "schema", ".", "ImageManifest", "{", "}", "\n", "if", "err", ":=", "aim", ".", "UnmarshalJSON", "(", "imb", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "appName", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "aim", ",", "nil", "\n", "}" ]

[ "AppImageManifest", "returns", "an", "ImageManifest", "for", "the", "app", "." ]

[ "func", "(", "p", "*", "Pod", ")", "CreationTime", "(", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "if", "!", "(", "p", ".", "isPrepared", "||", "p", ".", "isRunning", "(", ")", "||", "p", ".", "IsAfterRun", "(", ")", ")", "{", "return", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", "\n", "t", ",", "err", ":=", "p", ".", "getModTime", "(", "\"", "\"", ")", "\n", "if", "err", "==", "nil", "{", "return", "t", ",", "nil", "\n", "}", "\n", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "t", ",", "err", "\n", "}", "\n", "// backwards compatibility with rkt before v1.20", "return", "p", ".", "getModTime", "(", "\"", "\"", ")", "\n", "}" ]

[ "CreationTime", "returns", "the", "time", "when", "the", "pod", "was", "created", ".", "This", "happens", "at", "prepare", "time", "." ]

[ "func", "(", "p", "*", "Pod", ")", "StartTime", "(", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "var", "(", "t", "time", ".", "Time", "\n", "retErr", "error", "\n", ")", "\n\n", "if", "!", "p", ".", "isRunning", "(", ")", "&&", "!", "p", ".", "IsAfterRun", "(", ")", "{", "// hasn't started", "return", "t", ",", "nil", "\n", "}", "\n\n", "// check pid and ppid since stage1s can choose one xor the other", "for", "_", ",", "ctimeFile", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "{", "t", ",", "err", ":=", "p", ".", "getModTime", "(", "ctimeFile", ")", "\n", "if", "err", "==", "nil", "{", "return", "t", ",", "nil", "\n", "}", "\n", "// if there's an error starting the pod, it can go to \"exited\" without", "// creating a ppid/pid file, so ignore not-exist errors.", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "retErr", "=", "err", "\n", "}", "\n", "}", "\n\n", "return", "t", ",", "retErr", "\n", "}" ]

[ "StartTime", "returns", "the", "time", "when", "the", "pod", "was", "started", "." ]

[ "func", "(", "p", "*", "Pod", ")", "GCMarkedTime", "(", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "if", "!", "p", ".", "isGarbage", "&&", "!", "p", ".", "isExitedGarbage", "{", "return", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", "\n\n", "// At this point, the pod is in either exited-garbage dir, garbage dir or gone already.", "podPath", ":=", "p", ".", "Path", "(", ")", "\n", "if", "podPath", "==", "\"", "\"", "{", "// Pod is gone.", "return", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", "\n\n", "st", ":=", "&", "syscall", ".", "Stat_t", "{", "}", "\n", "if", "err", ":=", "syscall", ".", "Lstat", "(", "podPath", ",", "st", ")", ";", "err", "!=", "nil", "{", "if", "err", "==", "syscall", ".", "ENOENT", "{", "// Pod is gone.", "err", "=", "nil", "\n", "}", "\n", "return", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "return", "time", ".", "Unix", "(", "st", ".", "Ctim", ".", "Unix", "(", ")", ")", ",", "nil", "\n", "}" ]

[ "GCMarkedTime", "returns", "the", "time", "when", "the", "pod", "is", "marked", "by", "gc", "." ]

[ "func", "(", "p", "*", "Pod", ")", "Pid", "(", ")", "(", "int", ",", "error", ")", "{", "if", "pid", ",", "err", ":=", "p", ".", "readIntFromFile", "(", "\"", "\"", ")", ";", "err", "==", "nil", "{", "return", "pid", ",", "nil", "\n", "}", "\n", "if", "pid", ",", "err", ":=", "p", ".", "readIntFromFile", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "else", "{", "return", "pid", ",", "nil", "\n", "}", "\n", "}" ]

[ "Pid", "returns", "the", "pid", "of", "the", "stage1", "process", "that", "started", "the", "pod", "." ]

[ "func", "(", "p", "*", "Pod", ")", "Stage1RootfsPath", "(", ")", "(", "string", ",", "error", ")", "{", "stage1RootfsPath", ":=", "\"", "\"", "\n", "if", "p", ".", "UsesOverlay", "(", ")", "{", "stage1TreeStoreID", ",", "err", ":=", "p", ".", "GetStage1TreeStoreID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "stage1RootfsPath", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "stage1TreeStoreID", ")", "\n", "}", "\n\n", "return", "filepath", ".", "Join", "(", "p", ".", "Path", "(", ")", ",", "stage1RootfsPath", ")", ",", "nil", "\n", "}" ]

[ "Stage1RootfsPath", "returns", "the", "stage1", "path", "of", "the", "pod", "." ]

[ "func", "(", "p", "*", "Pod", ")", "JournalLogPath", "(", ")", "(", "string", ",", "error", ")", "{", "stage1RootfsPath", ",", "err", ":=", "p", ".", "Stage1RootfsPath", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "filepath", ".", "Join", "(", "stage1RootfsPath", ",", "\"", "\"", ")", ",", "nil", "\n", "}" ]

[ "JournalLogPath", "returns", "the", "path", "to", "the", "journal", "log", "dir", "of", "the", "pod", "." ]

[ "func", "(", "p", "*", "Pod", ")", "State", "(", ")", "string", "{", "switch", "{", "case", "p", ".", "isEmbryo", ":", "return", "Embryo", "\n", "case", "p", ".", "isPreparing", ":", "return", "Preparing", "\n", "case", "p", ".", "isAbortedPrepare", ":", "return", "AbortedPrepare", "\n", "case", "p", ".", "isPrepared", ":", "return", "Prepared", "\n", "case", "p", ".", "isDeleting", ":", "return", "Deleting", "\n", "case", "p", ".", "isExitedDeleting", ":", "return", "ExitedDeleting", "\n", "case", "p", ".", "isExited", ":", "// this covers p.isExitedGarbage", "if", "p", ".", "isExitedGarbage", "{", "return", "ExitedGarbage", "\n", "}", "\n", "return", "Exited", "\n", "case", "p", ".", "isGarbage", ":", "return", "Garbage", "\n", "}", "\n\n", "return", "Running", "\n", "}" ]

[ "State", "returns", "the", "current", "state", "of", "the", "pod" ]

[ "func", "(", "p", "*", "Pod", ")", "isRunning", "(", ")", "bool", "{", "// when none of these things, running!", "return", "!", "p", ".", "isEmbryo", "&&", "!", "p", ".", "isAbortedPrepare", "&&", "!", "p", ".", "isPreparing", "&&", "!", "p", ".", "isPrepared", "&&", "!", "p", ".", "isExited", "&&", "!", "p", ".", "isExitedGarbage", "&&", "!", "p", ".", "isExitedDeleting", "&&", "!", "p", ".", "isGarbage", "&&", "!", "p", ".", "isDeleting", "&&", "!", "p", ".", "isGone", "\n", "}" ]

[ "isRunning", "does", "the", "annoying", "tests", "to", "infer", "if", "a", "pod", "is", "in", "a", "running", "state" ]

[ "func", "(", "p", "*", "Pod", ")", "PodManifestAvailable", "(", ")", "bool", "{", "if", "p", ".", "isPreparing", "||", "p", ".", "isAbortedPrepare", "||", "p", ".", "isDeleting", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "PodManifestAvailable", "returns", "whether", "the", "caller", "should", "reasonably", "expect", "PodManifest", "to", "function", "in", "the", "pod", "s", "current", "state", ".", "Namely", "in", "Preparing", "AbortedPrepare", "and", "Deleting", "it", "s", "possible", "for", "the", "manifest", "to", "not", "be", "present" ]

[ "func", "(", "p", "*", "Pod", ")", "IsAfterRun", "(", ")", "bool", "{", "return", "p", ".", "isExitedDeleting", "||", "p", ".", "isDeleting", "||", "p", ".", "isExited", "||", "p", ".", "isGarbage", "\n", "}" ]

[ "IsAfterRun", "returns", "true", "if", "the", "pod", "is", "in", "a", "post", "-", "running", "state", "otherwise", "it", "returns", "false", "." ]

[ "func", "(", "p", "*", "Pod", ")", "IsFinished", "(", ")", "bool", "{", "return", "p", ".", "isExited", "||", "p", ".", "isAbortedPrepare", "||", "p", ".", "isGarbage", "||", "p", ".", "isGone", "\n", "}" ]

[ "IsFinished", "returns", "true", "if", "the", "pod", "is", "in", "a", "terminal", "state", "else", "false", "." ]

[ "func", "(", "p", "*", "Pod", ")", "AppExitCode", "(", "appName", "string", ")", "(", "int", ",", "error", ")", "{", "stage1RootfsPath", ",", "err", ":=", "p", ".", "Stage1RootfsPath", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n\n", "statusFile", ":=", "common", ".", "AppStatusPathFromStage1Rootfs", "(", "stage1RootfsPath", ",", "appName", ")", "\n", "return", "p", ".", "readIntFromFile", "(", "statusFile", ")", "\n", "}" ]

[ "AppExitCode", "returns", "the", "app", "s", "exit", "code", ".", "It", "returns", "an", "error", "if", "the", "exit", "code", "file", "doesn", "t", "exit", "or", "the", "content", "of", "the", "file", "is", "invalid", "." ]

[ "func", "StopPod", "(", "dir", "string", ",", "force", "bool", ",", "uuid", "*", "types", ".", "UUID", ")", "error", "{", "s1rootfs", ":=", "common", ".", "Stage1RootfsPath", "(", "dir", ")", "\n\n", "if", "err", ":=", "os", ".", "Chdir", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "ep", ",", "err", ":=", "getStage1Entrypoint", "(", "dir", ",", "stopEntrypoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "args", ":=", "[", "]", "string", "{", "filepath", ".", "Join", "(", "s1rootfs", ",", "ep", ")", "}", "\n", "debug", "(", "\"", "\"", ",", "ep", ")", "\n\n", "if", "force", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", ")", "\n", "}", "\n\n", "args", "=", "append", "(", "args", ",", "uuid", ".", "String", "(", ")", ")", "\n\n", "c", ":=", "exec", ".", "Cmd", "{", "Path", ":", "args", "[", "0", "]", ",", "Args", ":", "args", ",", "Stdout", ":", "os", ".", "Stdout", ",", "Stderr", ":", "os", ".", "Stderr", ",", "}", "\n\n", "return", "c", ".", "Run", "(", ")", "\n", "}" ]

[ "StopPod", "stops", "the", "given", "pod", "." ]

[ "func", "(", "c", "*", "Config", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "stage0", ":=", "[", "]", "interface", "{", "}", "{", "}", "\n\n", "for", "host", ",", "auth", ":=", "range", "c", ".", "AuthPerHost", "{", "var", "typ", "string", "\n", "var", "credentials", "interface", "{", "}", "\n\n", "switch", "h", ":=", "auth", ".", "(", "type", ")", "{", "case", "*", "basicAuthHeaderer", ":", "typ", "=", "\"", "\"", "\n", "credentials", "=", "h", ".", "auth", "\n", "case", "*", "oAuthBearerTokenHeaderer", ":", "typ", "=", "\"", "\"", "\n", "credentials", "=", "h", ".", "auth", "\n", "case", "*", "awsAuthHeaderer", ":", "typ", "=", "\"", "\"", "\n", "credentials", "=", "h", ".", "auth", "\n", "default", ":", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "auth", ":=", "struct", "{", "RktVersion", "string", "`json:\"rktVersion\"`", "\n", "RktKind", "string", "`json:\"rktKind\"`", "\n", "Domains", "[", "]", "string", "`json:\"domains\"`", "\n", "Type", "string", "`json:\"type\"`", "\n", "Credentials", "interface", "{", "}", "`json:\"credentials\"`", "\n", "}", "{", "RktVersion", ":", "\"", "\"", ",", "RktKind", ":", "\"", "\"", ",", "Domains", ":", "[", "]", "string", "{", "host", "}", ",", "Type", ":", "typ", ",", "Credentials", ":", "credentials", ",", "}", "\n\n", "stage0", "=", "append", "(", "stage0", ",", "auth", ")", "\n", "}", "\n\n", "for", "registry", ",", "credentials", ":=", "range", "c", ".", "DockerCredentialsPerRegistry", "{", "dockerAuth", ":=", "struct", "{", "RktVersion", "string", "`json:\"rktVersion\"`", "\n", "RktKind", "string", "`json:\"rktKind\"`", "\n", "Registries", "[", "]", "string", "`json:\"registries\"`", "\n", "Credentials", "BasicCredentials", "`json:\"credentials\"`", "\n", "}", "{", "RktVersion", ":", "\"", "\"", ",", "RktKind", ":", "\"", "\"", ",", "Registries", ":", "[", "]", "string", "{", "registry", "}", ",", "Credentials", ":", "credentials", ",", "}", "\n\n", "stage0", "=", "append", "(", "stage0", ",", "dockerAuth", ")", "\n", "}", "\n\n", "paths", ":=", "struct", "{", "RktVersion", "string", "`json:\"rktVersion\"`", "\n", "RktKind", "string", "`json:\"rktKind\"`", "\n", "Data", "string", "`json:\"data\"`", "\n", "Stage1Images", "string", "`json:\"stage1-images\"`", "\n", "}", "{", "RktVersion", ":", "\"", "\"", ",", "RktKind", ":", "\"", "\"", ",", "Data", ":", "c", ".", "Paths", ".", "DataDir", ",", "Stage1Images", ":", "c", ".", "Paths", ".", "Stage1ImagesDir", ",", "}", "\n\n", "stage1", ":=", "struct", "{", "RktVersion", "string", "`json:\"rktVersion\"`", "\n", "RktKind", "string", "`json:\"rktKind\"`", "\n", "Name", "string", "`json:\"name\"`", "\n", "Version", "string", "`json:\"version\"`", "\n", "Location", "string", "`json:\"location\"`", "\n", "}", "{", "RktVersion", ":", "\"", "\"", ",", "RktKind", ":", "\"", "\"", ",", "Name", ":", "c", ".", "Stage1", ".", "Name", ",", "Version", ":", "c", ".", "Stage1", ".", "Version", ",", "Location", ":", "c", ".", "Stage1", ".", "Location", ",", "}", "\n\n", "stage0", "=", "append", "(", "stage0", ",", "paths", ",", "stage1", ")", "\n\n", "data", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "stage0", "}", "\n", "return", "json", ".", "Marshal", "(", "data", ")", "\n", "}" ]

[ "MarshalJSON", "marshals", "the", "config", "for", "user", "output", "." ]

[ "func", "ResolveAuthPerHost", "(", "authPerHost", "map", "[", "string", "]", "Headerer", ")", "map", "[", "string", "]", "http", ".", "Header", "{", "hostHeaders", ":=", "make", "(", "map", "[", "string", "]", "http", ".", "Header", ",", "len", "(", "authPerHost", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "authPerHost", "{", "hostHeaders", "[", "k", "]", "=", "v", ".", "GetHeader", "(", ")", "\n", "}", "\n", "return", "hostHeaders", "\n", "}" ]

[ "ResolveAuthPerHost", "takes", "a", "map", "of", "strings", "to", "Headerer", "and", "resolves", "the", "Headerers", "to", "http", ".", "Headers" ]

[ "func", "GetConfigFrom", "(", "dirs", "...", "string", ")", "(", "*", "Config", ",", "error", ")", "{", "cfg", ":=", "newConfig", "(", ")", "\n", "for", "_", ",", "cd", ":=", "range", "dirs", "{", "subcfg", ",", "err", ":=", "GetConfigFromDir", "(", "cd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "mergeConfigs", "(", "cfg", ",", "subcfg", ")", "\n", "}", "\n", "return", "cfg", ",", "nil", "\n", "}" ]

[ "GetConfigFrom", "gets", "the", "Config", "instance", "with", "configuration", "taken", "from", "given", "paths", ".", "Subsequent", "paths", "override", "settings", "from", "the", "previous", "paths", "." ]

[ "func", "GetConfigFromDir", "(", "dir", "string", ")", "(", "*", "Config", ",", "error", ")", "{", "subcfg", ":=", "newConfig", "(", ")", "\n", "if", "valid", ",", "err", ":=", "validDir", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "!", "valid", "{", "return", "subcfg", ",", "nil", "\n", "}", "\n", "if", "err", ":=", "readConfigDir", "(", "subcfg", ",", "dir", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "subcfg", ",", "nil", "\n", "}" ]

[ "GetConfigFromDir", "gets", "the", "Config", "instance", "with", "configuration", "taken", "from", "given", "directory", "." ]

[ "func", "WriteEnvFile", "(", "env", "[", "]", "string", ",", "uidRange", "*", "user", ".", "UidRange", ",", "envFilePath", "string", ")", "error", "{", "ef", ":=", "bytes", ".", "Buffer", "{", "}", "\n\n", "for", "_", ",", "v", ":=", "range", "env", "{", "fmt", ".", "Fprintf", "(", "&", "ef", ",", "\"", "\\n", "\"", ",", "v", ")", "\n", "}", "\n\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "filepath", ".", "Dir", "(", "envFilePath", ")", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "envFilePath", ",", "ef", ".", "Bytes", "(", ")", ",", "0644", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "user", ".", "ShiftFiles", "(", "[", "]", "string", "{", "envFilePath", "}", ",", "uidRange", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "WriteEnvFile", "creates", "an", "environment", "file", "for", "given", "app", "name", ".", "To", "ensure", "the", "minimum", "required", "environment", "variables", "by", "the", "appc", "spec", "are", "set", "to", "sensible", "defaults", "env", "should", "be", "the", "result", "of", "calling", "ComposeEnviron", ".", "The", "containing", "directory", "and", "its", "ancestors", "will", "be", "created", "if", "necessary", "." ]

[ "func", "ComposeEnviron", "(", "env", "types", ".", "Environment", ")", "[", "]", "string", "{", "var", "composed", "[", "]", "string", "\n\n", "for", "dk", ",", "dv", ":=", "range", "defaultEnv", "{", "if", "_", ",", "exists", ":=", "env", ".", "Get", "(", "dk", ")", ";", "!", "exists", "{", "composed", "=", "append", "(", "composed", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dk", ",", "dv", ")", ")", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "e", ":=", "range", "env", "{", "composed", "=", "append", "(", "composed", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "Name", ",", "e", ".", "Value", ")", ")", "\n", "}", "\n", "return", "composed", "\n", "}" ]

[ "ComposeEnviron", "formats", "the", "environment", "into", "a", "slice", "of", "strings", "each", "of", "the", "form", "key", "=", "value", ".", "The", "minimum", "required", "environment", "variables", "by", "the", "appc", "spec", "will", "be", "set", "to", "sensible", "defaults", "here", "if", "they", "re", "not", "provided", "by", "env", "." ]

[ "func", "(", "f", "mountFlags", ")", "String", "(", ")", "string", "{", "var", "s", "[", "]", "string", "\n\n", "maybeAppendFlag", ":=", "func", "(", "ff", "uintptr", ",", "desc", "string", ")", "{", "if", "uintptr", "(", "f", ")", "&", "ff", "!=", "0", "{", "s", "=", "append", "(", "s", ",", "desc", ")", "\n", "}", "\n", "}", "\n\n", "maybeAppendFlag", "(", "syscall", ".", "MS_DIRSYNC", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_MANDLOCK", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_NOATIME", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_NODEV", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_NODIRATIME", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_NOEXEC", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_NOSUID", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_RDONLY", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_REC", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_RELATIME", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_SILENT", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_STRICTATIME", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_SYNCHRONOUS", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_REMOUNT", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_BIND", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_SHARED", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_PRIVATE", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_SLAVE", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_UNBINDABLE", ",", "\"", "\"", ")", "\n", "maybeAppendFlag", "(", "syscall", ".", "MS_MOVE", ",", "\"", "\"", ")", "\n\n", "return", "strings", ".", "Join", "(", "s", ",", "\"", "\"", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "readable", "representation", "of", "mountFlags", "based", "on", "which", "bits", "are", "set", ".", "E", ".", "g", ".", "for", "a", "value", "of", "syscall", ".", "MS_RDONLY|syscall", ".", "MS_BIND", "it", "will", "print", "MS_RDONLY|MS_BIND" ]

[ "func", "newValidator", "(", "image", "io", ".", "ReadSeeker", ")", "(", "*", "validator", ",", "error", ")", "{", "manifest", ",", "err", ":=", "aci", ".", "ManifestFromImage", "(", "image", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "v", ":=", "&", "validator", "{", "image", ":", "image", ",", "manifest", ":", "manifest", ",", "}", "\n", "return", "v", ",", "nil", "\n", "}" ]

[ "newValidator", "returns", "a", "validator", "instance", "if", "passed", "image", "is", "indeed", "an", "ACI", "." ]

[ "func", "(", "v", "*", "validator", ")", "ValidateName", "(", "imageName", "string", ")", "error", "{", "name", ":=", "v", ".", "ImageName", "(", ")", "\n", "if", "name", "!=", "imageName", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "imageName", ",", "name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateName", "checks", "if", "desired", "image", "name", "is", "actually", "the", "same", "as", "the", "one", "in", "the", "image", "manifest", "." ]

[ "func", "(", "v", "*", "validator", ")", "ValidateLabels", "(", "labels", "map", "[", "types", ".", "ACIdentifier", "]", "string", ")", "error", "{", "for", "n", ",", "rv", ":=", "range", "labels", "{", "if", "av", ",", "ok", ":=", "v", ".", "manifest", ".", "GetLabel", "(", "n", ".", "String", "(", ")", ")", ";", "ok", "{", "if", "rv", "!=", "av", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "n", ",", "rv", ",", "av", ")", "\n", "}", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateLabels", "checks", "if", "desired", "image", "labels", "are", "actually", "the", "same", "as", "the", "ones", "in", "the", "image", "manifest", "." ]

[ "func", "(", "v", "*", "validator", ")", "ValidateWithSignature", "(", "ks", "*", "keystore", ".", "Keystore", ",", "sig", "io", ".", "ReadSeeker", ")", "(", "*", "openpgp", ".", "Entity", ",", "error", ")", "{", "if", "ks", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "_", ",", "err", ":=", "v", ".", "image", ".", "Seek", "(", "0", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "sig", ".", "Seek", "(", "0", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errwrap", ".", "Wrap", "(", "errors", ".", "New", "(", "\"", "\"", ")", ",", "err", ")", "\n", "}", "\n", "entity", ",", "err", ":=", "ks", ".", "CheckSignature", "(", "v", ".", "ImageName", "(", ")", ",", "v", ".", "image", ",", "sig", ")", "\n", "if", "err", "==", "pgperrors", ".", "ErrUnknownIssuer", "{", "log", ".", "Print", "(", "\"", "\"", ")", "\n", "log", ".", "Print", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "entity", ",", "nil", "\n", "}" ]

[ "ValidateWithSignature", "verifies", "the", "image", "against", "a", "given", "signature", "file", "." ]

[ "func", "Register", "(", "distType", "Type", ",", "f", "newDistribution", ")", "{", "if", "_", ",", "ok", ":=", "distributions", "[", "distType", "]", ";", "ok", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "distType", ")", ")", "\n", "}", "\n", "distributions", "[", "distType", "]", "=", "f", "\n", "}" ]

[ "Register", "registers", "a", "function", "that", "returns", "a", "new", "instance", "of", "the", "given", "distribution", ".", "This", "is", "intended", "to", "be", "called", "from", "the", "init", "function", "in", "packages", "that", "implement", "distribution", "functions", "." ]

[ "func", "Get", "(", "u", "*", "url", ".", "URL", ")", "(", "Distribution", ",", "error", ")", "{", "c", ",", "err", ":=", "parseCIMD", "(", "u", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "u", ".", "String", "(", ")", ",", "err", ")", "\n", "}", "\n", "if", "u", ".", "Scheme", "!=", "Scheme", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "u", ".", "String", "(", ")", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "distributions", "[", "c", ".", "Type", "]", ";", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "Type", ")", "\n", "}", "\n", "return", "distributions", "[", "c", ".", "Type", "]", "(", "u", ")", "\n", "}" ]

[ "Get", "returns", "a", "Distribution", "from", "the", "input", "URI", ".", "It", "returns", "an", "error", "if", "the", "uri", "string", "is", "wrong", "or", "referencing", "an", "unknown", "distribution", "type", "." ]

[ "func", "Parse", "(", "rawuri", "string", ")", "(", "Distribution", ",", "error", ")", "{", "u", ",", "err", ":=", "url", ".", "Parse", "(", "rawuri", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rawuri", ",", "err", ")", "\n", "}", "\n", "return", "Get", "(", "u", ")", "\n", "}" ]

[ "Parse", "parses", "the", "provided", "distribution", "URI", "string", "and", "returns", "a", "Distribution", "." ]

[ "func", "newCompletion", "(", "w", "io", ".", "Writer", ")", "func", "(", "*", "cobra", ".", "Command", ",", "[", "]", "string", ")", "int", "{", "return", "func", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "int", "{", "return", "runCompletion", "(", "w", ",", "cmd", ",", "args", ")", "\n", "}", "\n", "}" ]

[ "newCompletion", "creates", "a", "new", "command", "with", "a", "bounded", "writer", ".", "Writer", "is", "used", "to", "print", "the", "generated", "shell", "-", "completion", "script", "which", "is", "intended", "to", "be", "consumed", "by", "the", "CLI", "users", "." ]

[ "func", "runCompletion", "(", "w", "io", ".", "Writer", ",", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "(", "exit", "int", ")", "{", "if", "len", "(", "args", ")", "==", "0", "{", "stderr", ".", "Print", "(", "\"", "\"", ")", "\n", "return", "254", "\n", "}", "\n\n", "if", "len", "(", "args", ")", ">", "1", "{", "stderr", ".", "Print", "(", "\"", "\"", ")", "\n", "return", "254", "\n", "}", "\n\n", "// Right now only bash completion is supported, but zsh could be", "// supported in a future as well.", "completion", ",", "ok", ":=", "completionShells", "[", "args", "[", "0", "]", "]", "\n", "if", "!", "ok", "{", "stderr", ".", "Printf", "(", "\"", "\"", ",", "args", "[", "0", "]", ")", "\n", "return", "254", "\n", "}", "\n\n", "// Write the shell completion to the specified writer.", "err", ":=", "completion", "(", "w", ",", "cmd", ".", "Parent", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "stderr", ".", "PrintE", "(", "\"", "\"", ",", "err", ")", "\n", "return", "254", "\n", "}", "\n\n", "return", "0", "\n", "}" ]

[ "runCompletion", "is", "a", "command", "handler", "to", "generate", "the", "shell", "script", "with", "shell", "completion", "functions", ".", "It", "ensures", "that", "there", "are", "enough", "arguments", "to", "generate", "the", "completion", "scripts", "." ]