Datasets:

google

/

code_x_glue_cc_cloze_testing_all

like 5

Follow

Google 4,233

[ "SetIconTooltipText", "()", "is", "a", "wrapper", "around", "gtk_entry_set_icon_tooltip_text", "()", "." ]

[ "func", "(", "v", "*", "<mask>", ")", "SetIconTooltipText", "(", "iconPos", "EntryIconPosition", ",", "tooltip", "string", ")", "{", "cstr", ":=", "C", ".", "CString", "(", "tooltip", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cstr", ")", ")", "\n", "C", ".", "gtk_entry_set_icon_tooltip_text", "(", "v", ".", "native", "(", ")", ",", "C", ".", "GtkEntryIconPosition", "(", "iconPos", ")", ",", "(", "*", "C", ".", "gchar", ")", "(", "cstr", ")", ")", "\n", "}" ]

[ "SetKnownStatus", "safely", "sets", "the", "currently", "known", "status", "of", "the", "resource" ]

[ "func", "(", "auth", "*", "ASMAuthResource", ")", "SetKnownStatus", "(", "status", "resourcestatus", ".", "ResourceStatus", ")", "{", "auth", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "auth", ".", "<mask>", ".", "Unlock", "(", ")", "\n\n", "auth", ".", "knownStatusUnsafe", "=", "status", "\n", "auth", ".", "updateAppliedStatusUnsafe", "(", "status", ")", "\n", "}" ]

[ "newConn", "constructs", "a", "new", "connection" ]

[ "func", "newSecureConn", "(", "ctx", "context", ".", "<mask>", ",", "sk", "ic", ".", "PrivKey", ",", "insecure", "iconn", ".", "Conn", ")", "(", "iconn", ".", "Conn", ",", "error", ")", "{", "if", "insecure", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "insecure", ".", "LocalPeer", "(", ")", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "sk", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// NewSession performs the secure handshake, which takes multiple RTT", "sessgen", ":=", "secio", ".", "SessionGenerator", "{", "LocalID", ":", "insecure", ".", "LocalPeer", "(", ")", ",", "PrivateKey", ":", "sk", "}", "\n", "secure", ",", "err", ":=", "sessgen", ".", "NewSession", "(", "ctx", ",", "insecure", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "conn", ":=", "&", "secureConn", "{", "insecure", ":", "insecure", ",", "secure", ":", "secure", ",", "}", "\n", "return", "conn", ",", "nil", "\n", "}" ]

[ "getConfig", "parses", "and", "returns", "the", "configuration", "data", "from", "the", "storage", "backend", "." ]

[ "func", "getConfig", "(", "ctx", "context", ".", "Context", ",", "s", "logical", ".", "Storage", ")", "(", "*", "config", ",", "error", ")", "{", "entry", ",", "err", ":=", "s", ".", "Get", "(", "ctx", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "entry", "==", "nil", "||", "len", "(", "entry", ".", "Value", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "result", "config", "\n", "if", "err", ":=", "<mask>", ".", "DecodeJSON", "(", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "&", "result", ",", "nil", "\n", "}" ]

[ "pushError", "reports", "err", "(", "can", "be", "nil", ")", "to", "the", "waiter", ".", "It", "does", "not", "block", "and", "must", "only", "be", "executed", "once", "." ]

[ "func", "(", "p", "*", "batchPoint", ")", "pushError", "(", "err", "error", ")", "{", "p", ".", "errch", "<-", "err", "\n", "<mask>", "(", "p", ".", "errch", ")", "\n", "}" ]

[ "AppendSubmenu", "is", "a", "wrapper", "around", "g_menu_append_submenu", "()", "." ]

[ "func", "(", "v", "*", "Menu", ")", "AppendSubmenu", "(", "<mask>", "string", ",", "submenu", "*", "MenuModel", ")", "{", "cstr1", ":=", "(", "*", "C", ".", "gchar", ")", "(", "C", ".", "CString", "(", "label", ")", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cstr1", ")", ")", "\n\n", "C", ".", "g_menu_append_submenu", "(", "v", ".", "native", "(", ")", ",", "cstr1", ",", "submenu", ".", "native", "(", ")", ")", "\n", "}" ]

[ "skipStatement", "scans", "until", "the", "EOF", "or", "end", "of", "statement", "is", "encountered", "." ]

[ "func", "(", "tkn", "*", "Tokenizer", ")", "skipStatement", "(", ")", "{", "ch", ":=", "tkn", ".", "lastChar", "\n", "for", "ch", "!=", "';'", "&&", "ch", "!=", "eofChar", "{", "tkn", ".", "<mask>", "(", ")", "\n", "ch", "=", "tkn", ".", "lastChar", "\n", "}", "\n", "}" ]

[ "chainHandlers", "takes", "a", "set", "of", "middleware", "and", "joins", "them", "together", "into", "a", "single", "Middleware", "making", "it", "much", "simpler", "to", "compose", "middleware", "together" ]

[ "func", "chainHandlers", "(", "mw", "...", "Middleware", ")", "Middleware", "{", "return", "func", "(", "<mask>", "http", ".", "Handler", ")", "http", ".", "Handler", "{", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "last", ":=", "final", "\n", "for", "i", ":=", "len", "(", "mw", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "last", "=", "mw", "[", "i", "]", "(", "last", ")", "\n", "}", "\n", "last", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "GetAggregation", "returns", "the", "Aggregation", "field", "if", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "e", "*", "<mask>", ")", "GetAggregation", "(", ")", "string", "{", "if", "e", "==", "nil", "||", "e", ".", "Aggregation", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "e", ".", "Aggregation", "\n", "}" ]

[ "Do", "executes", "Emulation", ".", "setTouchEmulationEnabled", "against", "the", "provided", "context", "." ]

[ "func", "(", "p", "*", "SetTouchEmulationEnabledParams", ")", "Do", "(", "ctx", "<mask>", ".", "Context", ")", "(", "err", "error", ")", "{", "return", "cdp", ".", "Execute", "(", "ctx", ",", "CommandSetTouchEmulationEnabled", ",", "p", ",", "nil", ")", "\n", "}" ]

[ "===", "ceil", "(", "Vector", "ValueTypeVector", ")", "Vector", "===" ]

[ "func", "funcCeil", "(", "vals", "[", "]", "Value", ",", "args", "Expressions", ",", "enh", "*", "EvalNodeHelper", ")", "<mask>", "{", "return", "simpleFunc", "(", "vals", ",", "enh", ",", "math", ".", "Ceil", ")", "\n", "}" ]

[ "ReadUint32", "returns", "a", "uint32", "read", "from", "address", "a", "of", "the", "inferior", "." ]

[ "func", "(", "p", "*", "Process", ")", "ReadUint32", "(", "a", "Address", ")", "uint32", "{", "m", ":=", "p", ".", "findMapping", "(", "a", ")", "\n", "if", "m", "==", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "a", ")", ")", "\n", "}", "\n", "b", ":=", "m", ".", "contents", "[", "a", ".", "Sub", "(", "m", ".", "min", ")", ":", "]", "\n", "if", "len", "(", "b", ")", "<", "4", "{", "var", "buf", "[", "4", "]", "<mask>", "\n", "b", "=", "buf", "[", ":", "]", "\n", "p", ".", "ReadAt", "(", "b", ",", "a", ")", "\n", "}", "\n", "if", "p", ".", "littleEndian", "{", "return", "binary", ".", "LittleEndian", ".", "Uint32", "(", "b", ")", "\n", "}", "\n", "return", "binary", ".", "BigEndian", ".", "Uint32", "(", "b", ")", "\n", "}" ]

[ "Next", "returns", "the", "next", "page", "of", "resources", ".", "If", "there", "are", "no", "more", "resources", "NoMoreResults", "is", "returned", "." ]

[ "func", "(", "c", "*", "QueuePageIterator", ")", "Next", "(", "ctx", "<mask>", ".", "Context", ")", "(", "*", "QueuePage", ",", "error", ")", "{", "qp", ":=", "new", "(", "QueuePage", ")", "\n", "err", ":=", "c", ".", "p", ".", "Next", "(", "ctx", ",", "qp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ".", "p", ".", "SetNextPageURI", "(", "qp", ".", "NextPageURI", ")", "\n", "return", "qp", ",", "nil", "\n", "}" ]

[ "copy", "pixels", "into", "a", "1D", "texture", "image" ]

[ "func", "CopyTexImage1D", "(", "target", "uint32", ",", "level", "int32", ",", "internalformat", "uint32", ",", "x", "int32", ",", "y", "int32", ",", "width", "int32", ",", "border", "int32", ")", "{", "syscall", ".", "Syscall9", "(", "gpCopyTexImage1D", ",", "7", ",", "uintptr", "(", "target", ")", ",", "uintptr", "(", "<mask>", ")", ",", "uintptr", "(", "internalformat", ")", ",", "uintptr", "(", "x", ")", ",", "uintptr", "(", "y", ")", ",", "uintptr", "(", "width", ")", ",", "uintptr", "(", "border", ")", ",", "0", ",", "0", ")", "\n", "}" ]

[ "MarshalEasyJSON", "satisfies", "easyjson", ".", "Marshaler", "." ]

[ "func", "(", "t", "ValueType", ")", "MarshalEasyJSON", "(", "out", "*", "jwriter", ".", "Writer", ")", "{", "out", ".", "<mask>", "(", "string", "(", "t", ")", ")", "\n", "}" ]

[ "Run", "processes", "billing", "for", "active", "client", "channels", ".", "This", "function", "does", "not", "return", "until", "an", "error", "occurs", "or", "Close", "()", "is", "called", "." ]

[ "func", "(", "m", "*", "Monitor", ")", "Run", "(", ")", "error", "{", "m", ".", "mtx", ".", "Lock", "(", ")", "\n", "if", "m", ".", "exit", "!=", "nil", "{", "m", ".", "mtx", ".", "Unlock", "(", ")", "\n", "return", "ErrAlreadyRunning", "\n", "}", "\n", "m", ".", "exit", "=", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", "\n", "m", ".", "exited", "=", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", "\n", "m", ".", "mtx", ".", "Unlock", "(", ")", "\n\n", "period", ":=", "time", ".", "Duration", "(", "m", ".", "conf", ".", "CollectPeriod", ")", "*", "time", ".", "Millisecond", "\n", "L", ":", "for", "{", "select", "{", "case", "<-", "m", ".", "exit", ":", "break", "L", "\n", "default", ":", "}", "\n\n", "started", ":=", "time", ".", "Now", "(", ")", "\n\n", "chans", ",", "err", ":=", "m", ".", "db", ".", "SelectAllFrom", "(", "data", ".", "ChannelTable", ",", "`\n\t\t\t JOIN accounts ON eth_addr = client\n\t\t\tWHERE service_status IN ('active', 'suspended')\n\t\t\t AND channel_status = 'active' AND in_use`", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "logger", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "break", "L", "\n", "}", "\n\n", "for", "_", ",", "v", ":=", "range", "chans", "{", "err", ":=", "m", ".", "processChannel", "(", "v", ".", "(", "*", "data", ".", "Channel", ")", ")", "\n\n", "select", "{", "case", "m", ".", "processErrors", "<-", "err", ":", "default", ":", "}", "\n\n", "if", "err", "!=", "nil", "{", "break", "L", "\n", "}", "\n", "}", "\n\n", "time", ".", "Sleep", "(", "period", "-", "time", ".", "Now", "(", ")", ".", "Sub", "(", "started", ")", ")", "\n", "}", "\n\n", "m", ".", "exited", "<-", "struct", "{", "}", "{", "}", "\n\n", "m", ".", "mtx", ".", "Lock", "(", ")", "\n", "m", ".", "exit", "=", "nil", "\n", "m", ".", "mtx", ".", "Unlock", "(", ")", "\n\n", "m", ".", "logger", ".", "Info", "(", "ErrMonitorClosed", ".", "<mask>", "(", ")", ")", "\n", "return", "ErrMonitorClosed", "\n", "}" ]

