Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "s", "*", "Sandbox", ")", "AddContainer", "(", "c", "*", "oci", ".", "Container", ")", "{", "s", ".", "containers", ".", "Add", "(", "c", ".", "Name", "(", ")", ",", "c", ")", "\n", "}" ]

[ "AddContainer", "adds", "a", "container", "to", "the", "sandbox" ]

[ "func", "(", "s", "*", "Sandbox", ")", "GetContainer", "(", "name", "string", ")", "*", "oci", ".", "Container", "{", "return", "s", ".", "containers", ".", "Get", "(", "name", ")", "\n", "}" ]

[ "GetContainer", "retrieves", "a", "container", "from", "the", "sandbox" ]

[ "func", "(", "s", "*", "Sandbox", ")", "RemoveContainer", "(", "c", "*", "oci", ".", "Container", ")", "{", "s", ".", "containers", ".", "Delete", "(", "c", ".", "Name", "(", ")", ")", "\n", "}" ]

[ "RemoveContainer", "deletes", "a", "container", "from", "the", "sandbox" ]

[ "func", "(", "s", "*", "Sandbox", ")", "SetInfraContainer", "(", "infraCtr", "*", "oci", ".", "Container", ")", "error", "{", "if", "s", ".", "infraContainer", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "else", "if", "infraCtr", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "s", ".", "infraContainer", "=", "infraCtr", "\n\n", "return", "nil", "\n", "}" ]

[ "SetInfraContainer", "sets", "the", "infrastructure", "container", "of", "a", "sandbox", "Attempts", "to", "set", "the", "infrastructure", "container", "after", "one", "is", "already", "present", "will", "throw", "an", "error" ]

[ "func", "(", "s", "*", "Sandbox", ")", "NetNs", "(", ")", "*", "NetNs", "{", "if", "s", ".", "netns", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "s", ".", "netns", ".", "Get", "(", ")", "\n", "}" ]

[ "NetNs", "retrieves", "the", "network", "namespace", "of", "the", "sandbox", "If", "the", "sandbox", "uses", "the", "host", "namespace", "nil", "is", "returned" ]

[ "func", "(", "s", "*", "Sandbox", ")", "NetNsPath", "(", ")", "string", "{", "if", "s", ".", "netns", "==", "nil", "||", "s", ".", "netns", ".", "Get", "(", ")", "==", "nil", "||", "s", ".", "netns", ".", "Get", "(", ")", ".", "symlink", "==", "nil", "{", "if", "s", ".", "infraContainer", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "infraContainer", ".", "State", "(", ")", ".", "Pid", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}", "\n\n", "return", "s", ".", "netns", ".", "Get", "(", ")", ".", "symlink", ".", "Name", "(", ")", "\n", "}" ]

[ "NetNsPath", "returns", "the", "path", "to", "the", "network", "namespace", "of", "the", "sandbox", ".", "If", "the", "sandbox", "uses", "the", "host", "namespace", "nil", "is", "returned" ]

[ "func", "(", "s", "*", "Sandbox", ")", "UserNsPath", "(", ")", "string", "{", "if", "s", ".", "infraContainer", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "infraContainer", ".", "State", "(", ")", ".", "Pid", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "UserNsPath", "returns", "the", "path", "to", "the", "user", "namespace", "of", "the", "sandbox", ".", "If", "the", "sandbox", "uses", "the", "host", "namespace", "nil", "is", "returned" ]