[ "simultaneously", "specify", "storage", "for", "all", "levels", "of", "a", "one", "-", "dimensional", "texture" ]

[ "func", "TexStorage1D", "(", "target", "uint32", ",", "levels", "int32", ",", "internalformat", "uint32", ",", "width", "int32", ")", "{", "syscall", ".", "Syscall6", "(", "gpTexStorage1D", ",", "4", ",", "uintptr", "(", "<mask>", ")", ",", "uintptr", "(", "levels", ")", ",", "uintptr", "(", "internalformat", ")", ",", "uintptr", "(", "width", ")", ",", "0", ",", "0", ")", "\n", "}" ]

[ "bind", "a", "transform", "feedback", "object" ]

[ "func", "BindTransformFeedback", "(", "<mask>", "uint32", ",", "id", "uint32", ")", "{", "C", ".", "glowBindTransformFeedback", "(", "gpBindTransformFeedback", ",", "(", "C", ".", "GLenum", ")", "(", "target", ")", ",", "(", "C", ".", "GLuint", ")", "(", "id", ")", ")", "\n", "}" ]

[ "Marshal", "writes", "an", "xdr", "element", "v", "into", "w", "." ]

[ "func", "Marshal", "(", "w", "io", ".", "<mask>", ",", "v", "interface", "{", "}", ")", "(", "int", ",", "error", ")", "{", "// delegate to xdr package's Marshal", "return", "xdr", ".", "Marshal", "(", "w", ",", "v", ")", "\n", "}" ]

[ "Given", "a", "tag", "string", "with", "the", "format", "specified", "in", "the", "package", "comment", "parseFieldParameters", "will", "parse", "it", "into", "a", "fieldParameters", "structure", "ignoring", "unknown", "parts", "of", "the", "string", "." ]

[ "func", "parseFieldParameters", "(", "str", "string", ")", "(", "ret", "fieldParameters", ")", "{", "for", "_", ",", "part", ":=", "range", "strings", ".", "Split", "(", "str", ",", "\"", "\"", ")", "{", "switch", "{", "case", "part", "==", "\"", "\"", ":", "ret", ".", "optional", "=", "true", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "explicit", "=", "true", "\n", "if", "ret", ".", "tag", "==", "nil", "{", "ret", ".", "tag", "=", "new", "(", "int", ")", "\n", "}", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "timeType", "=", "tagGeneralizedTime", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "timeType", "=", "tagUTCTime", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "stringType", "=", "tagIA5String", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "stringType", "=", "tagPrintableString", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "stringType", "=", "tagUTF8String", "\n", "case", "strings", ".", "HasPrefix", "(", "part", ",", "\"", "\"", ")", ":", "i", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "part", "[", "8", ":", "]", ",", "10", ",", "64", ")", "\n", "if", "err", "==", "nil", "{", "ret", ".", "defaultValue", "=", "new", "(", "int64", ")", "\n", "*", "ret", ".", "defaultValue", "=", "i", "\n", "}", "\n", "case", "strings", ".", "HasPrefix", "(", "part", ",", "\"", "\"", ")", ":", "i", ",", "err", ":=", "strconv", ".", "Atoi", "(", "<mask>", "[", "4", ":", "]", ")", "\n", "if", "err", "==", "nil", "{", "ret", ".", "tag", "=", "new", "(", "int", ")", "\n", "*", "ret", ".", "tag", "=", "i", "\n", "}", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "set", "=", "true", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "application", "=", "true", "\n", "if", "ret", ".", "tag", "==", "nil", "{", "ret", ".", "tag", "=", "new", "(", "int", ")", "\n", "}", "\n", "case", "part", "==", "\"", "\"", ":", "ret", ".", "omitEmpty", "=", "true", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "prop", "value", "enum" ]

[ "func", "(", "m", "*", "TaskAllOf1", ")", "validateReasonEnum", "(", "path", ",", "location", "string", ",", "value", "string", ")", "error", "{", "if", "err", ":=", "validate", ".", "Enum", "(", "<mask>", ",", "location", ",", "value", ",", "taskAllOf1TypeReasonPropEnum", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "NewLedgerHeaderExt", "creates", "a", "new", "LedgerHeaderExt", "." ]

[ "func", "NewLedgerHeaderExt", "(", "v", "int32", ",", "value", "<mask>", "{", "}", ")", "(", "result", "LedgerHeaderExt", ",", "err", "error", ")", "{", "result", ".", "V", "=", "v", "\n", "switch", "int32", "(", "v", ")", "{", "case", "0", ":", "// void", "}", "\n", "return", "\n", "}" ]

[ "KeyPressDuration", "returns", "how", "long", "the", "key", "is", "pressed", "in", "frames", ".", "KeyPressDuration", "is", "concurrent", "safe", "." ]

[ "func", "KeyPressDuration", "(", "key", "ebiten", ".", "Key", ")", "int", "{", "theInputState", ".", "m", ".", "RLock", "(", ")", "\n", "s", ":=", "theInputState", ".", "keyDurations", "[", "<mask>", "]", "\n", "theInputState", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "s", "\n", "}" ]

[ "Parse", "parse", "string", "to", "time" ]

[ "func", "Parse", "(", "strs", "...", "string", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "return", "New", "(", "<mask>", ".", "Now", "(", ")", ")", ".", "Parse", "(", "strs", "...", ")", "\n", "}" ]

[ "computeDiffID", "reads", "all", "input", "from", "layerStream", "uncompresses", "it", "using", "decompressor", "if", "necessary", "and", "returns", "its", "digest", "." ]

[ "func", "computeDiffID", "(", "stream", "io", ".", "Reader", ",", "decompressor", "compression", ".", "DecompressorFunc", ")", "(", "digest", ".", "Digest", ",", "error", ")", "{", "if", "decompressor", "!=", "nil", "{", "s", ",", "err", ":=", "decompressor", "(", "<mask>", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "s", ".", "Close", "(", ")", "\n", "stream", "=", "s", "\n", "}", "\n\n", "return", "digest", ".", "Canonical", ".", "FromReader", "(", "stream", ")", "\n", "}" ]

[ "GetUsername", "finds", "the", "login", "for", "each", "token" ]

[ "func", "GetUsername", "(", "<mask>", "*", "github", ".", "Client", ")", "(", "string", ",", "error", ")", "{", "user", ",", "_", ",", "err", ":=", "client", ".", "Users", ".", "Get", "(", "context", ".", "Background", "(", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "user", ".", "Login", "==", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\\\"", "\\\"", "\"", ")", "\n", "}", "\n\n", "return", "*", "user", ".", "Login", ",", "nil", "\n", "}" ]

[ "NewMockWebsocketConn", "creates", "a", "new", "mock", "instance" ]

[ "func", "NewMockWebsocketConn", "(", "ctrl", "*", "gomock", ".", "<mask>", ")", "*", "MockWebsocketConn", "{", "mock", ":=", "&", "MockWebsocketConn", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockWebsocketConnMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "Browser", "returns", "the", "HostDatastoreBrowser", "for", "a", "certain", "datastore", ".", "This", "is", "a", "convenience", "method", "that", "exists", "to", "abstract", "the", "context", "." ]

[ "func", "Browser", "(", "ds", "*", "object", ".", "Datastore", ")", "(", "*", "object", ".", "HostDatastoreBrowser", ",", "error", ")", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "<mask>", ".", "Background", "(", ")", ",", "provider", ".", "DefaultAPITimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "return", "ds", ".", "Browser", "(", "ctx", ")", "\n", "}" ]

[ "Where", "adds", "WHERE", "clause", "to", "the", "Condition", "and", "returns", "it", "for", "method", "chain", "." ]

[ "func", "(", "c", "*", "Condition", ")", "Where", "(", "cond", "<mask>", "{", "}", ",", "args", "...", "interface", "{", "}", ")", "*", "Condition", "{", "return", "c", ".", "appendQueryByCondOrExpr", "(", "\"", "\"", ",", "0", ",", "Where", ",", "cond", ",", "args", "...", ")", "\n", "}" ]

[ "GetNPagesToPrint", "()", "is", "a", "wrapper", "around", "gtk_print_operation_get_n_pages_to_print", "()", "." ]

[ "func", "(", "po", "*", "PrintOperation", ")", "GetNPagesToPrint", "(", ")", "int", "{", "c", ":=", "C", ".", "gtk_print_operation_get_n_pages_to_print", "(", "<mask>", ".", "native", "(", ")", ")", "\n", "return", "int", "(", "c", ")", "\n", "}" ]

[ "MarshalJSON", "implements", "of", "json", ".", "Marshaler", "interface", ".", "It", "marshals", "string", "representations", "of", "time", ".", "Duration", "." ]

[ "func", "(", "o", "Options", ")", "MarshalJSON", "(", ")", "(", "[", "]", "<mask>", ",", "error", ")", "{", "return", "json", ".", "Marshal", "(", "optionsJSON", "{", "Timeout", ":", "marshal", ".", "Duration", "(", "o", ".", "Timeout", ")", ",", "KeepAlive", ":", "marshal", ".", "Duration", "(", "o", ".", "KeepAlive", ")", ",", "TLSHandshakeTimeout", ":", "marshal", ".", "Duration", "(", "o", ".", "TLSHandshakeTimeout", ")", ",", "TLSSkipVerify", ":", "o", ".", "TLSSkipVerify", ",", "RetryTimeMax", ":", "marshal", ".", "Duration", "(", "o", ".", "RetryTimeMax", ")", ",", "RetrySleepMax", ":", "marshal", ".", "Duration", "(", "o", ".", "RetrySleepMax", ")", ",", "RetrySleepBase", ":", "marshal", ".", "Duration", "(", "o", ".", "RetrySleepBase", ")", ",", "}", ")", "\n", "}" ]

[ "HasChildren", "checks", "to", "see", "if", "a", "compute", "resource", "has", "any", "child", "items", "(", "hosts", "and", "virtual", "machines", ")", "and", "returns", "true", "if", "that", "is", "the", "case", ".", "This", "is", "useful", "when", "checking", "to", "see", "if", "a", "compute", "cluster", "is", "safe", "to", "delete", "-", "destroying", "a", "compute", "resource", "in", "vSphere", "destroys", "*", "all", "*", "children", "if", "at", "all", "possible", "(", "including", "removing", "hosts", "and", "virtual", "machines", ")", "so", "extra", "verification", "is", "necessary", "to", "prevent", "accidental", "removal", "." ]

[ "func", "HasChildren", "(", "obj", "BaseComputeResource", ")", "(", "bool", ",", "error", ")", "{", "props", ",", "err", ":=", "BaseProperties", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "<mask>", ",", "err", "\n", "}", "\n\n", "// We calculate if there is children based on host count alone as", "// technically, if a compute resource has no hosts, it can't have virtual", "// machines either.", "return", "props", ".", "Summary", ".", "GetComputeResourceSummary", "(", ")", ".", "NumHosts", ">", "0", ",", "nil", "\n", "}" ]

[ "NewRClientWithAuth", "creates", "a", "RClient", "with", "the", "specified", "credentials", "and", "RServe", "server", "details" ]

[ "func", "NewRClientWithAuth", "(", "host", "string", ",", "port", "int64", ",", "user", ",", "password", "string", ")", "(", "RClient", ",", "error", ")", "{", "addr", ",", "err", ":=", "net", ".", "ResolveTCPAddr", "(", "\"", "\"", ",", "host", "+", "\"", "\"", "+", "strconv", ".", "FormatInt", "(", "port", ",", "10", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "rClient", ":=", "&", "roger", "{", "address", ":", "addr", ",", "user", ":", "<mask>", ",", "password", ":", "password", ",", "}", "\n\n", "if", "_", ",", "err", "=", "rClient", ".", "Eval", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "rClient", ",", "nil", "\n", "}" ]

[ "NewInlineQueryResultArticle", "returns", "a", "new", "InlineQueryResultArticle", "with", "all", "mandatory", "fields", "set", "." ]

[ "func", "NewInlineQueryResultArticle", "(", "id", ",", "<mask>", ",", "text", "string", ")", "*", "InlineQueryResultArticle", "{", "return", "&", "InlineQueryResultArticle", "{", "InlineQueryResultBase", ":", "InlineQueryResultBase", "{", "Type", ":", "ArticleResult", ",", "ID", ":", "id", ",", "}", ",", "Title", ":", "title", ",", "Text", ":", "text", ",", "}", "\n", "}" ]

[ "MarshalJSON", "supports", "json", ".", "Marshaler", "interface" ]

[ "func", "(", "v", "SearchInResponseBodyReturns", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "w", ":=", "jwriter", ".", "Writer", "{", "}", "\n", "easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork20", "(", "&", "w", ",", "v", ")", "\n", "return", "w", ".", "Buffer", ".", "BuildBytes", "(", ")", ",", "w", ".", "<mask>", "\n", "}" ]

[ "FileModeGoString", "returns", "the", "value", "of", "the", "os", ".", "FileMode", "for", "printing", "in", "a", "string", "." ]

[ "func", "FileModeGoString", "(", "o", "*", "<mask>", ".", "FileMode", ")", "string", "{", "if", "o", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "*", "o", ")", "\n", "}" ]

[ "NewSalter", "creates", "a", "new", "instance", "of", "Salter", ".", "It", "requires", "a", "list", "of", "sources", "of", "random", "data", "and", "optionally", "an", "input", "to", "salt", "next", "token", "." ]

[ "func", "NewSalter", "(", "sources", "RandomSourceList", ",", "input", "[", "]", "byte", ")", "*", "Salter", "{", "if", "input", "==", "nil", "{", "input", "=", "[", "]", "byte", "(", "\"", "\"", ")", "\n", "}", "\n\n", "hash", ":=", "sha256", ".", "New", "(", ")", "\n", "hash", ".", "Write", "(", "input", ")", "\n\n", "sum", ":=", "0", "\n", "for", "_", ",", "v", ":=", "range", "sources", "{", "sum", "+=", "v", ".", "Weight", "\n", "}", "\n\n", "return", "&", "Salter", "{", "salt", ":", "hash", ".", "Sum", "(", "nil", ")", ",", "rndSources", ":", "sources", ",", "sumWeight", ":", "<mask>", ",", "}", "\n", "}" ]

[ "Len", "returns", "the", "length", "of", "the", "array", "v", ".", "If", "v", ".", "Kind", "()", "!", "=", "Array", "Len", "returns", "0", "." ]

[ "func", "(", "v", "Value", ")", "Len", "(", ")", "int", "{", "x", ",", "<mask>", ":=", "v", ".", "data", ".", "(", "array", ")", "\n", "if", "!", "ok", "{", "return", "0", "\n", "}", "\n", "return", "len", "(", "x", ")", "\n", "}" ]

[ "MarshalJSON", "supports", "json", ".", "Marshaler", "interface" ]

[ "func", "(", "v", "MoveToReturns", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "w", ":=", "jwriter", ".", "Writer", "{", "}", "\n", "easyjsonC5a4559bEncodeGithubComChromedpCdprotoDom29", "(", "&", "w", ",", "v", ")", "\n", "return", "w", ".", "<mask>", ".", "BuildBytes", "(", ")", ",", "w", ".", "Error", "\n", "}" ]

[ "NewSdk", "is", "used", "to", "create", "a", "Sdk", "client", "to", "connect", "to", "the", "cloud", "provider", "." ]

[ "func", "NewSdk", "(", ")", "(", "*", "Sdk", ",", "error", ")", "{", "sdk", ":=", "&", "Sdk", "{", "}", "\n\n", "client", ",", "err", ":=", "google", ".", "DefaultClient", "(", "context", ".", "TODO", "(", ")", ",", "compute", ".", "ComputeScope", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "service", ",", "err", ":=", "compute", ".", "New", "(", "<mask>", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "sdk", ".", "Service", "=", "service", "\n", "return", "sdk", ",", "nil", "\n", "}" ]

[ "Start", "starts", "an", "existing", "GCE", "instance", "or", "create", "an", "instance", "with", "an", "existing", "disk", "." ]

[ "func", "(", "d", "*", "Driver", ")", "Start", "(", ")", "error", "{", "c", ",", "err", ":=", "newComputeUtil", "(", "d", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "instance", ",", "err", ":=", "c", ".", "instance", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "isNotFound", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "<mask>", "==", "nil", "{", "if", "err", "=", "c", ".", "createInstance", "(", "d", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "if", "err", ":=", "c", ".", "startInstance", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "d", ".", "IPAddress", ",", "err", "=", "d", ".", "GetIP", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "Read", "all", "the", "series", "records", "from", "a", "Checkpoint", "directory", "." ]