[ "func", "(", "s", "*", "Sandbox", ")", "NetNsCreate", "(", "netNs", "NetNsIface", ")", "error", "{", "// Create a new netNs if nil provided", "if", "netNs", "==", "nil", "{", "netNs", "=", "&", "NetNs", "{", "}", "\n", "}", "\n\n", "// Check if interface is already initialized", "if", "netNs", ".", "Initialized", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "netNs", ",", "err", ":=", "netNs", ".", "Initialize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "netNs", ".", "SymlinkCreate", "(", "s", ".", "name", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n\n", "if", "err1", ":=", "netNs", ".", "Close", "(", ")", ";", "err1", "!=", "nil", "{", "return", "err1", "\n", "}", "\n\n", "return", "err", "\n", "}", "\n\n", "s", ".", "netns", "=", "netNs", "\n", "return", "nil", "\n", "}" ]

[ "NetNsCreate", "creates", "a", "new", "network", "namespace", "for", "the", "sandbox" ]

[ "func", "(", "s", "*", "Sandbox", ")", "NetNsJoin", "(", "nspath", ",", "name", "string", ")", "error", "{", "if", "s", ".", "netns", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "netNS", ",", "err", ":=", "s", ".", "NetNsGet", "(", "nspath", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "s", ".", "netns", "=", "netNS", "\n\n", "return", "nil", "\n", "}" ]

[ "NetNsJoin", "attempts", "to", "join", "the", "sandbox", "to", "an", "existing", "network", "namespace", "This", "will", "fail", "if", "the", "sandbox", "is", "already", "part", "of", "a", "network", "namespace" ]

[ "func", "(", "s", "*", "Sandbox", ")", "NetNsRemove", "(", ")", "error", "{", "if", "s", ".", "netns", "==", "nil", "{", "logrus", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "return", "s", ".", "netns", ".", "Remove", "(", ")", "\n", "}" ]

[ "NetNsRemove", "removes", "the", "network", "namespace", "associated", "with", "the", "sandbox" ]

[ "func", "New", "(", "crioSocketPath", "string", ")", "(", "CrioClient", ",", "error", ")", "{", "tr", ":=", "new", "(", "http", ".", "Transport", ")", "\n", "configureUnixTransport", "(", "tr", ",", "\"", "\"", ",", "crioSocketPath", ")", "\n", "c", ":=", "&", "http", ".", "Client", "{", "Transport", ":", "tr", ",", "}", "\n", "return", "&", "crioClientImpl", "{", "client", ":", "c", ",", "crioSocketPath", ":", "crioSocketPath", ",", "}", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "crio", "client" ]

[ "func", "(", "c", "*", "crioClientImpl", ")", "DaemonInfo", "(", ")", "(", "types", ".", "CrioInfo", ",", "error", ")", "{", "info", ":=", "types", ".", "CrioInfo", "{", "}", "\n", "req", ",", "err", ":=", "c", ".", "getRequest", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "info", ",", "err", "\n", "}", "\n", "resp", ",", "err", ":=", "c", ".", "client", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "info", ",", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "err", "=", "json", ".", "NewDecoder", "(", "resp", ".", "Body", ")", ".", "Decode", "(", "&", "info", ")", "\n", "return", "info", ",", "err", "\n", "}" ]

[ "DaemonInfo", "return", "cri", "-", "o", "daemon", "info", "from", "the", "cri", "-", "o", "info", "endpoint", "." ]

[ "func", "(", "c", "*", "crioClientImpl", ")", "ContainerInfo", "(", "id", "string", ")", "(", "*", "types", ".", "ContainerInfo", ",", "error", ")", "{", "req", ",", "err", ":=", "c", ".", "getRequest", "(", "\"", "\"", "+", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "resp", ",", "err", ":=", "c", ".", "client", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "cInfo", ":=", "types", ".", "ContainerInfo", "{", "}", "\n", "if", "err", ":=", "json", ".", "NewDecoder", "(", "resp", ".", "Body", ")", ".", "Decode", "(", "&", "cInfo", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "cInfo", ",", "nil", "\n", "}" ]

[ "ContainerInfo", "returns", "container", "info", "by", "querying", "the", "cri", "-", "o", "container", "endpoint", "." ]

[ "func", "(", "f", "*", "fifo", ")", "Write", "(", "b", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "if", "f", ".", "flag", "&", "(", "syscall", ".", "O_WRONLY", "|", "syscall", ".", "O_RDWR", ")", "==", "0", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "select", "{", "case", "<-", "f", ".", "opened", ":", "return", "f", ".", "file", ".", "Write", "(", "b", ")", "\n", "default", ":", "}", "\n", "select", "{", "case", "<-", "f", ".", "opened", ":", "return", "f", ".", "file", ".", "Write", "(", "b", ")", "\n", "case", "<-", "f", ".", "closed", ":", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "Write", "from", "byte", "array", "to", "a", "fifo", "." ]

[ "func", "Get", "(", "ctx", "context", ".", "Context", ")", "string", "{", "httpVersion", ":=", "make", "(", "[", "]", "VersionInfo", ",", "0", ",", "4", ")", "\n", "httpVersion", "=", "append", "(", "httpVersion", ",", "VersionInfo", "{", "Name", ":", "\"", "\"", ",", "Version", ":", "version", ".", "Version", "}", ")", "\n", "httpVersion", "=", "append", "(", "httpVersion", ",", "VersionInfo", "{", "Name", ":", "\"", "\"", ",", "Version", ":", "runtime", ".", "Version", "(", ")", "}", ")", "\n", "httpVersion", "=", "append", "(", "httpVersion", ",", "VersionInfo", "{", "Name", ":", "\"", "\"", ",", "Version", ":", "runtime", ".", "GOOS", "}", ")", "\n", "httpVersion", "=", "append", "(", "httpVersion", ",", "VersionInfo", "{", "Name", ":", "\"", "\"", ",", "Version", ":", "runtime", ".", "GOARCH", "}", ")", "\n\n", "return", "AppendVersions", "(", "\"", "\"", ",", "httpVersion", "...", ")", "\n", "}" ]

[ "Get", "is", "the", "User", "-", "Agent", "the", "CRI", "-", "O", "daemon", "uses", "to", "identify", "itself", "." ]

[ "func", "(", "s", "SecretData", ")", "SaveTo", "(", "dir", "string", ")", "error", "{", "path", ":=", "filepath", ".", "Join", "(", "dir", ",", "s", ".", "Name", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "filepath", ".", "Dir", "(", "path", ")", ",", "0700", ")", ";", "err", "!=", "nil", "&&", "!", "os", ".", "IsExist", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "return", "ioutil", ".", "WriteFile", "(", "path", ",", "s", ".", "Data", ",", "0700", ")", "\n", "}" ]

[ "SaveTo", "saves", "secret", "data", "to", "given", "directory" ]

[ "func", "secretMounts", "(", "defaultMountsPaths", "[", "]", "string", ",", "mountLabel", ",", "containerWorkingDir", "string", ",", "runtimeMounts", "[", "]", "rspec", ".", "Mount", ")", "(", "[", "]", "rspec", ".", "Mount", ",", "error", ")", "{", "mounts", ":=", "make", "(", "[", "]", "rspec", ".", "Mount", ",", "0", ",", "len", "(", "defaultMountsPaths", ")", ")", "\n", "for", "_", ",", "path", ":=", "range", "defaultMountsPaths", "{", "hostDir", ",", "ctrDir", ",", "err", ":=", "getMountsMap", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// skip if the hostDir path doesn't exist", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "hostDir", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "hostDir", ")", "\n", "continue", "\n", "}", "\n\n", "ctrDirOnHost", ":=", "filepath", ".", "Join", "(", "containerWorkingDir", ",", "ctrDir", ")", "\n", "// skip if ctrDir has already been mounted by caller", "if", "isAlreadyMounted", "(", "runtimeMounts", ",", "ctrDir", ")", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "ctrDir", ")", "\n", "continue", "\n", "}", "\n\n", "if", "err", ":=", "os", ".", "RemoveAll", "(", "ctrDirOnHost", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "ctrDirOnHost", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "hostDir", ",", "err", "=", "resolveSymbolicLink", "(", "hostDir", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "data", ",", "err", ":=", "getHostSecretData", "(", "hostDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "s", ":=", "range", "data", "{", "if", "err", ":=", "s", ".", "SaveTo", "(", "ctrDirOnHost", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "label", ".", "Relabel", "(", "ctrDirOnHost", ",", "mountLabel", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "m", ":=", "rspec", ".", "Mount", "{", "Source", ":", "ctrDirOnHost", ",", "Destination", ":", "ctrDir", ",", "}", "\n\n", "mounts", "=", "append", "(", "mounts", ",", "m", ")", "\n", "}", "\n", "return", "mounts", ",", "nil", "\n", "}" ]

[ "secretMount", "copies", "the", "contents", "of", "host", "directory", "to", "container", "directory", "and", "returns", "a", "list", "of", "mounts" ]

[ "func", "NewCRILogger", "(", "path", "string", ",", "w", "io", ".", "Writer", ",", "stream", "StreamType", ",", "maxLen", "int", ")", "(", "io", ".", "WriteCloser", ",", "<-", "chan", "struct", "{", "}", ")", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "stream", ",", "path", ")", "\n", "prc", ",", "pwc", ":=", "io", ".", "Pipe", "(", ")", "\n", "stop", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "go", "func", "(", ")", "{", "redirectLogs", "(", "path", ",", "prc", ",", "w", ",", "stream", ",", "maxLen", ")", "\n", "close", "(", "stop", ")", "\n", "}", "(", ")", "\n", "return", "pwc", ",", "stop", "\n", "}" ]

[ "NewCRILogger", "returns", "a", "write", "closer", "which", "redirect", "container", "log", "into", "log", "file", "and", "decorate", "the", "log", "line", "into", "CRI", "defined", "format", ".", "It", "also", "returns", "a", "channel", "which", "indicates", "whether", "the", "logger", "is", "stopped", ".", "maxLen", "is", "the", "max", "length", "limit", "of", "a", "line", ".", "A", "line", "longer", "than", "the", "limit", "will", "be", "cut", "into", "multiple", "lines", "." ]

[ "func", "inStringSlice", "(", "ss", "[", "]", "string", ",", "str", "string", ")", "bool", "{", "for", "_", ",", "s", ":=", "range", "ss", "{", "if", "strings", ".", "EqualFold", "(", "s", ",", "str", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "inStringSlice", "checks", "whether", "a", "string", "is", "inside", "a", "string", "slice", ".", "Comparison", "is", "case", "insensitive", "." ]

[ "func", "getOCICapabilitiesList", "(", ")", "[", "]", "string", "{", "caps", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "capability", ".", "List", "(", ")", ")", ")", "\n", "for", "_", ",", "cap", ":=", "range", "capability", ".", "List", "(", ")", "{", "if", "cap", ">", "validate", ".", "LastCap", "(", ")", "{", "continue", "\n", "}", "\n", "caps", "=", "append", "(", "caps", ",", "\"", "\"", "+", "strings", ".", "ToUpper", "(", "cap", ".", "String", "(", ")", ")", ")", "\n", "}", "\n", "return", "caps", "\n", "}" ]

[ "getOCICapabilitiesList", "returns", "a", "list", "of", "all", "available", "capabilities", "." ]

[ "func", "validateSysctl", "(", "sysctl", "string", ",", "hostNet", ",", "hostIPC", "bool", ")", "error", "{", "nsErrorFmt", ":=", "\"", "\"", "\n", "if", "ns", ",", "found", ":=", "namespaces", "[", "sysctl", "]", ";", "found", "{", "if", "ns", "==", "IpcNamespace", "&&", "hostIPC", "{", "return", "errors", ".", "Errorf", "(", "nsErrorFmt", ",", "sysctl", ",", "ns", ")", "\n", "}", "\n", "if", "ns", "==", "NetNamespace", "&&", "hostNet", "{", "return", "errors", ".", "Errorf", "(", "nsErrorFmt", ",", "sysctl", ",", "ns", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "for", "p", ",", "ns", ":=", "range", "prefixNamespaces", "{", "if", "strings", ".", "HasPrefix", "(", "sysctl", ",", "p", ")", "{", "if", "ns", "==", "IpcNamespace", "&&", "hostIPC", "{", "return", "errors", ".", "Errorf", "(", "nsErrorFmt", ",", "sysctl", ",", "ns", ")", "\n", "}", "\n", "if", "ns", "==", "NetNamespace", "&&", "hostNet", "{", "return", "errors", ".", "Errorf", "(", "nsErrorFmt", ",", "sysctl", ",", "ns", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "sysctl", ")", "\n", "}" ]

[ "validateSysctl", "checks", "that", "a", "sysctl", "is", "whitelisted", "because", "it", "is", "known", "to", "be", "namespaced", "by", "the", "Linux", "kernel", ".", "The", "parameters", "hostNet", "and", "hostIPC", "are", "used", "to", "forbid", "sysctls", "for", "pod", "sharing", "the", "respective", "namespaces", "with", "the", "host", ".", "This", "check", "is", "only", "used", "on", "sysctls", "defined", "by", "the", "user", "in", "the", "crio", ".", "conf", "file", "." ]

[ "func", "translateLabelsToDescription", "(", "labels", "map", "[", "string", "]", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "labels", "[", "types", ".", "KubernetesPodNamespaceLabel", "]", ",", "labels", "[", "types", ".", "KubernetesPodNameLabel", "]", ",", "labels", "[", "types", ".", "KubernetesContainerNameLabel", "]", ")", "\n", "}" ]

[ "Translate", "container", "labels", "to", "a", "description", "of", "the", "container" ]

[ "func", "(", "c", "*", "Config", ")", "GetStore", "(", ")", "(", "cstorage", ".", "Store", ",", "error", ")", "{", "return", "cstorage", ".", "GetStore", "(", "cstorage", ".", "StoreOptions", "{", "RunRoot", ":", "c", ".", "RunRoot", ",", "GraphRoot", ":", "c", ".", "Root", ",", "GraphDriverName", ":", "c", ".", "Storage", ",", "GraphDriverOptions", ":", "c", ".", "StorageOptions", ",", "}", ")", "\n", "}" ]

[ "GetStore", "returns", "the", "container", "storage", "for", "a", "given", "configuration" ]

[ "func", "(", "c", "*", "Config", ")", "UpdateFromFile", "(", "path", "string", ")", "error", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "t", ":=", "new", "(", "tomlConfig", ")", "\n", "t", ".", "fromConfig", "(", "c", ")", "\n\n", "_", ",", "err", "=", "toml", ".", "Decode", "(", "string", "(", "data", ")", ",", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n\n", "t", ".", "toConfig", "(", "c", ")", "\n", "return", "nil", "\n", "}" ]

[ "UpdateFromFile", "populates", "the", "Config", "from", "the", "TOML", "-", "encoded", "file", "at", "the", "given", "path", ".", "Returns", "errors", "encountered", "when", "reading", "or", "parsing", "the", "files", "or", "nil", "otherwise", "." ]

[ "func", "(", "c", "*", "Config", ")", "ToFile", "(", "path", "string", ")", "error", "{", "var", "w", "bytes", ".", "Buffer", "\n", "e", ":=", "toml", ".", "NewEncoder", "(", "&", "w", ")", "\n\n", "t", ":=", "new", "(", "tomlConfig", ")", "\n", "t", ".", "fromConfig", "(", "c", ")", "\n\n", "if", "err", ":=", "e", ".", "Encode", "(", "*", "t", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "ioutil", ".", "WriteFile", "(", "path", ",", "w", ".", "Bytes", "(", ")", ",", "0644", ")", "\n", "}" ]

[ "ToFile", "outputs", "the", "given", "Config", "as", "a", "TOML", "-", "encoded", "file", "at", "the", "given", "path", ".", "Returns", "errors", "encountered", "when", "generating", "or", "writing", "the", "file", "or", "nil", "otherwise", "." ]

[ "func", "(", "c", "*", "Config", ")", "Validate", "(", "onExecution", "bool", ")", "error", "{", "if", "err", ":=", "c", ".", "RootConfig", ".", "Validate", "(", "onExecution", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "RuntimeConfig", ".", "Validate", "(", "onExecution", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "NetworkConfig", ".", "Validate", "(", "onExecution", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "is", "the", "main", "entry", "point", "for", "library", "configuration", "validation", ".", "The", "parameter", "onExecution", "specifies", "if", "the", "validation", "should", "include", "execution", "checks", ".", "It", "returns", "an", "error", "on", "validation", "failure", "otherwise", "nil", "." ]

[ "func", "(", "c", "*", "RootConfig", ")", "Validate", "(", "onExecution", "bool", ")", "error", "{", "if", "onExecution", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "c", ".", "LogDir", ",", "0700", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "is", "the", "main", "entry", "point", "for", "root", "configuration", "validation", ".", "The", "parameter", "onExecution", "specifies", "if", "the", "validation", "should", "include", "execution", "checks", ".", "It", "returns", "an", "error", "on", "validation", "failure", "otherwise", "nil", "." ]

[ "func", "(", "c", "*", "RuntimeConfig", ")", "Validate", "(", "onExecution", "bool", ")", "error", "{", "// This is somehow duplicated with server.getUlimitsFromConfig under server/utils.go", "// but I don't want to export that function for the sake of validation here", "// so, keep it in mind if things start to blow up.", "// Reason for having this here is that I don't want people to start crio", "// with invalid ulimits but realize that only after starting a couple of", "// containers and watching them fail.", "for", "_", ",", "u", ":=", "range", "c", ".", "DefaultUlimits", "{", "ul", ",", "err", ":=", "units", ".", "ParseUlimit", "(", "u", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "u", ",", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "ul", ".", "GetRlimit", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "d", ":=", "range", "c", ".", "AdditionalDevices", "{", "split", ":=", "strings", ".", "Split", "(", "d", ",", "\"", "\"", ")", "\n", "switch", "len", "(", "split", ")", "{", "case", "3", ":", "if", "!", "createconfig", ".", "IsValidDeviceMode", "(", "split", "[", "2", "]", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "split", "[", "2", "]", ")", "\n", "}", "\n", "fallthrough", "\n", "case", "2", ":", "if", "(", "!", "createconfig", ".", "IsValidDeviceMode", "(", "split", "[", "1", "]", ")", "&&", "!", "strings", ".", "HasPrefix", "(", "split", "[", "1", "]", ",", "\"", "\"", ")", ")", "||", "(", "len", "(", "split", ")", "==", "3", "&&", "createconfig", ".", "IsValidDeviceMode", "(", "split", "[", "1", "]", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "split", "[", "1", "]", ")", "\n", "}", "\n", "fallthrough", "\n", "case", "1", ":", "if", "!", "strings", ".", "HasPrefix", "(", "split", "[", "0", "]", ",", "\"", "\"", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "split", "[", "0", "]", ")", "\n", "}", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "d", ")", "\n", "}", "\n", "}", "\n\n", "// check we do have at least a runtime", "if", "_", ",", "ok", ":=", "c", ".", "Runtimes", "[", "c", ".", "DefaultRuntime", "]", ";", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// check for validation on execution", "if", "onExecution", "{", "// Validate if runtime_path does exist for each runtime", "for", "runtime", ",", "handler", ":=", "range", "c", ".", "Runtimes", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "handler", ".", "RuntimePath", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "runtime", ",", "err", ")", "\n", "}", "\n", "logrus", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "runtime", ",", "handler", ".", "RuntimePath", ")", "\n", "}", "\n\n", "// Validate the system registries configuration", "if", "_", ",", "err", ":=", "sysregistriesv2", ".", "GetRegistries", "(", "nil", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "hooksDir", ":=", "range", "c", ".", "HooksDir", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "hooksDir", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "c", ".", "Conmon", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "is", "the", "main", "entry", "point", "for", "runtime", "configuration", "validation", "The", "parameter", "onExecution", "specifies", "if", "the", "validation", "should", "include", "execution", "checks", ".", "It", "returns", "an", "error", "on", "validation", "failure", "otherwise", "nil", "." ]

[ "func", "(", "c", "*", "NetworkConfig", ")", "Validate", "(", "onExecution", "bool", ")", "error", "{", "if", "onExecution", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "c", ".", "NetworkDir", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "for", "_", ",", "pluginDir", ":=", "range", "c", ".", "PluginDir", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "pluginDir", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "is", "the", "main", "entry", "point", "for", "network", "configuration", "validation", ".", "The", "parameter", "onExecution", "specifies", "if", "the", "validation", "should", "include", "execution", "checks", ".", "It", "returns", "an", "error", "on", "validation", "failure", "otherwise", "nil", "." ]

[ "func", "(", "s", "*", "Server", ")", "privilegedSandbox", "(", "req", "*", "pb", ".", "RunPodSandboxRequest", ")", "bool", "{", "securityContext", ":=", "req", ".", "GetConfig", "(", ")", ".", "GetLinux", "(", ")", ".", "GetSecurityContext", "(", ")", "\n", "if", "securityContext", "==", "nil", "{", "return", "false", "\n", "}", "\n\n", "if", "securityContext", ".", "Privileged", "{", "return", "true", "\n", "}", "\n\n", "namespaceOptions", ":=", "securityContext", ".", "GetNamespaceOptions", "(", ")", "\n", "if", "namespaceOptions", "==", "nil", "{", "return", "false", "\n", "}", "\n\n", "if", "namespaceOptions", ".", "GetNetwork", "(", ")", "==", "pb", ".", "NamespaceMode_NODE", "||", "namespaceOptions", ".", "GetPid", "(", ")", "==", "pb", ".", "NamespaceMode_NODE", "||", "namespaceOptions", ".", "GetIpc", "(", ")", "==", "pb", ".", "NamespaceMode_NODE", "{", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "privilegedSandbox", "returns", "true", "if", "the", "sandbox", "configuration", "requires", "additional", "host", "privileges", "for", "the", "sandbox", "." ]

[ "func", "(", "s", "*", "Server", ")", "runtimeHandler", "(", "req", "*", "pb", ".", "RunPodSandboxRequest", ")", "(", "string", ",", "error", ")", "{", "handler", ":=", "req", ".", "GetRuntimeHandler", "(", ")", "\n", "if", "handler", "==", "\"", "\"", "{", "return", "handler", ",", "nil", "\n", "}", "\n\n", "runtime", ",", "ok", ":=", "s", ".", "Runtime", "(", ")", ".", "(", "*", "oci", ".", "Runtime", ")", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "runtime", ".", "ValidateRuntimeHandler", "(", "handler", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "handler", ",", "nil", "\n", "}" ]

[ "runtimeHandler", "returns", "the", "runtime", "handler", "key", "provided", "by", "CRI", "if", "the", "key", "does", "exist", "and", "the", "associated", "data", "are", "valid", ".", "If", "the", "key", "is", "empty", "there", "is", "nothing", "to", "do", "and", "the", "empty", "key", "is", "returned", ".", "For", "every", "other", "case", "this", "function", "will", "return", "an", "empty", "string", "with", "the", "error", "associated", "." ]

[ "func", "(", "s", "*", "Server", ")", "RunPodSandbox", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "RunPodSandboxRequest", ")", "(", "resp", "*", "pb", ".", "RunPodSandboxResponse", ",", "err", "error", ")", "{", "// platform dependent call", "return", "s", ".", "runPodSandbox", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "RunPodSandbox", "creates", "and", "runs", "a", "pod", "-", "level", "sandbox", "." ]

[ "func", "(", "s", "*", "Server", ")", "StopPodSandbox", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "StopPodSandboxRequest", ")", "(", "resp", "*", "pb", ".", "StopPodSandboxResponse", ",", "err", "error", ")", "{", "// platform dependent call", "return", "s", ".", "stopPodSandbox", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "StopPodSandbox", "stops", "the", "sandbox", ".", "If", "there", "are", "any", "running", "containers", "in", "the", "sandbox", "they", "should", "be", "force", "terminated", "." ]

[ "func", "(", "s", "*", "Server", ")", "stopAllPodSandboxes", "(", "ctx", "context", ".", "Context", ")", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ")", "\n", "for", "_", ",", "sb", ":=", "range", "s", ".", "ContainerServer", ".", "ListSandboxes", "(", ")", "{", "pod", ":=", "&", "pb", ".", "StopPodSandboxRequest", "{", "PodSandboxId", ":", "sb", ".", "ID", "(", ")", ",", "}", "\n", "if", "_", ",", "err", ":=", "s", ".", "StopPodSandbox", "(", "ctx", ",", "pod", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "stopAllPodSandboxes", "removes", "all", "pod", "sandboxes" ]

[ "func", "localeToLanguage", "(", "locale", "string", ")", "string", "{", "locale", "=", "strings", ".", "Replace", "(", "strings", ".", "SplitN", "(", "locale", ",", "\"", "\"", ",", "2", ")", "[", "0", "]", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", "\n", "langString", ",", "ok", ":=", "localeToLanguageMap", "[", "strings", ".", "ToLower", "(", "locale", ")", "]", "\n", "if", "!", "ok", "{", "langString", "=", "locale", "\n", "}", "\n", "return", "langString", "\n", "}" ]

[ "localeToLanguage", "translates", "POSIX", "locale", "strings", "to", "BCP", "47", "language", "tags", "." ]

[ "func", "(", "c", "*", "ContainerServer", ")", "ContainerStateFromDisk", "(", "ctr", "*", "oci", ".", "Container", ")", "error", "{", "if", "err", ":=", "ctr", ".", "FromDisk", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// ignore errors, this is a best effort to have up-to-date info about", "// a given container before its state gets stored", "c", ".", "runtime", ".", "UpdateContainerStatus", "(", "ctr", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "ContainerStateFromDisk", "retrieves", "information", "on", "the", "state", "of", "a", "running", "container", "from", "the", "disk" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "ContainerStateToDisk", "(", "ctr", "*", "oci", ".", "Container", ")", "error", "{", "// ignore errors, this is a best effort to have up-to-date info about", "// a given container before its state gets stored", "c", ".", "Runtime", "(", ")", ".", "UpdateContainerStatus", "(", "ctr", ")", "\n\n", "jsonSource", ",", "err", ":=", "ioutils", ".", "NewAtomicFileWriter", "(", "ctr", ".", "StatePath", "(", ")", ",", "0644", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "jsonSource", ".", "Close", "(", ")", "\n", "enc", ":=", "json", ".", "NewEncoder", "(", "jsonSource", ")", "\n", "return", "enc", ".", "Encode", "(", "ctr", ".", "State", "(", ")", ")", "\n", "}" ]

[ "ContainerStateToDisk", "writes", "the", "container", "s", "state", "information", "to", "a", "JSON", "file", "on", "disk" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "ReserveContainerName", "(", "id", ",", "name", "string", ")", "(", "string", ",", "error", ")", "{", "if", "err", ":=", "c", ".", "ctrNameIndex", ".", "Reserve", "(", "name", ",", "id", ")", ";", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "id", ")", "\n", "logrus", ".", "Warn", "(", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "name", ",", "nil", "\n", "}" ]

[ "ReserveContainerName", "holds", "a", "name", "for", "a", "container", "that", "is", "being", "created" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "ReservePodName", "(", "id", ",", "name", "string", ")", "(", "string", ",", "error", ")", "{", "if", "err", ":=", "c", ".", "podNameIndex", ".", "Reserve", "(", "name", ",", "id", ")", ";", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "id", ")", "\n", "logrus", ".", "Warn", "(", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "name", ",", "nil", "\n", "}" ]

[ "ReservePodName", "holds", "a", "name", "for", "a", "pod", "that", "is", "being", "created" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "AddContainer", "(", "ctr", "*", "oci", ".", "Container", ")", "{", "sandbox", ":=", "c", ".", "state", ".", "sandboxes", ".", "Get", "(", "ctr", ".", "Sandbox", "(", ")", ")", "\n", "if", "sandbox", "==", "nil", "{", "return", "\n", "}", "\n", "sandbox", ".", "AddContainer", "(", "ctr", ")", "\n", "c", ".", "state", ".", "containers", ".", "Add", "(", "ctr", ".", "ID", "(", ")", ",", "ctr", ")", "\n", "}" ]

[ "AddContainer", "adds", "a", "container", "to", "the", "container", "state", "store" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "AddInfraContainer", "(", "ctr", "*", "oci", ".", "Container", ")", "{", "c", ".", "state", ".", "infraContainers", ".", "Add", "(", "ctr", ".", "ID", "(", ")", ",", "ctr", ")", "\n", "}" ]

[ "AddInfraContainer", "adds", "a", "container", "to", "the", "container", "state", "store" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "GetContainer", "(", "id", "string", ")", "*", "oci", ".", "Container", "{", "return", "c", ".", "state", ".", "containers", ".", "Get", "(", "id", ")", "\n", "}" ]

[ "GetContainer", "returns", "a", "container", "by", "its", "ID" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "GetInfraContainer", "(", "id", "string", ")", "*", "oci", ".", "Container", "{", "return", "c", ".", "state", ".", "infraContainers", ".", "Get", "(", "id", ")", "\n", "}" ]

[ "GetInfraContainer", "returns", "a", "container", "by", "its", "ID" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "HasContainer", "(", "id", "string", ")", "bool", "{", "return", "c", ".", "state", ".", "containers", ".", "Get", "(", "id", ")", "!=", "nil", "\n", "}" ]

[ "HasContainer", "checks", "if", "a", "container", "exists", "in", "the", "state" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "RemoveContainer", "(", "ctr", "*", "oci", ".", "Container", ")", "{", "sbID", ":=", "ctr", ".", "Sandbox", "(", ")", "\n", "sb", ":=", "c", ".", "state", ".", "sandboxes", ".", "Get", "(", "sbID", ")", "\n", "if", "sb", "==", "nil", "{", "return", "\n", "}", "\n", "sb", ".", "RemoveContainer", "(", "ctr", ")", "\n", "c", ".", "state", ".", "containers", ".", "Delete", "(", "ctr", ".", "ID", "(", ")", ")", "\n", "}" ]

[ "RemoveContainer", "removes", "a", "container", "from", "the", "container", "state", "store" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "RemoveInfraContainer", "(", "ctr", "*", "oci", ".", "Container", ")", "{", "c", ".", "state", ".", "infraContainers", ".", "Delete", "(", "ctr", ".", "ID", "(", ")", ")", "\n", "}" ]

[ "RemoveInfraContainer", "removes", "a", "container", "from", "the", "container", "state", "store" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "ListContainers", "(", "filters", "...", "func", "(", "*", "oci", ".", "Container", ")", "bool", ")", "(", "[", "]", "*", "oci", ".", "Container", ",", "error", ")", "{", "containers", ":=", "c", ".", "listContainers", "(", ")", "\n", "if", "len", "(", "filters", ")", "==", "0", "{", "return", "containers", ",", "nil", "\n", "}", "\n", "filteredContainers", ":=", "make", "(", "[", "]", "*", "oci", ".", "Container", ",", "0", ",", "len", "(", "containers", ")", ")", "\n", "for", "_", ",", "container", ":=", "range", "containers", "{", "for", "_", ",", "filter", ":=", "range", "filters", "{", "if", "filter", "(", "container", ")", "{", "filteredContainers", "=", "append", "(", "filteredContainers", ",", "container", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "filteredContainers", ",", "nil", "\n", "}" ]

[ "ListContainers", "returns", "a", "list", "of", "all", "containers", "stored", "by", "the", "server", "state", "that", "match", "the", "given", "filter", "function" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "AddSandbox", "(", "sb", "*", "sandbox", ".", "Sandbox", ")", "error", "{", "c", ".", "state", ".", "sandboxes", ".", "Add", "(", "sb", ".", "ID", "(", ")", ",", "sb", ")", "\n\n", "c", ".", "stateLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "return", "c", ".", "addSandboxPlatform", "(", "sb", ")", "\n", "}" ]

[ "AddSandbox", "adds", "a", "sandbox", "to", "the", "sandbox", "state", "store" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "GetSandbox", "(", "id", "string", ")", "*", "sandbox", ".", "Sandbox", "{", "return", "c", ".", "state", ".", "sandboxes", ".", "Get", "(", "id", ")", "\n", "}" ]

[ "GetSandbox", "returns", "a", "sandbox", "by", "its", "ID" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "GetSandboxContainer", "(", "id", "string", ")", "*", "oci", ".", "Container", "{", "sb", ":=", "c", ".", "state", ".", "sandboxes", ".", "Get", "(", "id", ")", "\n", "if", "sb", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "sb", ".", "InfraContainer", "(", ")", "\n", "}" ]

[ "GetSandboxContainer", "returns", "a", "sandbox", "s", "infra", "container" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "HasSandbox", "(", "id", "string", ")", "bool", "{", "return", "c", ".", "state", ".", "sandboxes", ".", "Get", "(", "id", ")", "!=", "nil", "\n", "}" ]

[ "HasSandbox", "checks", "if", "a", "sandbox", "exists", "in", "the", "state" ]

[ "func", "(", "c", "*", "ContainerServer", ")", "RemoveSandbox", "(", "id", "string", ")", "error", "{", "sb", ":=", "c", ".", "state", ".", "sandboxes", ".", "Get", "(", "id", ")", "\n", "if", "sb", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "c", ".", "stateLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "if", "err", ":=", "c", ".", "removeSandboxPlatform", "(", "sb", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "c", ".", "state", ".", "sandboxes", ".", "Delete", "(", "id", ")", "\n", "return", "nil", "\n", "}" ]

[ "RemoveSandbox", "removes", "a", "sandbox", "from", "the", "state", "store" ]

[ "func", "(", "s", "*", "Server", ")", "PodSandboxStatus", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "PodSandboxStatusRequest", ")", "(", "resp", "*", "pb", ".", "PodSandboxStatusResponse", ",", "err", "error", ")", "{", "const", "operation", "=", "\"", "\"", "\n", "defer", "func", "(", ")", "{", "recordOperation", "(", "operation", ",", "time", ".", "Now", "(", ")", ")", "\n", "recordError", "(", "operation", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "req", ")", "\n", "sb", ",", "err", ":=", "s", ".", "getPodSandboxFromRequest", "(", "req", ".", "PodSandboxId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "podInfraContainer", ":=", "sb", ".", "InfraContainer", "(", ")", "\n", "cState", ":=", "podInfraContainer", ".", "State", "(", ")", "\n\n", "rStatus", ":=", "pb", ".", "PodSandboxState_SANDBOX_NOTREADY", "\n", "if", "cState", ".", "Status", "==", "oci", ".", "ContainerStateRunning", "{", "rStatus", "=", "pb", ".", "PodSandboxState_SANDBOX_READY", "\n", "}", "\n\n", "linux", ":=", "&", "pb", ".", "LinuxPodSandboxStatus", "{", "Namespaces", ":", "&", "pb", ".", "Namespace", "{", "Options", ":", "&", "pb", ".", "NamespaceOption", "{", "Network", ":", "sb", ".", "NamespaceOptions", "(", ")", ".", "GetNetwork", "(", ")", ",", "Ipc", ":", "sb", ".", "NamespaceOptions", "(", ")", ".", "GetIpc", "(", ")", ",", "Pid", ":", "sb", ".", "NamespaceOptions", "(", ")", ".", "GetPid", "(", ")", ",", "}", ",", "}", ",", "}", "\n\n", "sandboxID", ":=", "sb", ".", "ID", "(", ")", "\n", "resp", "=", "&", "pb", ".", "PodSandboxStatusResponse", "{", "Status", ":", "&", "pb", ".", "PodSandboxStatus", "{", "Id", ":", "sandboxID", ",", "CreatedAt", ":", "podInfraContainer", ".", "CreatedAt", "(", ")", ".", "UnixNano", "(", ")", ",", "Network", ":", "&", "pb", ".", "PodSandboxNetworkStatus", "{", "Ip", ":", "sb", ".", "IP", "(", ")", "}", ",", "State", ":", "rStatus", ",", "Labels", ":", "sb", ".", "Labels", "(", ")", ",", "Annotations", ":", "sb", ".", "Annotations", "(", ")", ",", "Metadata", ":", "sb", ".", "Metadata", "(", ")", ",", "Linux", ":", "linux", ",", "}", ",", "}", "\n\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "resp", ")", "\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "PodSandboxStatus", "returns", "the", "Status", "of", "the", "PodSandbox", "." ]

[ "func", "(", "s", "*", "Server", ")", "Status", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "StatusRequest", ")", "(", "resp", "*", "pb", ".", "StatusResponse", ",", "err", "error", ")", "{", "const", "operation", "=", "\"", "\"", "\n", "defer", "func", "(", ")", "{", "recordOperation", "(", "operation", ",", "time", ".", "Now", "(", ")", ")", "\n", "recordError", "(", "operation", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "runtimeCondition", ":=", "&", "pb", ".", "RuntimeCondition", "{", "Type", ":", "pb", ".", "RuntimeReady", ",", "Status", ":", "true", ",", "}", "\n", "networkCondition", ":=", "&", "pb", ".", "RuntimeCondition", "{", "Type", ":", "pb", ".", "NetworkReady", ",", "Status", ":", "true", ",", "}", "\n\n", "if", "err", ":=", "s", ".", "netPlugin", ".", "Status", "(", ")", ";", "err", "!=", "nil", "{", "networkCondition", ".", "Status", "=", "false", "\n", "networkCondition", ".", "Reason", "=", "networkNotReadyReason", "\n", "networkCondition", ".", "Message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "resp", "=", "&", "pb", ".", "StatusResponse", "{", "Status", ":", "&", "pb", ".", "RuntimeStatus", "{", "Conditions", ":", "[", "]", "*", "pb", ".", "RuntimeCondition", "{", "runtimeCondition", ",", "networkCondition", ",", "}", ",", "}", ",", "}", "\n\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "Status", "returns", "the", "status", "of", "the", "runtime" ]

[ "func", "Register", "(", ")", "{", "registerMetrics", ".", "Do", "(", "func", "(", ")", "{", "prometheus", ".", "MustRegister", "(", "CRIOOperations", ")", "\n", "prometheus", ".", "MustRegister", "(", "CRIOOperationsLatency", ")", "\n", "prometheus", ".", "MustRegister", "(", "CRIOOperationsErrors", ")", "\n", "}", ")", "\n", "}" ]

[ "Register", "all", "metrics" ]

[ "func", "(", "svc", "*", "imageService", ")", "prepareReference", "(", "imageName", "string", ",", "options", "*", "copy", ".", "Options", ")", "(", "types", ".", "ImageReference", ",", "error", ")", "{", "if", "imageName", "==", "\"", "\"", "{", "return", "nil", ",", "storage", ".", "ErrNotAnImage", "\n", "}", "\n\n", "srcRef", ",", "err", ":=", "alltransports", ".", "ParseImageName", "(", "imageName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "svc", ".", "defaultTransport", "==", "\"", "\"", "{", "return", "nil", ",", "err", "\n", "}", "\n", "srcRef2", ",", "err2", ":=", "alltransports", ".", "ParseImageName", "(", "svc", ".", "defaultTransport", "+", "imageName", ")", "\n", "if", "err2", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "srcRef", "=", "srcRef2", "\n", "}", "\n\n", "if", "options", ".", "SourceCtx", "==", "nil", "{", "options", ".", "SourceCtx", "=", "&", "types", ".", "SystemContext", "{", "}", "\n", "}", "\n\n", "if", "srcRef", ".", "DockerReference", "(", ")", "!=", "nil", "{", "hostname", ":=", "reference", ".", "Domain", "(", "srcRef", ".", "DockerReference", "(", ")", ")", "\n", "if", "secure", ":=", "svc", ".", "isSecureIndex", "(", "hostname", ")", ";", "!", "secure", "{", "options", ".", "SourceCtx", ".", "DockerInsecureSkipTLSVerify", "=", "types", ".", "NewOptionalBool", "(", "!", "secure", ")", "\n", "}", "\n", "}", "\n", "return", "srcRef", ",", "nil", "\n", "}" ]

[ "prepareReference", "creates", "an", "image", "reference", "from", "an", "image", "string", "and", "set", "options", "for", "the", "source", "context" ]

[ "func", "(", "s", "*", "Server", ")", "UpdateRuntimeConfig", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "UpdateRuntimeConfigRequest", ")", "(", "resp", "*", "pb", ".", "UpdateRuntimeConfigResponse", ",", "err", "error", ")", "{", "const", "operation", "=", "\"", "\"", "\n", "defer", "func", "(", ")", "{", "recordOperation", "(", "operation", ",", "time", ".", "Now", "(", ")", ")", "\n", "recordError", "(", "operation", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "return", "&", "pb", ".", "UpdateRuntimeConfigResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "UpdateRuntimeConfig", "updates", "the", "configuration", "of", "a", "running", "container", "." ]

[ "func", "(", "ss", "StreamService", ")", "Attach", "(", "containerID", "string", ",", "inputStream", "io", ".", "Reader", ",", "outputStream", ",", "errorStream", "io", ".", "WriteCloser", ",", "tty", "bool", ",", "resize", "<-", "chan", "remotecommand", ".", "TerminalSize", ")", "error", "{", "c", ",", "err", ":=", "ss", ".", "runtimeServer", ".", "GetContainerFromShortID", "(", "containerID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "containerID", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "ss", ".", "runtimeServer", ".", "Runtime", "(", ")", ".", "UpdateContainerStatus", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "cState", ":=", "c", ".", "State", "(", ")", "\n", "if", "!", "(", "cState", ".", "Status", "==", "oci", ".", "ContainerStateRunning", "||", "cState", ".", "Status", "==", "oci", ".", "ContainerStateCreated", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "ss", ".", "runtimeServer", ".", "Runtime", "(", ")", ".", "AttachContainer", "(", "c", ",", "inputStream", ",", "outputStream", ",", "errorStream", ",", "tty", ",", "resize", ")", "\n", "}" ]

[ "Attach", "endpoint", "for", "streaming", ".", "Runtime" ]

[ "func", "(", "s", "*", "Server", ")", "networkStart", "(", "sb", "*", "sandbox", ".", "Sandbox", ")", "(", "podIP", "string", ",", "result", "cnitypes", ".", "Result", ",", "err", "error", ")", "{", "if", "sb", ".", "HostNetwork", "(", ")", "{", "return", "s", ".", "hostIP", ",", "nil", ",", "nil", "\n", "}", "\n\n", "// Ensure network resources are cleaned up if the plugin succeeded", "// but an error happened between plugin success and the end of networkStart()", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "s", ".", "networkStop", "(", "sb", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "podNetwork", ":=", "newPodNetwork", "(", "sb", ")", "\n", "_", ",", "err", "=", "s", ".", "netPlugin", ".", "SetUpPod", "(", "podNetwork", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "tmp", ",", "err", ":=", "s", ".", "netPlugin", ".", "GetPodNetworkStatus", "(", "podNetwork", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// only one cnitypes.Result is returned since newPodNetwork sets Networks list empty", "result", "=", "tmp", "[", "0", "]", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "result", ")", "\n\n", "network", ",", "err", ":=", "cnicurrent", ".", "GetResult", "(", "result", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "podIP", "=", "strings", ".", "Split", "(", "network", ".", "IPs", "[", "0", "]", ".", "Address", ".", "String", "(", ")", ",", "\"", "\"", ")", "[", "0", "]", "\n\n", "if", "len", "(", "sb", ".", "PortMappings", "(", ")", ")", ">", "0", "{", "ip", ":=", "net", ".", "ParseIP", "(", "podIP", ")", "\n", "if", "ip", "==", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ")", "\n", "return", "\n", "}", "\n\n", "err", "=", "s", ".", "hostportManager", ".", "Add", "(", "sb", ".", "ID", "(", ")", ",", "&", "hostport", ".", "PodPortMapping", "{", "Name", ":", "sb", ".", "Name", "(", ")", ",", "PortMappings", ":", "sb", ".", "PortMappings", "(", ")", ",", "IP", ":", "ip", ",", "HostNetwork", ":", "false", ",", "}", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "}", "\n", "return", "\n", "}" ]

[ "networkStart", "sets", "up", "the", "sandbox", "s", "network", "and", "returns", "the", "pod", "IP", "on", "success", "or", "an", "error" ]

[ "func", "(", "s", "*", "Server", ")", "getSandboxIP", "(", "sb", "*", "sandbox", ".", "Sandbox", ")", "(", "string", ",", "error", ")", "{", "if", "sb", ".", "HostNetwork", "(", ")", "{", "return", "s", ".", "hostIP", ",", "nil", "\n", "}", "\n\n", "podNetwork", ":=", "newPodNetwork", "(", "sb", ")", "\n", "result", ",", "err", ":=", "s", ".", "netPlugin", ".", "GetPodNetworkStatus", "(", "podNetwork", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "res", ",", "err", ":=", "cnicurrent", ".", "GetResult", "(", "result", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "strings", ".", "Split", "(", "res", ".", "IPs", "[", "0", "]", ".", "Address", ".", "String", "(", ")", ",", "\"", "\"", ")", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "getSandboxIP", "retrieves", "the", "IP", "address", "for", "the", "sandbox" ]

[ "func", "(", "s", "*", "Server", ")", "networkStop", "(", "sb", "*", "sandbox", ".", "Sandbox", ")", "{", "if", "sb", ".", "HostNetwork", "(", ")", "{", "return", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "hostportManager", ".", "Remove", "(", "sb", ".", "ID", "(", ")", ",", "&", "hostport", ".", "PodPortMapping", "{", "Name", ":", "sb", ".", "Name", "(", ")", ",", "PortMappings", ":", "sb", ".", "PortMappings", "(", ")", ",", "HostNetwork", ":", "false", ",", "}", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "podNetwork", ":=", "newPodNetwork", "(", "sb", ")", "\n", "if", "err", ":=", "s", ".", "netPlugin", ".", "TearDownPod", "(", "podNetwork", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "sb", ".", "Name", "(", ")", ",", "sb", ".", "ID", "(", ")", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "networkStop", "cleans", "up", "and", "removes", "a", "pod", "s", "network", ".", "It", "is", "best", "-", "effort", "and", "must", "call", "the", "network", "plugin", "even", "if", "the", "network", "namespace", "is", "already", "gone" ]

[ "func", "getUserFromImage", "(", "user", "string", ")", "(", "*", "int64", ",", "string", ")", "{", "// return both empty if user is not specified in the image.", "if", "user", "==", "\"", "\"", "{", "return", "nil", ",", "\"", "\"", "\n", "}", "\n", "// split instances where the id may contain user:group", "user", "=", "strings", ".", "Split", "(", "user", ",", "\"", "\"", ")", "[", "0", "]", "\n", "// user could be either uid or user name. Try to interpret as numeric uid.", "uid", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "user", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "// If user is non numeric, assume it's user name.", "return", "nil", ",", "user", "\n", "}", "\n", "// If user is a numeric uid.", "return", "&", "uid", ",", "\"", "\"", "\n", "}" ]

[ "getUserFromImage", "gets", "uid", "or", "user", "name", "of", "the", "image", "user", ".", "If", "user", "is", "numeric", "it", "will", "be", "treated", "as", "uid", ";", "or", "else", "it", "is", "treated", "as", "user", "name", "." ]

[ "func", "(", "s", "*", "Server", ")", "ReopenContainerLog", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "ReopenContainerLogRequest", ")", "(", "resp", "*", "pb", ".", "ReopenContainerLogResponse", ",", "err", "error", ")", "{", "const", "operation", "=", "\"", "\"", "\n", "defer", "func", "(", ")", "{", "recordOperation", "(", "operation", ",", "time", ".", "Now", "(", ")", ")", "\n", "recordError", "(", "operation", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "req", ")", "\n", "containerID", ":=", "req", ".", "ContainerId", "\n", "c", ":=", "s", ".", "GetContainer", "(", "containerID", ")", "\n\n", "if", "c", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "containerID", ")", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "ContainerServer", ".", "Runtime", "(", ")", ".", "UpdateContainerStatus", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "cState", ":=", "c", ".", "State", "(", ")", "\n", "if", "!", "(", "cState", ".", "Status", "==", "oci", ".", "ContainerStateRunning", "||", "cState", ".", "Status", "==", "oci", ".", "ContainerStateCreated", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "ContainerServer", ".", "Runtime", "(", ")", ".", "ReopenContainerLog", "(", "c", ")", "\n", "if", "err", "==", "nil", "{", "resp", "=", "&", "pb", ".", "ReopenContainerLogResponse", "{", "}", "\n", "}", "\n\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "containerID", ",", "resp", ")", "\n", "return", "resp", ",", "err", "\n", "}" ]

[ "ReopenContainerLog", "reopens", "the", "containers", "log", "file" ]

[ "func", "filterSandbox", "(", "p", "*", "pb", ".", "PodSandbox", ",", "filter", "*", "pb", ".", "PodSandboxFilter", ")", "bool", "{", "if", "filter", "!=", "nil", "{", "if", "filter", ".", "State", "!=", "nil", "{", "if", "p", ".", "State", "!=", "filter", ".", "State", ".", "State", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "filter", ".", "LabelSelector", "!=", "nil", "{", "sel", ":=", "fields", ".", "SelectorFromSet", "(", "filter", ".", "LabelSelector", ")", "\n", "if", "!", "sel", ".", "Matches", "(", "fields", ".", "Set", "(", "p", ".", "Labels", ")", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "filterSandbox", "returns", "whether", "passed", "container", "matches", "filtering", "criteria" ]

[ "func", "(", "s", "*", "Server", ")", "ListPodSandbox", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "ListPodSandboxRequest", ")", "(", "resp", "*", "pb", ".", "ListPodSandboxResponse", ",", "err", "error", ")", "{", "const", "operation", "=", "\"", "\"", "\n", "defer", "func", "(", ")", "{", "recordOperation", "(", "operation", ",", "time", ".", "Now", "(", ")", ")", "\n", "recordError", "(", "operation", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "req", ")", "\n", "var", "pods", "[", "]", "*", "pb", ".", "PodSandbox", "\n", "var", "podList", "[", "]", "*", "sandbox", ".", "Sandbox", "\n", "podList", "=", "append", "(", "podList", ",", "s", ".", "ContainerServer", ".", "ListSandboxes", "(", ")", "...", ")", "\n\n", "filter", ":=", "req", ".", "Filter", "\n", "// Filter by pod id first.", "if", "filter", "!=", "nil", "{", "if", "filter", ".", "Id", "!=", "\"", "\"", "{", "id", ",", "err", ":=", "s", ".", "PodIDIndex", "(", ")", ".", "Get", "(", "filter", ".", "Id", ")", "\n", "if", "err", "!=", "nil", "{", "// Not finding an ID in a filtered list should not be considered", "// and error; it might have been deleted when stop was done.", "// Log and return an empty struct.", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "filter", ".", "Id", ")", "\n", "return", "&", "pb", ".", "ListPodSandboxResponse", "{", "}", ",", "nil", "\n", "}", "\n", "sb", ":=", "s", ".", "getSandbox", "(", "id", ")", "\n", "if", "sb", "==", "nil", "{", "podList", "=", "[", "]", "*", "sandbox", ".", "Sandbox", "{", "}", "\n", "}", "else", "{", "podList", "=", "[", "]", "*", "sandbox", ".", "Sandbox", "{", "sb", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "sb", ":=", "range", "podList", "{", "// Skip sandboxes that aren't created yet", "if", "!", "sb", ".", "Created", "(", ")", "{", "continue", "\n", "}", "\n", "podInfraContainer", ":=", "sb", ".", "InfraContainer", "(", ")", "\n", "if", "podInfraContainer", "==", "nil", "{", "// this can't really happen, but if it does because of a bug", "// it's better not to panic", "continue", "\n", "}", "\n", "cState", ":=", "podInfraContainer", ".", "StateNoLock", "(", ")", "\n", "rStatus", ":=", "pb", ".", "PodSandboxState_SANDBOX_NOTREADY", "\n", "if", "cState", ".", "Status", "==", "oci", ".", "ContainerStateRunning", "{", "rStatus", "=", "pb", ".", "PodSandboxState_SANDBOX_READY", "\n", "}", "\n\n", "pod", ":=", "&", "pb", ".", "PodSandbox", "{", "Id", ":", "sb", ".", "ID", "(", ")", ",", "CreatedAt", ":", "podInfraContainer", ".", "CreatedAt", "(", ")", ".", "UnixNano", "(", ")", ",", "State", ":", "rStatus", ",", "Labels", ":", "sb", ".", "Labels", "(", ")", ",", "Annotations", ":", "sb", ".", "Annotations", "(", ")", ",", "Metadata", ":", "sb", ".", "Metadata", "(", ")", ",", "}", "\n\n", "// Filter by other criteria such as state and labels.", "if", "filterSandbox", "(", "pod", ",", "req", ".", "Filter", ")", "{", "pods", "=", "append", "(", "pods", ",", "pod", ")", "\n", "}", "\n", "}", "\n\n", "resp", "=", "&", "pb", ".", "ListPodSandboxResponse", "{", "Items", ":", "pods", ",", "}", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "resp", ")", "\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "ListPodSandbox", "returns", "a", "list", "of", "SandBoxes", "." ]

[ "func", "(", "s", "*", "Server", ")", "RemoveContainer", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "RemoveContainerRequest", ")", "(", "resp", "*", "pb", ".", "RemoveContainerResponse", ",", "err", "error", ")", "{", "const", "operation", "=", "\"", "\"", "\n", "defer", "func", "(", ")", "{", "recordOperation", "(", "operation", ",", "time", ".", "Now", "(", ")", ")", "\n", "recordError", "(", "operation", ",", "err", ")", "\n", "}", "(", ")", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "req", ")", "\n\n", "// save container description to print", "c", ",", "err", ":=", "s", ".", "GetContainerFromShortID", "(", "req", ".", "ContainerId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "s", ".", "ContainerServer", ".", "Remove", "(", "ctx", ",", "req", ".", "ContainerId", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "c", ".", "Description", "(", ")", ")", "\n", "resp", "=", "&", "pb", ".", "RemoveContainerResponse", "{", "}", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "resp", ")", "\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "RemoveContainer", "removes", "the", "container", ".", "If", "the", "container", "is", "running", "the", "container", "should", "be", "force", "removed", "." ]

[ "func", "(", "w", "*", "wrapReadCloser", ")", "Close", "(", ")", "error", "{", "w", ".", "reader", ".", "Close", "(", ")", "\n", "w", ".", "writer", ".", "Close", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "read", "closer", "." ]

[ "func", "(", "c", "*", "Config", ")", "Validate", "(", "onExecution", "bool", ")", "error", "{", "switch", "c", ".", "ImageVolumes", "{", "case", "lib", ".", "ImageVolumesMkdir", ":", "case", "lib", ".", "ImageVolumesIgnore", ":", "case", "lib", ".", "ImageVolumesBind", ":", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "Config", ".", "Validate", "(", "onExecution", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "c", ".", "UIDMappings", "!=", "\"", "\"", "&&", "c", ".", "ManageNetworkNSLifecycle", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "GIDMappings", "!=", "\"", "\"", "&&", "c", ".", "ManageNetworkNSLifecycle", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "c", ".", "LogSizeMax", ">=", "0", "&&", "c", ".", "LogSizeMax", "<", "oci", ".", "BufSize", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "oci", ".", "BufSize", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "is", "the", "main", "entry", "point", "for", "configuration", "validation", "The", "parameter", "onExecution", "specifies", "if", "the", "validation", "should", "include", "execution", "checks", ".", "It", "returns", "an", "error", "on", "validation", "failure", "otherwise", "nil", "." ]

[ "func", "newRuntimeOCI", "(", "r", "*", "Runtime", ",", "handler", "*", "RuntimeHandler", ")", "RuntimeImpl", "{", "return", "&", "runtimeOCI", "{", "Runtime", ":", "r", ",", "path", ":", "handler", ".", "RuntimePath", ",", "root", ":", "handler", ".", "RuntimeRoot", ",", "}", "\n", "}" ]

[ "newRuntimeOCI", "creates", "a", "new", "runtimeOCI", "instance" ]

[ "func", "(", "history", "*", "History", ")", "Less", "(", "i", ",", "j", "int", ")", "bool", "{", "sandboxes", ":=", "*", "history", "\n", "// FIXME: state access should be serialized", "return", "sandboxes", "[", "j", "]", ".", "createdAt", ".", "Before", "(", "sandboxes", "[", "i", "]", ".", "createdAt", ")", "\n", "}" ]

[ "Less", "compares", "two", "sandboxes", "and", "returns", "true", "if", "the", "second", "one", "was", "created", "before", "the", "first", "one", "." ]

[ "func", "(", "history", "*", "History", ")", "Swap", "(", "i", ",", "j", "int", ")", "{", "sandboxes", ":=", "*", "history", "\n", "sandboxes", "[", "i", "]", ",", "sandboxes", "[", "j", "]", "=", "sandboxes", "[", "j", "]", ",", "sandboxes", "[", "i", "]", "\n", "}" ]

[ "Swap", "switches", "sandboxes", "i", "and", "j", "positions", "in", "the", "history", "." ]

[ "func", "NewExecIO", "(", "id", ",", "root", "string", ",", "tty", ",", "stdin", "bool", ")", "(", "*", "ExecIO", ",", "error", ")", "{", "fifos", ",", "err", ":=", "newFifos", "(", "root", ",", "id", ",", "tty", ",", "stdin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "stdio", ",", "closer", ",", "err", ":=", "newStdioPipes", "(", "fifos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "ExecIO", "{", "id", ":", "id", ",", "fifos", ":", "fifos", ",", "stdioPipes", ":", "stdio", ",", "closer", ":", "closer", ",", "}", ",", "nil", "\n", "}" ]

[ "NewExecIO", "creates", "exec", "io", "." ]

[ "func", "(", "e", "*", "ExecIO", ")", "Attach", "(", "opts", "AttachOptions", ")", "<-", "chan", "struct", "{", "}", "{", "var", "wg", "sync", ".", "WaitGroup", "\n", "var", "stdinStreamRC", "io", ".", "ReadCloser", "\n", "if", "e", ".", "stdin", "!=", "nil", "&&", "opts", ".", "Stdin", "!=", "nil", "{", "stdinStreamRC", "=", "cioutil", ".", "NewWrapReadCloser", "(", "opts", ".", "Stdin", ")", "\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "e", ".", "stdin", ",", "stdinStreamRC", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "id", ")", "\n", "}", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "e", ".", "id", ")", "\n", "if", "opts", ".", "StdinOnce", "&&", "!", "opts", ".", "Tty", "{", "e", ".", "stdin", ".", "Close", "(", ")", "\n", "if", "err", ":=", "opts", ".", "CloseStdin", "(", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "id", ")", "\n", "}", "\n", "}", "else", "{", "if", "e", ".", "stdout", "!=", "nil", "{", "e", ".", "stdout", ".", "Close", "(", ")", "\n", "}", "\n", "if", "e", ".", "stderr", "!=", "nil", "{", "e", ".", "stderr", ".", "Close", "(", ")", "\n", "}", "\n", "}", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n\n", "attachOutput", ":=", "func", "(", "t", "StreamType", ",", "stream", "io", ".", "WriteCloser", ",", "out", "io", ".", "ReadCloser", ")", "{", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "stream", ",", "out", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "\"", "\"", ",", "t", ",", "e", ".", "id", ")", "\n", "}", "\n", "out", ".", "Close", "(", ")", "\n", "stream", ".", "Close", "(", ")", "\n", "if", "stdinStreamRC", "!=", "nil", "{", "stdinStreamRC", ".", "Close", "(", ")", "\n", "}", "\n", "e", ".", "closer", ".", "wg", ".", "Done", "(", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "t", ",", "e", ".", "id", ")", "\n", "}", "\n\n", "if", "opts", ".", "Stdout", "!=", "nil", "{", "wg", ".", "Add", "(", "1", ")", "\n", "// Closer should wait for this routine to be over.", "e", ".", "closer", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "attachOutput", "(", "Stdout", ",", "opts", ".", "Stdout", ",", "e", ".", "stdout", ")", "\n", "}", "\n\n", "if", "!", "opts", ".", "Tty", "&&", "opts", ".", "Stderr", "!=", "nil", "{", "wg", ".", "Add", "(", "1", ")", "\n", "// Closer should wait for this routine to be over.", "e", ".", "closer", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "attachOutput", "(", "Stderr", ",", "opts", ".", "Stderr", ",", "e", ".", "stderr", ")", "\n", "}", "\n\n", "done", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "go", "func", "(", ")", "{", "wg", ".", "Wait", "(", ")", "\n", "close", "(", "done", ")", "\n", "}", "(", ")", "\n", "return", "done", "\n", "}" ]

[ "Attach", "attaches", "exec", "stdio", ".", "The", "logic", "is", "similar", "with", "container", "io", "attach", "." ]

[ "func", "getContainerNetIO", "(", "stats", "*", "libcontainer", ".", "Stats", ")", "(", "received", "uint64", ",", "transmitted", "uint64", ")", "{", "for", "_", ",", "iface", ":=", "range", "stats", ".", "Interfaces", "{", "received", "+=", "iface", ".", "RxBytes", "\n", "transmitted", "+=", "iface", ".", "TxBytes", "\n", "}", "\n", "return", "\n", "}" ]

[ "Returns", "the", "total", "number", "of", "bytes", "transmitted", "and", "received", "for", "the", "given", "container", "stats" ]

[ "func", "getMemLimit", "(", "cgroupLimit", "uint64", ")", "uint64", "{", "si", ":=", "&", "syscall", ".", "Sysinfo_t", "{", "}", "\n", "err", ":=", "syscall", ".", "Sysinfo", "(", "si", ")", "\n", "if", "err", "!=", "nil", "{", "return", "cgroupLimit", "\n", "}", "\n\n", "physicalLimit", ":=", "si", ".", "Totalram", "\n", "if", "cgroupLimit", ">", "physicalLimit", "{", "return", "physicalLimit", "\n", "}", "\n", "return", "cgroupLimit", "\n", "}" ]

[ "getMemory", "limit", "returns", "the", "memory", "limit", "for", "a", "given", "cgroup", "If", "the", "configured", "memory", "limit", "is", "larger", "than", "the", "total", "memory", "on", "the", "sys", "the", "physical", "system", "memory", "size", "is", "returned" ]

[ "func", "streamKey", "(", "id", ",", "name", "string", ",", "stream", "StreamType", ")", "string", "{", "return", "strings", ".", "Join", "(", "[", "]", "string", "{", "id", ",", "name", ",", "string", "(", "stream", ")", "}", ",", "\"", "\"", ")", "\n", "}" ]

[ "streamKey", "generates", "a", "key", "for", "the", "stream", "." ]

[ "func", "WithFIFOs", "(", "fifos", "*", "cio", ".", "FIFOSet", ")", "ContainerIOOpts", "{", "return", "func", "(", "c", "*", "ContainerIO", ")", "error", "{", "c", ".", "fifos", "=", "fifos", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithFIFOs", "specifies", "existing", "fifos", "for", "the", "container", "io", "." ]

[ "func", "WithNewFIFOs", "(", "root", "string", ",", "tty", ",", "stdin", "bool", ")", "ContainerIOOpts", "{", "return", "func", "(", "c", "*", "ContainerIO", ")", "error", "{", "fifos", ",", "err", ":=", "newFifos", "(", "root", ",", "c", ".", "id", ",", "tty", ",", "stdin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "WithFIFOs", "(", "fifos", ")", "(", "c", ")", "\n", "}", "\n", "}" ]

[ "WithNewFIFOs", "creates", "new", "fifos", "for", "the", "container", "io", "." ]

[ "func", "NewContainerIO", "(", "id", "string", ",", "opts", "...", "ContainerIOOpts", ")", "(", "_", "*", "ContainerIO", ",", "err", "error", ")", "{", "c", ":=", "&", "ContainerIO", "{", "id", ":", "id", ",", "stdoutGroup", ":", "cioutil", ".", "NewWriterGroup", "(", ")", ",", "stderrGroup", ":", "cioutil", ".", "NewWriterGroup", "(", ")", ",", "}", "\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "if", "err", ":=", "opt", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "c", ".", "fifos", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "// Create actual fifos.", "stdio", ",", "closer", ",", "err", ":=", "newStdioPipes", "(", "c", ".", "fifos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ".", "stdioPipes", "=", "stdio", "\n", "c", ".", "closer", "=", "closer", "\n", "return", "c", ",", "nil", "\n", "}" ]

[ "NewContainerIO", "creates", "container", "io", "." ]

[ "func", "(", "c", "*", "ContainerIO", ")", "Pipe", "(", ")", "{", "wg", ":=", "c", ".", "closer", ".", "wg", "\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "c", ".", "stdoutGroup", ",", "c", ".", "stdout", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "id", ")", "\n", "}", "\n", "c", ".", "stdout", ".", "Close", "(", ")", "\n", "c", ".", "stdoutGroup", ".", "Close", "(", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "c", ".", "id", ")", "\n", "}", "(", ")", "\n\n", "if", "!", "c", ".", "fifos", ".", "Terminal", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "c", ".", "stderrGroup", ",", "c", ".", "stderr", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "id", ")", "\n", "}", "\n", "c", ".", "stderr", ".", "Close", "(", ")", "\n", "c", ".", "stderrGroup", ".", "Close", "(", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "logrus", ".", "Infof", "(", "\"", "\"", ",", "c", ".", "id", ")", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "Pipe", "creates", "container", "fifos", "and", "pipe", "container", "output", "to", "output", "stream", "." ]

[ "func", "(", "c", "*", "ContainerIO", ")", "AddOutput", "(", "name", "string", ",", "stdout", ",", "stderr", "io", ".", "WriteCloser", ")", "(", "io", ".", "WriteCloser", ",", "io", ".", "WriteCloser", ")", "{", "var", "oldStdout", ",", "oldStderr", "io", ".", "WriteCloser", "\n", "if", "stdout", "!=", "nil", "{", "key", ":=", "streamKey", "(", "c", ".", "id", ",", "name", ",", "Stdout", ")", "\n", "oldStdout", "=", "c", ".", "stdoutGroup", ".", "Get", "(", "key", ")", "\n", "c", ".", "stdoutGroup", ".", "Add", "(", "key", ",", "stdout", ")", "\n", "}", "\n", "if", "stderr", "!=", "nil", "{", "key", ":=", "streamKey", "(", "c", ".", "id", ",", "name", ",", "Stderr", ")", "\n", "oldStderr", "=", "c", ".", "stderrGroup", ".", "Get", "(", "key", ")", "\n", "c", ".", "stderrGroup", ".", "Add", "(", "key", ",", "stderr", ")", "\n", "}", "\n", "return", "oldStdout", ",", "oldStderr", "\n", "}" ]

[ "AddOutput", "adds", "new", "write", "closers", "to", "the", "container", "stream", "and", "returns", "existing", "write", "closers", "if", "there", "are", "any", "." ]

[ "func", "(", "c", "*", "ContainerServer", ")", "GetLogs", "(", "container", "string", ",", "logChan", "chan", "string", ",", "opts", "LogOptions", ")", "error", "{", "defer", "close", "(", "logChan", ")", "\n", "// Get the full ID of the container", "ctr", ",", "err", ":=", "c", ".", "LookupContainer", "(", "container", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "containerID", ":=", "ctr", ".", "ID", "(", ")", "\n", "sandbox", ":=", "ctr", ".", "Sandbox", "(", ")", "\n", "if", "sandbox", "==", "\"", "\"", "{", "sandbox", "=", "containerID", "\n", "}", "\n", "// Read the log line by line and pass it into the pipe", "logsFile", ":=", "path", ".", "Join", "(", "c", ".", "config", ".", "LogDir", ",", "sandbox", ",", "containerID", "+", "\"", "\"", ")", "\n\n", "seekInfo", ":=", "&", "tail", ".", "SeekInfo", "{", "Offset", ":", "0", ",", "Whence", ":", "0", "}", "\n", "if", "opts", ".", "Tail", ">", "0", "{", "// seek to correct position in logs files", "seekInfo", ".", "Offset", "=", "int64", "(", "opts", ".", "Tail", ")", "\n", "seekInfo", ".", "Whence", "=", "2", "\n", "}", "\n\n", "t", ",", "err", ":=", "tail", ".", "TailFile", "(", "logsFile", ",", "tail", ".", "Config", "{", "Follow", ":", "false", ",", "ReOpen", ":", "false", ",", "Location", ":", "seekInfo", "}", ")", "\n", "for", "line", ":=", "range", "t", ".", "Lines", "{", "if", "since", ",", "err", ":=", "logSinceTime", "(", "opts", ".", "SinceTime", ",", "line", ".", "Text", ")", ";", "err", "!=", "nil", "||", "!", "since", "{", "continue", "\n", "}", "\n", "logMessage", ":=", "line", ".", "Text", "[", "secondSpaceIndex", "(", "line", ".", "Text", ")", ":", "]", "\n", "logChan", "<-", "logMessage", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "GetLogs", "gets", "each", "line", "of", "a", "log", "file", "and", "if", "it", "matches", "the", "criteria", "in", "logOptions", "sends", "it", "down", "logChan" ]

[ "func", "NewContainer", "(", "id", "string", ",", "name", "string", ",", "bundlePath", "string", ",", "logPath", "string", ",", "netns", "string", ",", "labels", "map", "[", "string", "]", "string", ",", "crioAnnotations", "map", "[", "string", "]", "string", ",", "annotations", "map", "[", "string", "]", "string", ",", "image", "string", ",", "imageName", "string", ",", "imageRef", "string", ",", "metadata", "*", "pb", ".", "ContainerMetadata", ",", "sandbox", "string", ",", "terminal", "bool", ",", "stdin", "bool", ",", "stdinOnce", "bool", ",", "privileged", "bool", ",", "runtimeHandler", "string", ",", "dir", "string", ",", "created", "time", ".", "Time", ",", "stopSignal", "string", ")", "(", "*", "Container", ",", "error", ")", "{", "state", ":=", "&", "ContainerState", "{", "}", "\n", "state", ".", "Created", "=", "created", "\n", "c", ":=", "&", "Container", "{", "id", ":", "id", ",", "name", ":", "name", ",", "bundlePath", ":", "bundlePath", ",", "logPath", ":", "logPath", ",", "labels", ":", "labels", ",", "sandbox", ":", "sandbox", ",", "netns", ":", "netns", ",", "terminal", ":", "terminal", ",", "stdin", ":", "stdin", ",", "stdinOnce", ":", "stdinOnce", ",", "privileged", ":", "privileged", ",", "runtimeHandler", ":", "runtimeHandler", ",", "metadata", ":", "metadata", ",", "annotations", ":", "annotations", ",", "crioAnnotations", ":", "crioAnnotations", ",", "image", ":", "image", ",", "imageName", ":", "imageName", ",", "imageRef", ":", "imageRef", ",", "dir", ":", "dir", ",", "state", ":", "state", ",", "stopSignal", ":", "stopSignal", ",", "}", "\n", "return", "c", ",", "nil", "\n", "}" ]

[ "NewContainer", "creates", "a", "container", "object", "." ]

[ "func", "(", "c", "*", "Container", ")", "GetStopSignal", "(", ")", "string", "{", "if", "c", ".", "stopSignal", "==", "\"", "\"", "{", "return", "defaultStopSignal", "\n", "}", "\n", "cleanSignal", ":=", "strings", ".", "TrimPrefix", "(", "strings", ".", "ToUpper", "(", "c", ".", "stopSignal", ")", ",", "\"", "\"", ")", "\n", "_", ",", "ok", ":=", "signal", ".", "SignalMap", "[", "cleanSignal", "]", "\n", "if", "!", "ok", "{", "return", "defaultStopSignal", "\n", "}", "\n", "return", "cleanSignal", "\n", "}" ]

[ "GetStopSignal", "returns", "the", "container", "s", "own", "stop", "signal", "configured", "from", "the", "image", "configuration", "or", "the", "default", "one", "." ]

[ "func", "(", "c", "*", "Container", ")", "StopSignal", "(", ")", "syscall", ".", "Signal", "{", "if", "c", ".", "stopSignal", "==", "\"", "\"", "{", "return", "defaultStopSignalInt", "\n", "}", "\n", "cleanSignal", ":=", "strings", ".", "TrimPrefix", "(", "strings", ".", "ToUpper", "(", "c", ".", "stopSignal", ")", ",", "\"", "\"", ")", "\n", "sig", ",", "ok", ":=", "signal", ".", "SignalMap", "[", "cleanSignal", "]", "\n", "if", "!", "ok", "{", "return", "defaultStopSignalInt", "\n", "}", "\n", "return", "sig", "\n", "}" ]

[ "StopSignal", "returns", "the", "container", "s", "own", "stop", "signal", "configured", "from", "the", "image", "configuration", "or", "the", "default", "one", "." ]

[ "func", "(", "c", "*", "Container", ")", "FromDisk", "(", ")", "error", "{", "jsonSource", ",", "err", ":=", "os", ".", "Open", "(", "c", ".", "StatePath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "jsonSource", ".", "Close", "(", ")", "\n\n", "dec", ":=", "json", ".", "NewDecoder", "(", "jsonSource", ")", "\n", "return", "dec", ".", "Decode", "(", "c", ".", "state", ")", "\n", "}" ]

[ "FromDisk", "restores", "container", "s", "state", "from", "disk" ]

[ "func", "(", "c", "*", "Container", ")", "NetNsPath", "(", ")", "(", "string", ",", "error", ")", "{", "if", "c", ".", "state", "==", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "c", ".", "netns", "==", "\"", "\"", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "state", ".", "Pid", ")", ",", "nil", "\n", "}", "\n\n", "return", "c", ".", "netns", ",", "nil", "\n", "}" ]

[ "NetNsPath", "returns", "the", "path", "to", "the", "network", "namespace", "of", "the", "container", "." ]

[ "func", "(", "c", "*", "Container", ")", "State", "(", ")", "*", "ContainerState", "{", "c", ".", "opLock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "opLock", ".", "RUnlock", "(", ")", "\n", "return", "c", ".", "state", "\n", "}" ]

[ "State", "returns", "the", "state", "of", "the", "running", "container" ]

[ "func", "(", "c", "*", "Container", ")", "AddVolume", "(", "v", "ContainerVolume", ")", "{", "c", ".", "volumes", "=", "append", "(", "c", ".", "volumes", ",", "v", ")", "\n", "}" ]

[ "AddVolume", "adds", "a", "volume", "to", "list", "of", "container", "volumes", "." ]

[ "func", "(", "c", "*", "Container", ")", "SetStartFailed", "(", "err", "error", ")", "{", "c", ".", "opLock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "opLock", ".", "Unlock", "(", ")", "\n", "// adjust finished and started times", "c", ".", "state", ".", "Finished", ",", "c", ".", "state", ".", "Started", "=", "c", ".", "state", ".", "Created", ",", "c", ".", "state", ".", "Created", "\n", "if", "err", "!=", "nil", "{", "c", ".", "state", ".", "Error", "=", "err", ".", "Error", "(", ")", "\n", "}", "\n", "}" ]

[ "SetStartFailed", "sets", "the", "container", "state", "appropriately", "after", "a", "start", "failure" ]

[ "func", "(", "c", "*", "Container", ")", "Description", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Labels", "(", ")", "[", "types", ".", "KubernetesPodNamespaceLabel", "]", ",", "c", ".", "Labels", "(", ")", "[", "types", ".", "KubernetesPodNameLabel", "]", ",", "c", ".", "Labels", "(", ")", "[", "types", ".", "KubernetesContainerNameLabel", "]", ")", "\n", "}" ]

[ "Description", "returns", "a", "description", "for", "the", "container" ]

[ "func", "NewWriteCloseInformer", "(", "wc", "io", ".", "WriteCloser", ")", "(", "io", ".", "WriteCloser", ",", "<-", "chan", "struct", "{", "}", ")", "{", "close", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "return", "&", "writeCloseInformer", "{", "close", ":", "close", ",", "wc", ":", "wc", ",", "}", ",", "close", "\n", "}" ]

[ "NewWriteCloseInformer", "creates", "the", "writeCloseInformer", "from", "a", "write", "closer", "." ]

[ "func", "(", "w", "*", "writeCloseInformer", ")", "Write", "(", "p", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "return", "w", ".", "wc", ".", "Write", "(", "p", ")", "\n", "}" ]

[ "Write", "passes", "through", "the", "data", "into", "the", "internal", "write", "closer", "." ]

[ "func", "(", "w", "*", "writeCloseInformer", ")", "Close", "(", ")", "error", "{", "err", ":=", "w", ".", "wc", ".", "Close", "(", ")", "\n", "close", "(", "w", ".", "close", ")", "\n", "return", "err", "\n", "}" ]

[ "Close", "closes", "the", "internal", "write", "closer", "and", "inform", "the", "close", "channel", "." ]

[ "func", "(", "n", "*", "nopWriteCloser", ")", "Write", "(", "p", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "return", "n", ".", "w", ".", "Write", "(", "p", ")", "\n", "}" ]

[ "Write", "passes", "through", "the", "data", "into", "the", "internal", "writer", "." ]

[ "func", "(", "s", "*", "serialWriteCloser", ")", "Write", "(", "data", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "s", ".", "wc", ".", "Write", "(", "data", ")", "\n", "}" ]

[ "Write", "writes", "a", "group", "of", "byte", "arrays", "in", "order", "atomically", "." ]

[ "func", "(", "s", "*", "serialWriteCloser", ")", "Close", "(", ")", "error", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "s", ".", "wc", ".", "Close", "(", ")", "\n", "}" ]

[ "Close", "closes", "the", "write", "closer", "." ]

[ "func", "IsEnabled", "(", ")", "bool", "{", "enabled", ":=", "false", "\n", "// Check if Seccomp is supported, via CONFIG_SECCOMP.", "if", "err", ":=", "unix", ".", "Prctl", "(", "unix", ".", "PR_GET_SECCOMP", ",", "0", ",", "0", ",", "0", ",", "0", ")", ";", "err", "!=", "unix", ".", "EINVAL", "{", "// Make sure the kernel has CONFIG_SECCOMP_FILTER.", "if", "err", ":=", "unix", ".", "Prctl", "(", "unix", ".", "PR_SET_SECCOMP", ",", "unix", ".", "SECCOMP_MODE_FILTER", ",", "0", ",", "0", ",", "0", ")", ";", "err", "!=", "unix", ".", "EINVAL", "{", "enabled", "=", "true", "\n", "}", "\n", "}", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "enabled", ")", "\n", "return", "enabled", "\n", "}" ]

[ "IsEnabled", "returns", "true", "if", "seccomp", "is", "enabled", "for", "the", "host", "." ]

[ "func", "LoadProfileFromStruct", "(", "config", "*", "Seccomp", ",", "specgen", "*", "generate", ".", "Generator", ")", "error", "{", "return", "setupSeccomp", "(", "config", ",", "specgen", ")", "\n", "}" ]

[ "LoadProfileFromStruct", "takes", "a", "Seccomp", "struct", "and", "setup", "seccomp", "in", "the", "spec", "." ]

[ "func", "LoadProfileFromBytes", "(", "body", "[", "]", "byte", ",", "specgen", "*", "generate", ".", "Generator", ")", "error", "{", "config", ":=", "&", "Seccomp", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "body", ",", "config", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "setupSeccomp", "(", "config", ",", "specgen", ")", "\n", "}" ]

[ "LoadProfileFromBytes", "takes", "a", "byte", "slice", "and", "decodes", "the", "seccomp", "profile", "." ]