[ "func", "(", "w", "*", "WALWatcher", ")", "readCheckpoint", "(", "checkpointDir", "string", ")", "error", "{", "level", ".", "Debug", "(", "w", ".", "logger", ")", ".", "Log", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "checkpointDir", ")", "\n", "index", ",", "err", ":=", "checkpointNum", "(", "checkpointDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Ensure we read the whole contents of every segment in the checkpoint dir.", "segs", ",", "err", ":=", "w", ".", "segments", "(", "checkpointDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "seg", ":=", "range", "segs", "{", "size", ",", "err", ":=", "getSegmentSize", "(", "checkpointDir", ",", "seg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "sr", ",", "err", ":=", "wal", ".", "OpenReadSegment", "(", "wal", ".", "SegmentName", "(", "checkpointDir", ",", "seg", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "sr", ".", "Close", "(", ")", "\n\n", "r", ":=", "wal", ".", "NewLiveReader", "(", "w", ".", "logger", ",", "sr", ")", "\n", "if", "err", ":=", "w", ".", "readSegment", "(", "r", ",", "index", ",", "false", ")", ";", "err", "!=", "io", ".", "EOF", "&&", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "r", ".", "Offset", "(", ")", "!=", "size", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "checkpointDir", ",", "seg", ",", "size", ",", "r", ".", "Offset", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "level", ".", "Debug", "(", "w", ".", "logger", ")", ".", "<mask>", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "checkpointDir", ")", "\n", "return", "nil", "\n", "}" ]

[ "BoshReleaseOrEmpty", "returns", "the", "named", "BOSH", "release", "from", "this", "pivnet", "release", "if", "it", "exists", "otherwise", "emptyBoshRelease", "is", "returned", "." ]

[ "func", "(", "r", "*", "PivnetRelease", ")", "BoshReleaseOrEmpty", "(", "name", "string", ")", "*", "BoshRelease", "{", "br", ":=", "r", ".", "BoshRelease", "[", "<mask>", "]", "\n", "if", "br", "==", "nil", "{", "br", "=", "emptyBoshRelease", "\n", "}", "\n", "return", "br", "\n", "}" ]

[ "expect", "consumes", "the", "next", "token", "and", "guarantees", "it", "has", "the", "required", "type", "." ]

[ "func", "(", "p", "*", "parser", ")", "expect", "(", "exp", "ItemType", ",", "context", "string", ")", "item", "{", "token", ":=", "p", ".", "<mask>", "(", ")", "\n", "if", "token", ".", "typ", "!=", "exp", "{", "p", ".", "errorf", "(", "\"", "\"", ",", "token", ".", "desc", "(", ")", ",", "context", ",", "exp", ".", "desc", "(", ")", ")", "\n", "}", "\n", "return", "token", "\n", "}" ]

[ "Create", "a", "new", "temporary", "file", "in", "the", "directory", "dir", "with", "a", "name", "beginning", "with", "prefix", "writes", "the", "provided", "data", "into", "it", "and", "returns", "it", "s", "path", ".", "If", "dir", "is", "the", "empty", "string", "TempFile", "uses", "the", "default", "directory", "for", "temporary", "files", "(", "see", "os", ".", "TempDir", ")", ".", "Multiple", "programs", "calling", "TempFile", "simultaneously", "will", "not", "choose", "the", "same", "file", ".", "It", "is", "the", "caller", "s", "responsibility", "to", "remove", "the", "file", "when", "no", "longer", "needed", "." ]

[ "func", "Create", "(", "dir", ",", "prefix", "string", ",", "data", "[", "]", "byte", ")", "(", "path", "string", ",", "err", "error", ")", "{", "var", "tmp", "*", "os", ".", "File", "\n\n", "tmp", ",", "err", "=", "ioutil", ".", "TempFile", "(", "dir", ",", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "tmp", ".", "Close", "(", ")", "\n\n", "_", ",", "err", "=", "tmp", ".", "Write", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "tmp", ".", "<mask>", "(", ")", ",", "nil", "\n", "}" ]

[ "Wrap", "the", "given", "error", "in", "an", "errs", ".", "Err", ".", "If", "err", "is", "nil", "Wrap", "returns", "nil", ".", "Use", "Err", ".", "WrappedError", "for", "direct", "access", "to", "the", "wrapped", "error", "." ]

[ "func", "Wrap", "(", "wrapErr", "error", ",", "info", "Info", ",", "publicMsg", "...", "interface", "{", "}", ")", "Err", "{", "if", "wrapErr", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "if", "info", "==", "nil", "{", "<mask>", "=", "Info", "{", "}", "\n", "}", "\n", "if", "errsErr", ",", "isErr", ":=", "IsErr", "(", "wrapErr", ")", ";", "isErr", "{", "if", "errStructErr", ",", "isErrsErr", ":=", "errsErr", ".", "(", "*", "err", ")", ";", "isErrsErr", "{", "errStructErr", ".", "mergeIn", "(", "info", ",", "publicMsg", ")", "\n", "return", "errStructErr", "\n", "}", "\n", "return", "errsErr", "\n", "}", "\n", "return", "newErr", "(", "debug", ".", "Stack", "(", ")", ",", "wrapErr", ",", "false", ",", "info", ",", "publicMsg", ")", "\n", "}" ]

[ "Fail", "Response", "fail" ]

[ "func", "(", "ctx", "*", "Context", ")", "Fail", "(", "err", "error", ")", "{", "if", "err", "==", "nil", "{", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "ctx", ".", "Request", ".", "<mask>", ".", "Path", "}", ")", ".", "Warnln", "(", "\"", "\"", ")", "\n", "ctx", ".", "ResponseWriter", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "ctx", ".", "ResponseWriter", ".", "Write", "(", "nil", ")", "\n", "return", "\n", "}", "\n\n", "if", "ctx", ".", "written", "==", "true", "{", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "ctx", ".", "Request", ".", "URL", ".", "Path", "}", ")", ".", "Warnln", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "errno", ":=", "0", "\n", "errCore", ",", "ok", ":=", "err", ".", "(", "ICoreError", ")", "\n", "if", "ok", "==", "true", "{", "errno", "=", "errCore", ".", "GetErrno", "(", ")", "\n", "}", "\n", "ctx", ".", "written", "=", "true", "\n", "if", "Production", "==", "false", "{", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "ctx", ".", "Request", ".", "URL", ".", "Path", "}", ")", ".", "Warnln", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "else", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "ServerError", ")", ";", "ok", "==", "true", "{", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "ctx", ".", "Request", ".", "URL", ".", "Path", "}", ")", ".", "Warnln", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "var", "json", "=", "jsoniter", ".", "ConfigCompatibleWithStandardLibrary", "\n", "b", ",", "_", ":=", "json", ".", "Marshal", "(", "&", "ResFormat", "{", "Ok", ":", "false", ",", "Message", ":", "err", ".", "Error", "(", ")", ",", "Errno", ":", "errno", "}", ")", "\n\n", "coreErr", ",", "ok", ":=", "err", ".", "(", "ICoreError", ")", "\n", "if", "ok", "==", "true", "{", "ctx", ".", "ResponseWriter", ".", "WriteHeader", "(", "coreErr", ".", "GetHTTPCode", "(", ")", ")", "\n", "}", "else", "{", "ctx", ".", "ResponseWriter", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "}", "\n", "ctx", ".", "ResponseWriter", ".", "Write", "(", "b", ")", "\n", "}" ]

[ "SetValid", "changes", "this", "Float", "s", "value", "and", "also", "sets", "it", "to", "be", "non", "-", "null", "." ]

[ "func", "(", "f", "*", "<mask>", ")", "SetValid", "(", "v", "float64", ")", "{", "f", ".", "Float64", "=", "v", "\n", "f", ".", "Valid", "=", "true", "\n", "}" ]

[ "injectedSteps", "returns", "initial", "containers", "a", "final", "container", "and", "an", "additional", "volume", "." ]

[ "func", "injectedSteps", "(", "encodedJobSpec", "string", ",", "dc", "prowjobv1", ".", "DecorationConfig", ",", "injectedSource", "bool", ",", "toolsMount", "coreapi", ".", "VolumeMount", ",", "entries", "[", "]", "wrapper", ".", "Options", ")", "(", "[", "]", "coreapi", ".", "<mask>", ",", "*", "coreapi", ".", "Container", ",", "*", "coreapi", ".", "Volume", ",", "error", ")", "{", "gcsVol", ",", "gcsMount", ",", "gcsOptions", ":=", "decorate", ".", "GCSOptions", "(", "dc", ")", "\n\n", "sidecar", ",", "err", ":=", "decorate", ".", "Sidecar", "(", "dc", ".", "UtilityImages", ".", "Sidecar", ",", "gcsOptions", ",", "gcsMount", ",", "logMount", ",", "encodedJobSpec", ",", "decorate", ".", "RequirePassingEntries", ",", "entries", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "var", "cloneLogMount", "*", "coreapi", ".", "VolumeMount", "\n", "if", "injectedSource", "{", "cloneLogMount", "=", "&", "logMount", "\n", "}", "\n", "initUpload", ",", "err", ":=", "decorate", ".", "InitUpload", "(", "dc", ".", "UtilityImages", ".", "InitUpload", ",", "gcsOptions", ",", "gcsMount", ",", "cloneLogMount", ",", "encodedJobSpec", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "placer", ":=", "decorate", ".", "PlaceEntrypoint", "(", "dc", ".", "UtilityImages", ".", "Entrypoint", ",", "toolsMount", ")", "\n\n", "return", "[", "]", "coreapi", ".", "Container", "{", "placer", ",", "*", "initUpload", "}", ",", "sidecar", ",", "&", "gcsVol", ",", "nil", "\n", "}" ]

[ "Activate", "is", "a", "wrapper", "around", "gtk_accel_group_activate", "()", "." ]

[ "func", "(", "v", "*", "AccelGroup", ")", "Activate", "(", "quark", "glib", ".", "Quark", ",", "acceleratable", "*", "glib", ".", "Object", ",", "key", "uint", ",", "mods", "gdk", ".", "ModifierType", ")", "bool", "{", "return", "gobool", "(", "C", ".", "gtk_accel_group_activate", "(", "v", ".", "native", "(", ")", ",", "C", ".", "GQuark", "(", "quark", ")", ",", "(", "*", "C", ".", "GObject", ")", "(", "unsafe", ".", "Pointer", "(", "acceleratable", ".", "Native", "(", ")", ")", ")", ",", "C", ".", "guint", "(", "<mask>", ")", ",", "C", ".", "GdkModifierType", "(", "mods", ")", ")", ")", "\n", "}" ]

[ "Send", "accumulates", "the", "GossipData", "and", "will", "send", "it", "eventually", ".", "Send", "and", "Broadcast", "accumulate", "into", "different", "buckets", "." ]

[ "func", "(", "s", "*", "gossipSender", ")", "Send", "(", "data", "GossipData", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n", "if", "s", ".", "empty", "(", ")", "{", "defer", "s", ".", "prod", "(", ")", "\n", "}", "\n", "if", "s", ".", "gossip", "==", "nil", "{", "s", ".", "gossip", "=", "<mask>", "\n", "}", "else", "{", "s", ".", "gossip", "=", "s", ".", "gossip", ".", "Merge", "(", "data", ")", "\n", "}", "\n", "}" ]

[ "resourceVSphereComputeClusterProcessHostUpdate", "processes", "any", "changes", "in", "host", "membership", "in", "the", "cluster", ".", "Note", "that", "this", "has", "implications", "for", "interoperability", "with", "any", "future", "host", "resources", "that", "we", "may", "set", "up", "in", "Terraform", ".", "This", "namely", "exists", "to", "support", "the", "fact", "that", "some", "cluster", "configuration", "settings", "depend", "on", "hosts", "actually", "existing", "in", "the", "cluster", "before", "they", "can", "be", "carried", "out", "in", "addition", "to", "the", "fact", "that", "we", "don", "t", "have", "any", "actual", "host", "resources", "at", "this", "point", "in", "time", "and", "may", "actually", "not", "in", "the", "future", "as", "the", "addition", "of", "hosts", "will", "require", "passwords", "to", "be", "supplied", "to", "Terraform", "which", "will", "propagate", "to", "state", "and", "have", "security", "implications", ".", "Currently", "this", "process", "expects", "the", "hosts", "supplied", "to", "host_system_ids", "to", "be", "already", "added", "to", "vSphere", "-", "the", "recommended", "method", "would", "be", "to", "add", "these", "hosts", "OOB", "as", "standalone", "hosts", "to", "the", "datacenter", "that", "the", "cluster", "is", "being", "deployed", "to", "and", "then", "use", "the", "vsphere_host", "data", "source", "to", "get", "the", "necessary", "ID", "to", "pass", "into", "the", "vsphere_compute_cluster", "resource", ".", "Hosts", "moved", "*", "out", "*", "of", "the", "cluster", "will", "be", "moved", "to", "the", "root", "host", "folder", "of", "the", "datacenter", "the", "cluster", "belongs", "to", ".", "This", "will", "create", "a", "ComputeResource", "MO", "for", "this", "host", "OOB", "from", "Terraform", ".", "Conversely", "moving", "a", "host", "into", "a", "cluster", "removes", "the", "ComputeResource", "MO", "for", "that", "host", "in", "addition", "to", "moving", "any", "VMs", "into", "the", "cluster", "at", "the", "root", "cluster", "resource", "pool", "removing", "any", "resource", "pools", "that", "exist", "on", "the", "standalone", "host", ".", "Hosts", "being", "removed", "are", "placed", "into", "maintenance", "mode", ".", "It", "is", "up", "to", "the", "operator", "to", "determine", "what", "the", "implications", "of", "this", "are", "-", "if", "DRS", "is", "set", "up", "correctly", "and", "sufficient", "resources", "exist", "placing", "a", "host", "into", "maintenance", "mode", "*", "should", "*", "migrate", "powered", "on", "VMs", "off", "the", "cluster", ".", "Powered", "off", "VMs", "will", "be", "migrated", "as", "well", "leaving", "the", "host", "as", "empty", "as", "possible", "after", "it", "leaves", "the", "cluster", ".", "The", "host", "will", "be", "taken", "out", "of", "maintenance", "mode", "after", "being", "removed", "." ]

[ "func", "resourceVSphereComputeClusterProcessHostUpdate", "(", "d", "*", "schema", ".", "ResourceData", ",", "meta", "interface", "{", "}", ",", "cluster", "*", "object", ".", "ClusterComputeResource", ",", ")", "error", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "resourceVSphereComputeClusterIDString", "(", "d", ")", ")", "\n", "<mask>", ",", "err", ":=", "resourceVSphereComputeClusterClient", "(", "meta", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "o", ",", "n", ":=", "d", ".", "GetChange", "(", "\"", "\"", ")", "\n\n", "newHosts", ",", "err", ":=", "resourceVSphereComputeClusterGetHostSystemObjects", "(", "client", ",", "structure", ".", "SliceInterfacesToStrings", "(", "n", ".", "(", "*", "schema", ".", "Set", ")", ".", "Difference", "(", "o", ".", "(", "*", "schema", ".", "Set", ")", ")", ".", "List", "(", ")", ")", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "oldHosts", ",", "err", ":=", "resourceVSphereComputeClusterGetHostSystemObjects", "(", "client", ",", "structure", ".", "SliceInterfacesToStrings", "(", "o", ".", "(", "*", "schema", ".", "Set", ")", ".", "Difference", "(", "n", ".", "(", "*", "schema", ".", "Set", ")", ")", ".", "List", "(", ")", ")", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Add new hosts first", "if", "len", "(", "newHosts", ")", ">", "0", "{", "if", "err", ":=", "clustercomputeresource", ".", "MoveHostsInto", "(", "cluster", ",", "newHosts", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// Remove hosts next", "if", "err", ":=", "clustercomputeresource", ".", "MoveHostsOutOf", "(", "cluster", ",", "oldHosts", ",", "d", ".", "Get", "(", "\"", "\"", ")", ".", "(", "int", ")", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "buildEnv", "constructs", "the", "environment", "map", "for", "the", "job" ]

[ "func", "buildEnv", "(", "pj", "prowjobv1", ".", "ProwJob", ",", "buildID", "string", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "return", "downwardapi", ".", "EnvForSpec", "(", "downwardapi", ".", "NewJobSpec", "(", "pj", ".", "Spec", ",", "buildID", ",", "pj", ".", "<mask>", ")", ")", "\n", "}" ]

[ "sendFile", "sends", "a", "file", "into", "the", "tar", "stream", "." ]

[ "func", "(", "d", "*", "Destination", ")", "sendFile", "(", "path", "string", ",", "expectedSize", "int64", ",", "stream", "<mask>", ".", "Reader", ")", "error", "{", "hdr", ",", "err", ":=", "tar", ".", "FileInfoHeader", "(", "&", "tarFI", "{", "path", ":", "path", ",", "size", ":", "expectedSize", "}", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "path", ")", "\n", "if", "err", ":=", "d", ".", "tar", ".", "WriteHeader", "(", "hdr", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// TODO: This can take quite some time, and should ideally be cancellable using a context.Context.", "size", ",", "err", ":=", "io", ".", "Copy", "(", "d", ".", "tar", ",", "stream", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "size", "!=", "expectedSize", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "expectedSize", ",", "size", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Get", "executes", "GET", "request", "to", "the", "server", "endpoint", "with", "optional", "query", "arguments", "passed", "in", "params", "re", "err", ":", "=", "c", ".", "Get", "(", "c", ".", "Endpoint", "(", "users", ")", "url", ".", "Values", "{", "name", ":", "[]", "string", "{", "John", "}}", ")" ]

[ "func", "(", "c", "*", "Client", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "endpoint", "string", ",", "params", "url", ".", "Values", ")", "(", "*", "Response", ",", "error", ")", "{", "// If the sanitizer is enabled, make sure the requested path is safe.", "if", "c", ".", "sanitizerEnabled", "{", "err", ":=", "isPathSafe", "(", "endpoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "baseUrl", ",", "err", ":=", "url", ".", "Parse", "(", "endpoint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "baseUrl", ".", "RawQuery", "=", "params", ".", "Encode", "(", ")", "\n", "tracer", ":=", "c", ".", "newTracer", "(", ")", "\n", "return", "tracer", ".", "Done", "(", "c", ".", "RoundTrip", "(", "func", "(", ")", "(", "*", "http", ".", "<mask>", ",", "error", ")", "{", "req", ",", "err", ":=", "http", ".", "NewRequest", "(", "http", ".", "MethodGet", ",", "baseUrl", ".", "String", "(", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "req", "=", "req", ".", "WithContext", "(", "ctx", ")", "\n", "c", ".", "addAuth", "(", "req", ")", "\n", "tracer", ".", "Start", "(", "req", ")", "\n", "return", "c", ".", "client", ".", "Do", "(", "req", ")", "\n", "}", ")", ")", "\n", "}" ]

[ "ns1BuildRecord", "returns", "a", "dns", ".", "Record", "for", "a", "change", "set" ]

[ "func", "ns1BuildRecord", "(", "zoneName", "string", ",", "change", "*", "ns1Change", ")", "*", "dns", ".", "Record", "{", "record", ":=", "dns", ".", "NewRecord", "(", "zoneName", ",", "change", ".", "Endpoint", ".", "DNSName", ",", "change", ".", "Endpoint", ".", "RecordType", ")", "\n", "for", "_", ",", "v", ":=", "range", "change", ".", "Endpoint", ".", "Targets", "{", "record", ".", "AddAnswer", "(", "dns", ".", "NewAnswer", "(", "strings", ".", "Split", "(", "v", ",", "\"", "\"", ")", ")", ")", "\n", "}", "\n", "// set detault ttl", "var", "ttl", "=", "ns1DefaultTTL", "\n", "if", "change", ".", "Endpoint", ".", "RecordTTL", ".", "IsConfigured", "(", ")", "{", "ttl", "=", "int", "(", "change", ".", "Endpoint", ".", "RecordTTL", ")", "\n", "}", "\n", "record", ".", "TTL", "=", "ttl", "\n\n", "return", "<mask>", "\n", "}" ]

[ "set", "the", "scale", "and", "units", "used", "to", "calculate", "depth", "values" ]

[ "func", "PolygonOffset", "(", "<mask>", "float32", ",", "units", "float32", ")", "{", "C", ".", "glowPolygonOffset", "(", "gpPolygonOffset", ",", "(", "C", ".", "GLfloat", ")", "(", "factor", ")", ",", "(", "C", ".", "GLfloat", ")", "(", "units", ")", ")", "\n", "}" ]

[ "SortSlices", "returns", "a", "Transformer", "option", "that", "sorts", "all", "[]", "V", ".", "The", "less", "function", "must", "be", "of", "the", "form", "func", "(", "T", "T", ")", "bool", "which", "is", "used", "to", "sort", "any", "slice", "with", "element", "type", "V", "that", "is", "assignable", "to", "T", ".", "The", "less", "function", "must", "be", ":", "•", "Deterministic", ":", "less", "(", "x", "y", ")", "==", "less", "(", "x", "y", ")", "•", "Irreflexive", ":", "!less", "(", "x", "x", ")", "•", "Transitive", ":", "if", "!less", "(", "x", "y", ")", "and", "!less", "(", "y", "z", ")", "then", "!less", "(", "x", "z", ")", "The", "less", "function", "does", "not", "have", "to", "be", "total", ".", "That", "is", "if", "!less", "(", "x", "y", ")", "and", "!less", "(", "y", "x", ")", "for", "two", "elements", "x", "and", "y", "their", "relative", "order", "is", "maintained", ".", "SortSlices", "can", "be", "used", "in", "conjunction", "with", "EquateEmpty", "." ]

[ "func", "SortSlices", "(", "lessFunc", "<mask>", "{", "}", ")", "cmp", ".", "Option", "{", "vf", ":=", "reflect", ".", "ValueOf", "(", "lessFunc", ")", "\n", "if", "!", "function", ".", "IsType", "(", "vf", ".", "Type", "(", ")", ",", "function", ".", "Less", ")", "||", "vf", ".", "IsNil", "(", ")", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "lessFunc", ")", ")", "\n", "}", "\n", "ss", ":=", "sliceSorter", "{", "vf", ".", "Type", "(", ")", ".", "In", "(", "0", ")", ",", "vf", "}", "\n", "return", "cmp", ".", "FilterValues", "(", "ss", ".", "filter", ",", "cmp", ".", "Transformer", "(", "\"", "\"", ",", "ss", ".", "sort", ")", ")", "\n", "}" ]

[ "MarshalJSON", "supports", "json", ".", "Marshaler", "interface" ]

[ "func", "(", "v", "SamplingProfileNode", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "w", ":=", "jwriter", ".", "<mask>", "{", "}", "\n", "easyjsonC5a4559bEncodeGithubComChromedpCdprotoMemory4", "(", "&", "w", ",", "v", ")", "\n", "return", "w", ".", "Buffer", ".", "BuildBytes", "(", ")", ",", "w", ".", "Error", "\n", "}" ]

[ "GetPrintSettings", "()", "is", "a", "wrapper", "around", "gtk_print_operation_get_print_settings", "()", "." ]

[ "func", "(", "<mask>", "*", "PrintOperation", ")", "GetPrintSettings", "(", "ps", "*", "PageSetup", ")", "(", "*", "PrintSettings", ",", "error", ")", "{", "c", ":=", "C", ".", "gtk_print_operation_get_print_settings", "(", "po", ".", "native", "(", ")", ")", "\n", "if", "c", "==", "nil", "{", "return", "nil", ",", "nilPtrErr", "\n", "}", "\n", "obj", ":=", "glib", ".", "Take", "(", "unsafe", ".", "Pointer", "(", "c", ")", ")", "\n", "return", "wrapPrintSettings", "(", "obj", ")", ",", "nil", "\n", "}" ]

[ "flattenHostPortGroupSpec", "reads", "various", "fields", "from", "a", "HostPortGroupSpec", "into", "the", "passed", "in", "ResourceData", "." ]

[ "func", "flattenHostPortGroupSpec", "(", "d", "*", "schema", ".", "ResourceData", ",", "obj", "*", "<mask>", ".", "HostPortGroupSpec", ")", "error", "{", "d", ".", "Set", "(", "\"", "\"", ",", "obj", ".", "VlanId", ")", "\n", "if", "err", ":=", "flattenHostNetworkPolicy", "(", "d", ",", "&", "obj", ".", "Policy", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Do", "executes", "Network", ".", "deleteCookies", "against", "the", "provided", "context", "." ]

[ "func", "(", "p", "*", "DeleteCookiesParams", ")", "Do", "(", "ctx", "context", ".", "<mask>", ")", "(", "err", "error", ")", "{", "return", "cdp", ".", "Execute", "(", "ctx", ",", "CommandDeleteCookies", ",", "p", ",", "nil", ")", "\n", "}" ]

[ "retrieve", "information", "about", "implementation", "-", "dependent", "support", "for", "internal", "formats" ]

[ "func", "GetInternalformativ", "(", "target", "uint32", ",", "internalformat", "uint32", ",", "pname", "uint32", ",", "bufSize", "int32", ",", "params", "*", "int32", ")", "{", "syscall", ".", "Syscall6", "(", "gpGetInternalformativ", ",", "5", ",", "uintptr", "(", "<mask>", ")", ",", "uintptr", "(", "internalformat", ")", ",", "uintptr", "(", "pname", ")", ",", "uintptr", "(", "bufSize", ")", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "params", ")", ")", ",", "0", ")", "\n", "}" ]

[ "ProfileConfigClear", "resets", "the", "config", "of", "the", "profile", "with", "the", "given", "ID", "." ]

[ "func", "ProfileConfigClear", "(", "tx", "*", "sql", ".", "Tx", ",", "id", "int64", ")", "error", "{", "_", ",", "err", ":=", "tx", ".", "Exec", "(", "\"", "\"", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "tx", ".", "Exec", "(", "`DELETE FROM profiles_devices_config WHERE id IN\n\t\t(SELECT profiles_devices_config.id\n\t\t FROM profiles_devices_config JOIN profiles_devices\n\t\t ON profiles_devices_config.profile_device_id=profiles_devices.id\n\t\t WHERE profiles_devices.profile_id=?)`", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "_", ",", "err", "=", "<mask>", ".", "Exec", "(", "\"", "\"", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ListPullRequestComments", "returns", "review", "comments", "." ]

[ "func", "(", "f", "*", "FakeClient", ")", "ListPullRequestComments", "(", "<mask>", ",", "repo", "string", ",", "number", "int", ")", "(", "[", "]", "github", ".", "ReviewComment", ",", "error", ")", "{", "return", "append", "(", "[", "]", "github", ".", "ReviewComment", "{", "}", ",", "f", ".", "PullRequestComments", "[", "number", "]", "...", ")", ",", "nil", "\n", "}" ]

[ "CreateProvisionBroker", "creates", "a", "new", "provison", "broker", "[", "request", "]", "." ]

[ "func", "(", "a", "*", "API", ")", "CreateProvisionBroker", "(", "cfg", "*", "ProvisionBroker", ")", "(", "*", "ProvisionBroker", ",", "error", ")", "{", "if", "cfg", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "jsonCfg", ",", "err", ":=", "json", ".", "Marshal", "(", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "a", ".", "Debug", "{", "a", ".", "Log", ".", "Printf", "(", "\"", "\"", ",", "string", "(", "jsonCfg", ")", ")", "\n", "}", "\n\n", "result", ",", "err", ":=", "a", ".", "<mask>", "(", "config", ".", "ProvisionBrokerPrefix", ",", "jsonCfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "broker", ":=", "&", "ProvisionBroker", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "result", ",", "broker", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "broker", ",", "nil", "\n", "}" ]

[ "SoftwareVersion", "returns", "the", "version", "of", "the", "currently", "running", "instance" ]

[ "func", "(", "o", "*", "<mask>", ")", "SoftwareVersion", "(", ")", "string", "{", "o", ".", "cmdCtrlLock", ".", "RLock", "(", ")", "\n", "defer", "o", ".", "cmdCtrlLock", ".", "RUnlock", "(", ")", "\n", "return", "o", ".", "binaryUpgrade", ".", "GetCurrentVersion", "(", ")", "\n", "}" ]

[ "containerNextState", "determines", "the", "next", "state", "a", "container", "should", "go", "to", ".", "It", "returns", "a", "transition", "struct", "including", "the", "information", ":", "*", "container", "state", "it", "should", "transition", "to", "*", "a", "bool", "indicating", "whether", "any", "action", "is", "required", "*", "an", "error", "indicating", "why", "this", "transition", "can", "t", "happen", "Stopped", "false", "-", ">", "You", "can", "move", "it", "to", "known", "stopped", "but", "you", "don", "t", "have", "to", "call", "a", "transition", "function", "Running", "true", "-", ">", "You", "can", "move", "it", "to", "running", "and", "you", "need", "to", "call", "the", "transition", "function", "None", "false", "containerDependencyNotResolved", "-", ">", "This", "should", "not", "be", "moved", ";", "it", "has", "unresolved", "dependencies", ";", "Next", "status", "is", "determined", "by", "whether", "the", "known", "and", "desired", "statuses", "are", "equal", "the", "next", "numerically", "greater", "(", "iota", "-", "wise", ")", "status", "and", "whether", "dependencies", "are", "fully", "resolved", "." ]

[ "func", "(", "mtask", "*", "managedTask", ")", "containerNextState", "(", "container", "*", "apicontainer", ".", "Container", ")", "*", "containerTransition", "{", "containerKnownStatus", ":=", "container", ".", "GetKnownStatus", "(", ")", "\n", "containerDesiredStatus", ":=", "container", ".", "GetDesiredStatus", "(", ")", "\n\n", "if", "containerKnownStatus", "==", "containerDesiredStatus", "{", "seelog", ".", "Debugf", "(", "\"", "\"", ",", "mtask", ".", "Arn", ",", "container", ".", "Name", ",", "containerDesiredStatus", ".", "String", "(", ")", ")", "\n", "return", "&", "containerTransition", "{", "nextState", ":", "apicontainerstatus", ".", "ContainerStatusNone", ",", "actionRequired", ":", "false", ",", "<mask>", ":", "dependencygraph", ".", "ContainerPastDesiredStatusErr", ",", "}", "\n", "}", "\n\n", "if", "containerKnownStatus", ">", "containerDesiredStatus", "{", "seelog", ".", "Debugf", "(", "\"", "\"", ",", "mtask", ".", "Arn", ",", "container", ".", "Name", ",", "containerKnownStatus", ".", "String", "(", ")", ",", "containerDesiredStatus", ".", "String", "(", ")", ")", "\n", "return", "&", "containerTransition", "{", "nextState", ":", "apicontainerstatus", ".", "ContainerStatusNone", ",", "actionRequired", ":", "false", ",", "reason", ":", "dependencygraph", ".", "ContainerPastDesiredStatusErr", ",", "}", "\n", "}", "\n", "if", "blocked", ",", "err", ":=", "dependencygraph", ".", "DependenciesAreResolved", "(", "container", ",", "mtask", ".", "Containers", ",", "mtask", ".", "Task", ".", "GetExecutionCredentialsID", "(", ")", ",", "mtask", ".", "credentialsManager", ",", "mtask", ".", "GetResources", "(", ")", ")", ";", "err", "!=", "nil", "{", "seelog", ".", "Debugf", "(", "\"", "\"", ",", "mtask", ".", "Arn", ",", "container", ".", "Name", ",", "err", ")", "\n", "return", "&", "containerTransition", "{", "nextState", ":", "apicontainerstatus", ".", "ContainerStatusNone", ",", "actionRequired", ":", "false", ",", "reason", ":", "err", ",", "blockedOn", ":", "blocked", ",", "}", "\n", "}", "\n\n", "var", "nextState", "apicontainerstatus", ".", "ContainerStatus", "\n", "if", "container", ".", "DesiredTerminal", "(", ")", "{", "nextState", "=", "apicontainerstatus", ".", "ContainerStopped", "\n", "// It's not enough to just check if container is in steady state here", "// we should really check if >= RUNNING <= STOPPED", "if", "!", "container", ".", "IsRunning", "(", ")", "{", "// If the container's AppliedStatus is running, it means the StartContainer", "// api call has already been scheduled, we should not mark it as stopped", "// directly, because when the stopped container comes back, we will end up", "// with either:", "// 1. The task is not cleaned up, the handleStoppedToRunningContainerTransition", "// function will handle this case, but only once. If there are some", "// other stopped containers come back, they will not be stopped by", "// Agent.", "// 2. The task has already been cleaned up, in this case any stopped container", "// will not be stopped by Agent when they come back.", "if", "container", ".", "GetAppliedStatus", "(", ")", "==", "apicontainerstatus", ".", "ContainerRunning", "{", "nextState", "=", "apicontainerstatus", ".", "ContainerStatusNone", "\n", "}", "\n\n", "return", "&", "containerTransition", "{", "nextState", ":", "nextState", ",", "actionRequired", ":", "false", ",", "}", "\n", "}", "\n", "}", "else", "{", "nextState", "=", "container", ".", "GetNextKnownStateProgression", "(", ")", "\n", "}", "\n", "return", "&", "containerTransition", "{", "nextState", ":", "nextState", ",", "actionRequired", ":", "true", ",", "}", "\n", "}" ]

[ "GetManageOfferOp", "retrieves", "the", "ManageOfferOp", "value", "from", "the", "union", "returning", "ok", "if", "the", "union", "s", "switch", "indicated", "the", "value", "is", "valid", "." ]

[ "func", "(", "u", "OperationBody", ")", "GetManageOfferOp", "(", ")", "(", "result", "ManageOfferOp", ",", "<mask>", "bool", ")", "{", "armName", ",", "_", ":=", "u", ".", "ArmForSwitch", "(", "int32", "(", "u", ".", "Type", ")", ")", "\n\n", "if", "armName", "==", "\"", "\"", "{", "result", "=", "*", "u", ".", "ManageOfferOp", "\n", "ok", "=", "true", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Create", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockOS", ")", "Create", "(", "arg0", "string", ")", "(", "oswrapper", ".", "File", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "oswrapper", ".", "<mask>", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "Getpid", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockOS", ")", "Getpid", "(", ")", "int", "{", "<mask>", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "int", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Generate", "a", "new", "Time", "Based", "One", "Time", "Password", "with", "the", "given", "secret", "(", "a", "b32", "encoded", "key", ")" ]

[ "func", "New", "(", "secretB32", "string", ")", "(", "*", "TOTP", ",", "error", ")", "{", "// Decode the secret", "key", ",", "err", ":=", "base32", ".", "StdEncoding", ".", "DecodeString", "(", "secretB32", ")", "\n", "if", "nil", "!=", "err", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "&", "TOTP", "{", "<mask>", ",", "6", ",", "30", "}", ",", "nil", "\n", "}" ]

[ "GetHostIPs", "returns", "a", "list", "of", "IP", "addresses", "of", "all", "host", "s", "interfaces", "." ]

[ "func", "GetHostIPs", "(", ")", "(", "[", "]", "net", ".", "IP", ",", "error", ")", "{", "ifaces", ",", "err", ":=", "net", ".", "Interfaces", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "ips", "[", "]", "net", ".", "IP", "\n", "for", "_", ",", "iface", ":=", "range", "ifaces", "{", "if", "strings", ".", "HasPrefix", "(", "iface", ".", "Name", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "addrs", ",", "err", ":=", "iface", ".", "Addrs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "<mask>", "\n", "}", "\n", "for", "_", ",", "addr", ":=", "range", "addrs", "{", "if", "ipnet", ",", "ok", ":=", "addr", ".", "(", "*", "net", ".", "IPNet", ")", ";", "ok", "{", "ips", "=", "append", "(", "ips", ",", "ipnet", ".", "IP", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "ips", ",", "nil", "\n", "}" ]

[ "Generic", "ReplaceAtLine", ":", "replaces", "a", "number", "of", "regular", "expressions", "matched", "in", "r", "if", "the", "line", "is", "matched", "at", "the", "first", "." ]

[ "func", "(", "e", "*", "edit", ")", "genReplaceAtLine", "(", "r", "[", "]", "ReplacerAtLine", ",", "n", "int", ")", "error", "{", "if", "n", "==", "0", "{", "return", "nil", "\n", "}", "\n", "if", "_", ",", "err", ":=", "e", ".", "file", ".", "Seek", "(", "0", ",", "os", ".", "SEEK_SET", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// == Cache the regular expressions", "allReLine", ":=", "make", "(", "[", "]", "*", "regexp", ".", "Regexp", ",", "len", "(", "r", ")", ")", "\n", "allReSearch", ":=", "make", "(", "[", "]", "*", "regexp", ".", "Regexp", ",", "len", "(", "r", ")", ")", "\n", "allRepl", ":=", "make", "(", "[", "]", "[", "]", "byte", ",", "len", "(", "r", ")", ")", "\n\n", "for", "i", ",", "v", ":=", "range", "r", "{", "if", "reLine", ",", "err", ":=", "regexp", ".", "Compile", "(", "v", ".", "Line", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "allReLine", "[", "i", "]", "=", "reLine", "\n", "}", "\n\n", "if", "reSearch", ",", "err", ":=", "regexp", ".", "Compile", "(", "v", ".", "Search", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "allReSearch", "[", "i", "]", "=", "reSearch", "\n", "}", "\n\n", "allRepl", "[", "i", "]", "=", "[", "]", "byte", "(", "v", ".", "Replace", ")", "\n", "}", "\n\n", "buf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "isNew", ":=", "false", "\n\n", "// Replace every line, if it maches", "for", "{", "line", ",", "err", ":=", "e", ".", "buf", ".", "ReadBytes", "(", "'\\n'", ")", "\n", "if", "err", "==", "<mask>", ".", "EOF", "{", "break", "\n", "}", "\n\n", "for", "i", ",", "_", ":=", "range", "r", "{", "if", "allReLine", "[", "i", "]", ".", "Match", "(", "line", ")", "{", "j", ":=", "n", "\n\n", "line", "=", "allReSearch", "[", "i", "]", ".", "ReplaceAllFunc", "(", "line", ",", "func", "(", "s", "[", "]", "byte", ")", "[", "]", "byte", "{", "if", "!", "isNew", "{", "isNew", "=", "true", "\n", "}", "\n\n", "if", "j", "!=", "0", "{", "j", "--", "\n", "return", "allRepl", "[", "i", "]", "\n", "}", "\n", "return", "s", "\n", "}", ")", "\n", "}", "\n", "}", "\n", "if", "_", ",", "err", "=", "buf", ".", "Write", "(", "line", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "isNew", "{", "return", "e", ".", "rewrite", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "BytesTwo", "returns", "all", "readable", "bytes", "but", "in", "two", "separate", "slices", "to", "avoid", "copying", ".", "The", "two", "slices", "are", "from", "the", "same", "buffer", "but", "are", "not", "contiguous", ".", "Either", "or", "both", "may", "be", "empty", "slices", "." ]

[ "func", "(", "b", "*", "AtomicFixedSizeRingBuf", ")", "BytesTwo", "(", ")", "TwoBuffers", "{", "b", ".", "tex", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "tex", ".", "Unlock", "(", ")", "\n", "<mask>", "b", ".", "unatomic_BytesTwo", "(", ")", "\n", "}" ]

[ "Format", "implements", "the", "fmt", ".", "Formatter", "interface", ".", "If", "the", "context", "is", "printed", "with", "%", "+", "v", "then", "it", "prints", "using", "the", "String", "method", "of", "the", "wrapped", "context", "." ]

[ "func", "(", "c", "*", "contextT", ")", "Format", "(", "f", "fmt", ".", "State", ",", "ch", "rune", ")", "{", "if", "ch", "==", "'v'", "&&", "f", ".", "Flag", "(", "'+'", ")", "{", "fmt", ".", "Fprint", "(", "f", ",", "c", ".", "ctx", ")", "\n", "return", "\n", "}", "\n", "buf", ":=", "pool", ".", "AllocBuffer", "(", ")", "\n", "list", ":=", "<mask>", "(", "fromContext", "(", "c", ".", "ctx", ")", ")", "\n", "list", ".", "writeToBuffer", "(", "buf", ")", "\n", "f", ".", "Write", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "pool", ".", "ReleaseBuffer", "(", "buf", ")", "\n", "}" ]

[ "SetContentType", "sets", "Content", "-", "Type", "header", "value", "." ]

[ "func", "(", "h", "*", "RequestHeader", ")", "SetContentType", "(", "contentType", "string", ")", "{", "h", ".", "parseRawHeaders", "(", ")", "\n", "h", ".", "contentType", "=", "<mask>", "(", "h", ".", "contentType", "[", ":", "0", "]", ",", "contentType", "...", ")", "\n", "}" ]

[ "Usage", "writes", "usage", "information", "to", "stderr", "using", "the", "default", "header", "and", "table", "format" ]

[ "func", "Usage", "(", "prefix", "string", ",", "spec", "interface", "{", "}", ")", "error", "{", "// The default is to output the usage information as a table", "// Create tabwriter instance to support table output", "tabs", ":=", "tabwriter", ".", "NewWriter", "(", "os", ".", "Stdout", ",", "1", ",", "0", ",", "4", ",", "' '", ",", "0", ")", "\n\n", "err", ":=", "Usagef", "(", "<mask>", ",", "spec", ",", "tabs", ",", "DefaultTableFormat", ")", "\n", "tabs", ".", "Flush", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "Specify", "the", "value", "of", "a", "uniform", "variable", "for", "the", "current", "program", "object" ]

[ "func", "UniformMatrix2x4fv", "(", "<mask>", "int32", ",", "count", "int32", ",", "transpose", "bool", ",", "value", "*", "float32", ")", "{", "C", ".", "glowUniformMatrix2x4fv", "(", "gpUniformMatrix2x4fv", ",", "(", "C", ".", "GLint", ")", "(", "location", ")", ",", "(", "C", ".", "GLsizei", ")", "(", "count", ")", ",", "(", "C", ".", "GLboolean", ")", "(", "boolToInt", "(", "transpose", ")", ")", ",", "(", "*", "C", ".", "GLfloat", ")", "(", "unsafe", ".", "Pointer", "(", "value", ")", ")", ")", "\n", "}" ]

[ "Size", "returns", "the", "size", "of", "the", "artifact", "in", "GCS" ]

[ "func", "(", "a", "*", "GCSArtifact", ")", "Size", "(", ")", "(", "int64", ",", "error", ")", "{", "attrs", ",", "err", ":=", "a", ".", "<mask>", ".", "Attrs", "(", "a", ".", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "attrs", ".", "Size", ",", "nil", "\n", "}" ]

[ "CreateTokenHandler", "parses", "the", "token", "and", "create", "a", "handler" ]

[ "func", "CreateTokenHandler", "(", "tokenStream", "io", ".", "Reader", ",", "influxdb", "*", "InfluxDB", ")", "(", "*", "TokenHandler", ",", "error", ")", "{", "<mask>", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "tokenStream", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "client", ":=", "GetGitHubClient", "(", "strings", ".", "TrimSpace", "(", "string", "(", "token", ")", ")", ")", "\n", "login", ",", "err", ":=", "GetUsername", "(", "client", ")", "// Get user name for token", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "TokenHandler", "{", "gClient", ":", "client", ",", "login", ":", "login", ",", "influxdb", ":", "influxdb", ",", "}", ",", "nil", "\n", "}" ]

[ "Execute", "-", "creates", "organizations" ]

[ "func", "(", "c", "*", "CreateOrgsCommand", ")", "Execute", "(", "[", "]", "string", ")", "error", "{", "var", "cfMgmt", "*", "CFMgmt", "\n", "<mask>", "err", "error", "\n", "if", "cfMgmt", ",", "err", "=", "InitializePeekManagers", "(", "c", ".", "BaseCFConfigCommand", ",", "c", ".", "Peek", ")", ";", "err", "==", "nil", "{", "err", "=", "cfMgmt", ".", "OrgManager", ".", "CreateOrgs", "(", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "GetFillMax", "returns", "the", "FillMax", "field", "if", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "s", "*", "Style", ")", "GetFillMax", "(", ")", "json", ".", "Number", "{", "if", "s", "==", "nil", "||", "s", ".", "FillMax", "==", "nil", "{", "<mask>", "\"", "\"", "\n", "}", "\n", "return", "*", "s", ".", "FillMax", "\n", "}" ]

[ "PolicyConfigurationNamespaces", "returns", "a", "list", "of", "other", "policy", "configuration", "namespaces", "to", "search", "for", "if", "explicit", "configuration", "for", "PolicyConfigurationIdentity", "()", "is", "not", "set", ".", "The", "list", "will", "be", "processed", "in", "order", "terminating", "on", "first", "match", "and", "an", "implicit", "is", "always", "checked", "at", "the", "end", ".", "It", "is", "STRONGLY", "recommended", "for", "the", "first", "element", "if", "any", "to", "be", "a", "prefix", "of", "PolicyConfigurationIdentity", "()", "and", "each", "following", "element", "to", "be", "a", "prefix", "of", "the", "element", "preceding", "it", "." ]

[ "func", "(", "ref", "dirReference", ")", "PolicyConfigurationNamespaces", "(", ")", "[", "]", "string", "{", "<mask>", ":=", "[", "]", "string", "{", "}", "\n", "path", ":=", "ref", ".", "resolvedPath", "\n", "for", "{", "lastSlash", ":=", "strings", ".", "LastIndex", "(", "path", ",", "\"", "\"", ")", "\n", "if", "lastSlash", "==", "-", "1", "||", "lastSlash", "==", "0", "{", "break", "\n", "}", "\n", "path", "=", "path", "[", ":", "lastSlash", "]", "\n", "res", "=", "append", "(", "res", ",", "path", ")", "\n", "}", "\n", "// Note that we do not include \"/\"; it is redundant with the default \"\" global default,", "// and rejected by dirTransport.ValidatePolicyConfigurationScope above.", "return", "res", "\n", "}" ]

[ "WithObjectID", "JavaScript", "object", "id", "of", "the", "node", "wrapper", "." ]

[ "func", "(", "p", "GetOuterHTMLParams", ")", "WithObjectID", "(", "objectID", "runtime", ".", "RemoteObjectID", ")", "*", "GetOuterHTMLParams", "{", "p", ".", "ObjectID", "=", "objectID", "\n", "<mask>", "&", "p", "\n", "}" ]

[ "ToggleButtonNewWithLabel", "is", "a", "wrapper", "around", "gtk_toggle_button_new_with_label", "()", "." ]

[ "func", "ToggleButtonNewWithLabel", "(", "label", "string", ")", "(", "*", "ToggleButton", ",", "error", ")", "{", "cstr", ":=", "C", ".", "CString", "(", "label", ")", "\n", "defer", "C", ".", "<mask>", "(", "unsafe", ".", "Pointer", "(", "cstr", ")", ")", "\n", "c", ":=", "C", ".", "gtk_toggle_button_new_with_label", "(", "(", "*", "C", ".", "gchar", ")", "(", "cstr", ")", ")", "\n", "if", "c", "==", "nil", "{", "return", "nil", ",", "nilPtrErr", "\n", "}", "\n", "return", "wrapToggleButton", "(", "glib", ".", "Take", "(", "unsafe", ".", "Pointer", "(", "c", ")", ")", ")", ",", "nil", "\n", "}" ]

[ "sudo", "is", "a", "helper", "function", "that", "copies", "pachClient", "grants", "it", "PPS", "s", "superuser", "token", "and", "calls", "f", "with", "the", "superuser", "client", ".", "This", "helps", "isolate", "PPS", "s", "use", "of", "its", "superuser", "token", "so", "that", "it", "s", "not", "widely", "copied", "and", "is", "unlikely", "to", "leak", "authority", "to", "parts", "of", "the", "code", "that", "aren", "t", "supposed", "to", "have", "it", ".", "Note", "that", "because", "the", "argument", "to", "f", "is", "a", "superuser", "client", "it", "should", "not", "be", "used", "to", "make", "any", "calls", "with", "unvalidated", "user", "input", ".", "Any", "such", "use", "could", "be", "exploited", "to", "make", "PPS", "a", "confused", "deputy" ]

[ "func", "(", "a", "*", "apiServer", ")", "sudo", "(", "pachClient", "*", "client", ".", "APIClient", ",", "f", "func", "(", "*", "client", ".", "APIClient", ")", "error", ")", "error", "{", "// Get PPS auth token", "superUserTokenOnce", ".", "Do", "(", "func", "(", ")", "{", "b", ":=", "backoff", ".", "NewExponentialBackOff", "(", ")", "\n", "b", ".", "MaxElapsedTime", "=", "60", "*", "time", ".", "Second", "\n", "b", ".", "MaxInterval", "=", "5", "*", "time", ".", "Second", "\n", "if", "err", ":=", "backoff", ".", "Retry", "(", "func", "(", ")", "error", "{", "superUserTokenCol", ":=", "col", ".", "NewCollection", "(", "a", ".", "env", ".", "GetEtcdClient", "(", ")", ",", "ppsconsts", ".", "PPSTokenKey", ",", "nil", ",", "&", "types", ".", "StringValue", "{", "}", ",", "nil", ",", "nil", ")", ".", "ReadOnly", "(", "pachClient", ".", "Ctx", "(", ")", ")", "\n", "var", "result", "<mask>", ".", "StringValue", "\n", "if", "err", ":=", "superUserTokenCol", ".", "Get", "(", "\"", "\"", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "superUserToken", "=", "result", ".", "Value", "\n", "return", "nil", "\n", "}", ",", "b", ")", ";", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "}", ")", "\n\n", "// Copy pach client, but keep ctx (to propagate cancellation). Replace token", "// with superUserToken", "superUserClient", ":=", "pachClient", ".", "WithCtx", "(", "pachClient", ".", "Ctx", "(", ")", ")", "\n", "superUserClient", ".", "SetAuthToken", "(", "superUserToken", ")", "\n", "return", "f", "(", "superUserClient", ")", "\n", "}" ]

[ "cancelWatcher", "removes", "references", "of", "the", "watcher", "from", "the", "watchableStore" ]

[ "func", "(", "s", "*", "watchableStore", ")", "cancelWatcher", "(", "wa", "*", "watcher", ")", "{", "for", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "s", ".", "unsynced", ".", "delete", "(", "wa", ")", "{", "slowWatcherGauge", ".", "Dec", "(", ")", "\n", "break", "\n", "}", "else", "if", "s", ".", "synced", ".", "delete", "(", "wa", ")", "{", "break", "\n", "}", "else", "if", "wa", ".", "compacted", "{", "<mask>", "\n", "}", "else", "if", "wa", ".", "ch", "==", "nil", "{", "// already canceled (e.g., cancel/close race)", "break", "\n", "}", "\n\n", "if", "!", "wa", ".", "victim", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "victimBatch", "watcherBatch", "\n", "for", "_", ",", "wb", ":=", "range", "s", ".", "victims", "{", "if", "wb", "[", "wa", "]", "!=", "nil", "{", "victimBatch", "=", "wb", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "victimBatch", "!=", "nil", "{", "slowWatcherGauge", ".", "Dec", "(", ")", "\n", "delete", "(", "victimBatch", ",", "wa", ")", "\n", "break", "\n", "}", "\n\n", "// victim being processed so not accessible; retry", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "time", ".", "Sleep", "(", "time", ".", "Millisecond", ")", "\n", "}", "\n\n", "watcherGauge", ".", "Dec", "(", ")", "\n", "wa", ".", "ch", "=", "nil", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "MakeSlice", "returns", "a", "pointer", "to", "a", "zero", "length", "slice", "of", "the", "model", "e", ".", "g", ".", "*", "[]", "*", "Post", ".", "Note", ":", "Don", "t", "forget", "to", "initialize", "the", "slice", "using", "InitSlice", "()", "after", "adding", "elements", "with", "libraries", "like", "mgo", "." ]

[ "func", "(", "m", "*", "Meta", ")", "MakeSlice", "(", ")", "interface", "{", "}", "{", "slice", ":=", "reflect", ".", "MakeSlice", "(", "reflect", ".", "SliceOf", "(", "reflect", ".", "TypeOf", "(", "m", ".", "model", ")", ")", ",", "0", ",", "0", ")", "\n", "<mask>", ":=", "reflect", ".", "New", "(", "slice", ".", "Type", "(", ")", ")", "\n", "pointer", ".", "Elem", "(", ")", ".", "Set", "(", "slice", ")", "\n", "return", "pointer", ".", "Interface", "(", ")", "\n", "}" ]

[ "setOfferingHash", "computes", "and", "sets", "values", "for", "raw", "msg", "and", "hash", "fields", "." ]

[ "func", "(", "h", "*", "Handler", ")", "setOfferingHash", "(", "logger", "log", ".", "Logger", ",", "offering", "*", "data", ".", "Offering", ",", "template", "*", "data", ".", "Template", ",", "agent", "*", "data", ".", "Account", ")", "error", "{", "handleErr", ":=", "func", "(", "err", "error", ")", "error", "{", "logger", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "ErrInternal", "\n", "}", "\n", "msg", ":=", "offer", ".", "OfferingMessage", "(", "agent", ",", "template", ",", "offering", ")", "\n\n", "msgBytes", ",", "err", ":=", "json", ".", "Marshal", "(", "msg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "handleErr", "(", "err", ")", "\n", "}", "\n\n", "agentKey", ",", "err", ":=", "h", ".", "decryptKeyFunc", "(", "agent", ".", "PrivateKey", ",", "h", ".", "pwdStorage", ".", "Get", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "handleErr", "(", "err", ")", "\n", "}", "\n\n", "packed", ",", "err", ":=", "messages", ".", "PackWithSignature", "(", "msgBytes", ",", "agentKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "handleErr", "(", "err", ")", "\n", "}", "\n\n", "offering", ".", "RawMsg", "=", "data", ".", "FromBytes", "(", "packed", ")", "\n\n", "hashBytes", ":=", "<mask>", ".", "BytesToHash", "(", "crypto", ".", "Keccak256", "(", "packed", ")", ")", "\n\n", "offering", ".", "Hash", "=", "data", ".", "HexFromBytes", "(", "hashBytes", ".", "Bytes", "(", ")", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "SetBSON", "sets", "the", "ObjectId", "from", "raw", "bson", "data" ]

[ "func", "(", "id", "*", "ObjectId", ")", "SetBSON", "(", "raw", "bson", ".", "Raw", ")", "error", "{", "var", "m", "bson", ".", "M", "\n", "if", "err", ":=", "raw", ".", "Unmarshal", "(", "&", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "data", ",", "<mask>", ":=", "m", "[", "\"", "\"", "]", ".", "(", "string", ")", ";", "ok", "{", "*", "id", "=", "NewObjectId", "(", "data", ")", "\n", "return", "nil", "\n", "}", "\n\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "GetHost", "returns", "the", "Host", "field", "if", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "m", "*", "Metric", ")", "GetHost", "(", ")", "string", "{", "if", "m", "==", "nil", "||", "m", ".", "Host", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "<mask>", "*", "m", ".", "Host", "\n", "}" ]

[ "Before", "is", "for", "adding", "middleware", "for", "running", "before", "routing" ]

[ "func", "(", "c4", "*", "Seefor", ")", "Before", "(", "middleware", "...", "Before", ")", "{", "c4", ".", "befores", "=", "<mask>", "(", "c4", ".", "befores", ",", "middleware", "...", ")", "\n", "}" ]

[ "NewMockContainerMetadataResolver", "creates", "a", "new", "mock", "instance" ]

[ "func", "NewMockContainerMetadataResolver", "(", "ctrl", "*", "gomock", ".", "<mask>", ")", "*", "MockContainerMetadataResolver", "{", "mock", ":=", "&", "MockContainerMetadataResolver", "{", "ctrl", ":", "ctrl", "}", "\n", "mock", ".", "recorder", "=", "&", "MockContainerMetadataResolverMockRecorder", "{", "mock", "}", "\n", "return", "mock", "\n", "}" ]

[ "Do", "executes", "Network", ".", "takeResponseBodyForInterceptionAsStream", "against", "the", "provided", "context", ".", "returns", ":", "stream" ]

[ "func", "(", "p", "*", "TakeResponseBodyForInterceptionAsStreamParams", ")", "Do", "(", "ctx", "context", ".", "Context", ")", "(", "stream", "io", ".", "StreamHandle", ",", "err", "error", ")", "{", "// execute", "var", "res", "TakeResponseBodyForInterceptionAsStreamReturns", "\n", "err", "=", "cdp", ".", "Execute", "(", "ctx", ",", "CommandTakeResponseBodyForInterceptionAsStream", ",", "p", ",", "&", "<mask>", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "res", ".", "Stream", ",", "nil", "\n", "}" ]

[ "SetTimeout", "sets", "the", "timeout", "for", "the", "Context", "." ]

[ "func", "(", "cb", "*", "ContextBuilder", ")", "SetTimeout", "(", "timeout", "<mask>", ".", "Duration", ")", "*", "ContextBuilder", "{", "cb", ".", "Timeout", "=", "timeout", "\n", "return", "cb", "\n", "}" ]

[ "Unsubscribe", "deletes", "the", "handler", "from", "the", "EventStream" ]

[ "func", "(", "eventStream", "*", "EventStream", ")", "Unsubscribe", "(", "name", "string", ")", "{", "eventStream", ".", "handlersLock", ".", "Lock", "(", ")", "\n", "defer", "eventStream", ".", "handlersLock", ".", "Unlock", "(", ")", "\n\n", "for", "handler", ":=", "range", "eventStream", ".", "handlers", "{", "if", "handler", "==", "name", "{", "seelog", ".", "Debugf", "(", "\"", "\"", ",", "handler", ",", "eventStream", ".", "name", ")", "\n", "<mask>", "(", "eventStream", ".", "handlers", ",", "handler", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "ListAdminsCmd", "returns", "a", "cobra", "command", "that", "lists", "the", "current", "cluster", "admins" ]

[ "func", "ListAdminsCmd", "(", "noMetrics", ",", "noPortForwarding", "*", "bool", ")", "*", "cobra", ".", "Command", "{", "listAdmins", ":=", "&", "cobra", ".", "Command", "{", "Short", ":", "\"", "\"", ",", "Long", ":", "\"", "\"", ",", "Run", ":", "cmdutil", ".", "Run", "(", "func", "(", "[", "]", "string", ")", "error", "{", "c", ",", "err", ":=", "client", ".", "NewOnUserMachine", "(", "!", "*", "noMetrics", ",", "!", "*", "noPortForwarding", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "c", ".", "Close", "(", ")", "\n", "resp", ",", "err", ":=", "c", ".", "GetAdmins", "(", "c", ".", "Ctx", "(", ")", ",", "&", "auth", ".", "GetAdminsRequest", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "grpcutil", ".", "ScrubGRPC", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "<mask>", ":=", "range", "resp", ".", "Admins", "{", "fmt", ".", "Println", "(", "user", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", ",", "}", "\n", "return", "cmdutil", ".", "CreateAlias", "(", "listAdmins", ",", "\"", "\"", ")", "\n", "}" ]

[ "GetContainers", "returns", "containers", "created", "by", "the", "benchmark", "." ]

[ "func", "GetContainers", "(", "c", "lxd", ".", "ContainerServer", ")", "(", "[", "]", "api", ".", "<mask>", ",", "error", ")", "{", "containers", ":=", "[", "]", "api", ".", "Container", "{", "}", "\n\n", "allContainers", ",", "err", ":=", "c", ".", "GetContainers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "containers", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "container", ":=", "range", "allContainers", "{", "if", "container", ".", "Config", "[", "userConfigKey", "]", "==", "\"", "\"", "{", "containers", "=", "append", "(", "containers", ",", "container", ")", "\n", "}", "\n", "}", "\n\n", "return", "containers", ",", "nil", "\n", "}" ]

[ "SetMachineProviderConfig", "will", "attempt", "to", "match", "a", "provider", "config", "to", "a", "machine", "set", "on", "the", "Name", "field", ".", "If", "a", "match", "cannot", "be", "made", "we", "warn", "and", "move", "on", "." ]

[ "func", "(", "c", "*", "Cluster", ")", "SetMachineProviderConfigs", "(", "providerConfigs", "[", "]", "*", "MachineProviderConfig", ")", "{", "for", "_", ",", "providerConfig", ":=", "range", "providerConfigs", "{", "<mask>", ":=", "providerConfig", ".", "ServerPool", ".", "Name", "\n", "found", ":=", "false", "\n", "for", "_", ",", "machineSet", ":=", "range", "c", ".", "MachineSets", "{", "if", "machineSet", ".", "Name", "==", "name", "{", "//logger.Debug(\"Matched machine set to provider config: %s\", name)", "bytes", ",", "err", ":=", "json", ".", "Marshal", "(", "providerConfig", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Critical", "(", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n", "str", ":=", "string", "(", "bytes", ")", "\n", "machineSet", ".", "Spec", ".", "Template", ".", "Spec", ".", "ProviderConfig", "=", "str", "\n", "found", "=", "true", "\n", "}", "\n", "}", "\n\n", "// TODO", "// @kris-nova", "// Right now if we have a machine provider config and we can't match it", "// we log a warning and move on. We might want to change this to create", "// the machineSet moving forward..", "if", "!", "found", "{", "logger", ".", "Warning", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "}", "\n\n", "}" ]