repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go | yaml_parser_fetch_anchor | func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool {
// An anchor or an alias could be a simple key.
if !yaml_parser_save_simple_key(parser) {
return false
}
// A simple key cannot follow an anchor or an alias.
parser.simple_key_allowed = false
// Create the ALIAS or ANCHOR token and append it to the queue.
var token yaml_token_t
if !yaml_parser_scan_anchor(parser, &token, typ) {
return false
}
yaml_insert_token(parser, -1, &token)
return true
} | go | func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool {
// An anchor or an alias could be a simple key.
if !yaml_parser_save_simple_key(parser) {
return false
}
// A simple key cannot follow an anchor or an alias.
parser.simple_key_allowed = false
// Create the ALIAS or ANCHOR token and append it to the queue.
var token yaml_token_t
if !yaml_parser_scan_anchor(parser, &token, typ) {
return false
}
yaml_insert_token(parser, -1, &token)
return true
} | [
"func",
"yaml_parser_fetch_anchor",
"(",
"parser",
"*",
"yaml_parser_t",
",",
"typ",
"yaml_token_type_t",
")",
"bool",
"{",
"// An anchor or an alias could be a simple key.",
"if",
"!",
"yaml_parser_save_simple_key",
"(",
"parser",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// A simple key cannot follow an anchor or an alias.",
"parser",
".",
"simple_key_allowed",
"=",
"false",
"\n\n",
"// Create the ALIAS or ANCHOR token and append it to the queue.",
"var",
"token",
"yaml_token_t",
"\n",
"if",
"!",
"yaml_parser_scan_anchor",
"(",
"parser",
",",
"&",
"token",
",",
"typ",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"yaml_insert_token",
"(",
"parser",
",",
"-",
"1",
",",
"&",
"token",
")",
"\n",
"return",
"true",
"\n",
"}"
] | // Produce the ALIAS or ANCHOR token. | [
"Produce",
"the",
"ALIAS",
"or",
"ANCHOR",
"token",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go#L1339-L1355 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go | yaml_parser_fetch_tag | func yaml_parser_fetch_tag(parser *yaml_parser_t) bool {
// A tag could be a simple key.
if !yaml_parser_save_simple_key(parser) {
return false
}
// A simple key cannot follow a tag.
parser.simple_key_allowed = false
// Create the TAG token and append it to the queue.
var token yaml_token_t
if !yaml_parser_scan_tag(parser, &token) {
return false
}
yaml_insert_token(parser, -1, &token)
return true
} | go | func yaml_parser_fetch_tag(parser *yaml_parser_t) bool {
// A tag could be a simple key.
if !yaml_parser_save_simple_key(parser) {
return false
}
// A simple key cannot follow a tag.
parser.simple_key_allowed = false
// Create the TAG token and append it to the queue.
var token yaml_token_t
if !yaml_parser_scan_tag(parser, &token) {
return false
}
yaml_insert_token(parser, -1, &token)
return true
} | [
"func",
"yaml_parser_fetch_tag",
"(",
"parser",
"*",
"yaml_parser_t",
")",
"bool",
"{",
"// A tag could be a simple key.",
"if",
"!",
"yaml_parser_save_simple_key",
"(",
"parser",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// A simple key cannot follow a tag.",
"parser",
".",
"simple_key_allowed",
"=",
"false",
"\n\n",
"// Create the TAG token and append it to the queue.",
"var",
"token",
"yaml_token_t",
"\n",
"if",
"!",
"yaml_parser_scan_tag",
"(",
"parser",
",",
"&",
"token",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"yaml_insert_token",
"(",
"parser",
",",
"-",
"1",
",",
"&",
"token",
")",
"\n",
"return",
"true",
"\n",
"}"
] | // Produce the TAG token. | [
"Produce",
"the",
"TAG",
"token",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go#L1358-L1374 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go | yaml_parser_scan_to_next_token | func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
// Until the next token is not found.
for {
// Allow the BOM mark to start a line.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) {
skip(parser)
}
// Eat whitespaces.
// Tabs are allowed:
// - in the flow context
// - in the block context, but not at the beginning of the line or
// after '-', '?', or ':' (complex value).
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') {
skip(parser)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
// Eat a comment until a line break.
if parser.buffer[parser.buffer_pos] == '#' {
for !is_breakz(parser.buffer, parser.buffer_pos) {
skip(parser)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
}
// If it is a line break, eat it.
if is_break(parser.buffer, parser.buffer_pos) {
if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
return false
}
skip_line(parser)
// In the block context, a new line may start a simple key.
if parser.flow_level == 0 {
parser.simple_key_allowed = true
}
} else {
break // We have found a token.
}
}
return true
} | go | func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
// Until the next token is not found.
for {
// Allow the BOM mark to start a line.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) {
skip(parser)
}
// Eat whitespaces.
// Tabs are allowed:
// - in the flow context
// - in the block context, but not at the beginning of the line or
// after '-', '?', or ':' (complex value).
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') {
skip(parser)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
// Eat a comment until a line break.
if parser.buffer[parser.buffer_pos] == '#' {
for !is_breakz(parser.buffer, parser.buffer_pos) {
skip(parser)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
}
// If it is a line break, eat it.
if is_break(parser.buffer, parser.buffer_pos) {
if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
return false
}
skip_line(parser)
// In the block context, a new line may start a simple key.
if parser.flow_level == 0 {
parser.simple_key_allowed = true
}
} else {
break // We have found a token.
}
}
return true
} | [
"func",
"yaml_parser_scan_to_next_token",
"(",
"parser",
"*",
"yaml_parser_t",
")",
"bool",
"{",
"// Until the next token is not found.",
"for",
"{",
"// Allow the BOM mark to start a line.",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"parser",
".",
"mark",
".",
"column",
"==",
"0",
"&&",
"is_bom",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"{",
"skip",
"(",
"parser",
")",
"\n",
"}",
"\n\n",
"// Eat whitespaces.",
"// Tabs are allowed:",
"// - in the flow context",
"// - in the block context, but not at the beginning of the line or",
"// after '-', '?', or ':' (complex value).",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"' '",
"||",
"(",
"(",
"parser",
".",
"flow_level",
">",
"0",
"||",
"!",
"parser",
".",
"simple_key_allowed",
")",
"&&",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'\\t'",
")",
"{",
"skip",
"(",
"parser",
")",
"\n",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Eat a comment until a line break.",
"if",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'#'",
"{",
"for",
"!",
"is_breakz",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"{",
"skip",
"(",
"parser",
")",
"\n",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If it is a line break, eat it.",
"if",
"is_break",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"{",
"if",
"parser",
".",
"unread",
"<",
"2",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"2",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"skip_line",
"(",
"parser",
")",
"\n\n",
"// In the block context, a new line may start a simple key.",
"if",
"parser",
".",
"flow_level",
"==",
"0",
"{",
"parser",
".",
"simple_key_allowed",
"=",
"true",
"\n",
"}",
"\n",
"}",
"else",
"{",
"break",
"// We have found a token.",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] | // Eat whitespaces and comments until the next token is found. | [
"Eat",
"whitespaces",
"and",
"comments",
"until",
"the",
"next",
"token",
"is",
"found",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go#L1434-L1489 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go | yaml_parser_scan_tag_handle | func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool {
// Check the initial '!' character.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
if parser.buffer[parser.buffer_pos] != '!' {
yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find expected '!'")
return false
}
var s []byte
// Copy the '!' character.
s = read(parser, s)
// Copy all subsequent alphabetical and numerical characters.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
for is_alpha(parser.buffer, parser.buffer_pos) {
s = read(parser, s)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
// Check if the trailing character is '!' and copy it.
if parser.buffer[parser.buffer_pos] == '!' {
s = read(parser, s)
} else {
// It's either the '!' tag or not really a tag handle. If it's a %TAG
// directive, it's an error. If it's a tag token, it must be a part of URI.
if directive && !(s[0] == '!' && s[1] == 0) {
yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find expected '!'")
return false
}
}
*handle = s
return true
} | go | func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool {
// Check the initial '!' character.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
if parser.buffer[parser.buffer_pos] != '!' {
yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find expected '!'")
return false
}
var s []byte
// Copy the '!' character.
s = read(parser, s)
// Copy all subsequent alphabetical and numerical characters.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
for is_alpha(parser.buffer, parser.buffer_pos) {
s = read(parser, s)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
// Check if the trailing character is '!' and copy it.
if parser.buffer[parser.buffer_pos] == '!' {
s = read(parser, s)
} else {
// It's either the '!' tag or not really a tag handle. If it's a %TAG
// directive, it's an error. If it's a tag token, it must be a part of URI.
if directive && !(s[0] == '!' && s[1] == 0) {
yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find expected '!'")
return false
}
}
*handle = s
return true
} | [
"func",
"yaml_parser_scan_tag_handle",
"(",
"parser",
"*",
"yaml_parser_t",
",",
"directive",
"bool",
",",
"start_mark",
"yaml_mark_t",
",",
"handle",
"*",
"[",
"]",
"byte",
")",
"bool",
"{",
"// Check the initial '!' character.",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"!=",
"'!'",
"{",
"yaml_parser_set_scanner_tag_error",
"(",
"parser",
",",
"directive",
",",
"start_mark",
",",
"\"",
"\"",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"var",
"s",
"[",
"]",
"byte",
"\n\n",
"// Copy the '!' character.",
"s",
"=",
"read",
"(",
"parser",
",",
"s",
")",
"\n\n",
"// Copy all subsequent alphabetical and numerical characters.",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"is_alpha",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"{",
"s",
"=",
"read",
"(",
"parser",
",",
"s",
")",
"\n",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Check if the trailing character is '!' and copy it.",
"if",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'!'",
"{",
"s",
"=",
"read",
"(",
"parser",
",",
"s",
")",
"\n",
"}",
"else",
"{",
"// It's either the '!' tag or not really a tag handle. If it's a %TAG",
"// directive, it's an error. If it's a tag token, it must be a part of URI.",
"if",
"directive",
"&&",
"!",
"(",
"s",
"[",
"0",
"]",
"==",
"'!'",
"&&",
"s",
"[",
"1",
"]",
"==",
"0",
")",
"{",
"yaml_parser_set_scanner_tag_error",
"(",
"parser",
",",
"directive",
",",
"start_mark",
",",
"\"",
"\"",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"*",
"handle",
"=",
"s",
"\n",
"return",
"true",
"\n",
"}"
] | // Scan a tag handle. | [
"Scan",
"a",
"tag",
"handle",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go#L1914-L1956 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go | yaml_parser_scan_tag_uri | func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool {
//size_t length = head ? strlen((char *)head) : 0
var s []byte
// Copy the head if needed.
//
// Note that we don't copy the leading '!' character.
if len(head) > 1 {
s = append(s, head[1:]...)
}
// Scan the tag.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
// The set of characters that may appear in URI is as follows:
//
// '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
// '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
// '%'.
// [Go] Convert this into more reasonable logic.
for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||
parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||
parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||
parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' ||
parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' ||
parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' ||
parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' ||
parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' ||
parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' ||
parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' ||
parser.buffer[parser.buffer_pos] == '%' {
// Check if it is a URI-escape sequence.
if parser.buffer[parser.buffer_pos] == '%' {
if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) {
return false
}
} else {
s = read(parser, s)
}
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
// Check if the tag is non-empty.
if len(s) == 0 {
yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find expected tag URI")
return false
}
*uri = s
return true
} | go | func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool {
//size_t length = head ? strlen((char *)head) : 0
var s []byte
// Copy the head if needed.
//
// Note that we don't copy the leading '!' character.
if len(head) > 1 {
s = append(s, head[1:]...)
}
// Scan the tag.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
// The set of characters that may appear in URI is as follows:
//
// '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
// '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
// '%'.
// [Go] Convert this into more reasonable logic.
for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||
parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||
parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||
parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' ||
parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' ||
parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' ||
parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' ||
parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' ||
parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' ||
parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' ||
parser.buffer[parser.buffer_pos] == '%' {
// Check if it is a URI-escape sequence.
if parser.buffer[parser.buffer_pos] == '%' {
if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) {
return false
}
} else {
s = read(parser, s)
}
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
// Check if the tag is non-empty.
if len(s) == 0 {
yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find expected tag URI")
return false
}
*uri = s
return true
} | [
"func",
"yaml_parser_scan_tag_uri",
"(",
"parser",
"*",
"yaml_parser_t",
",",
"directive",
"bool",
",",
"head",
"[",
"]",
"byte",
",",
"start_mark",
"yaml_mark_t",
",",
"uri",
"*",
"[",
"]",
"byte",
")",
"bool",
"{",
"//size_t length = head ? strlen((char *)head) : 0",
"var",
"s",
"[",
"]",
"byte",
"\n\n",
"// Copy the head if needed.",
"//",
"// Note that we don't copy the leading '!' character.",
"if",
"len",
"(",
"head",
")",
">",
"1",
"{",
"s",
"=",
"append",
"(",
"s",
",",
"head",
"[",
"1",
":",
"]",
"...",
")",
"\n",
"}",
"\n\n",
"// Scan the tag.",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// The set of characters that may appear in URI is as follows:",
"//",
"// '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',",
"// '=', '+', '$', ',', '.', '!', '~', '*', '\\'', '(', ')', '[', ']',",
"// '%'.",
"// [Go] Convert this into more reasonable logic.",
"for",
"is_alpha",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"';'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'/'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'?'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"':'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'@'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'&'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'='",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'+'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'$'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"','",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'.'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'!'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'~'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'*'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'\\''",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'('",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"')'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'['",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"']'",
"||",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'%'",
"{",
"// Check if it is a URI-escape sequence.",
"if",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'%'",
"{",
"if",
"!",
"yaml_parser_scan_uri_escapes",
"(",
"parser",
",",
"directive",
",",
"start_mark",
",",
"&",
"s",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"else",
"{",
"s",
"=",
"read",
"(",
"parser",
",",
"s",
")",
"\n",
"}",
"\n",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Check if the tag is non-empty.",
"if",
"len",
"(",
"s",
")",
"==",
"0",
"{",
"yaml_parser_set_scanner_tag_error",
"(",
"parser",
",",
"directive",
",",
"start_mark",
",",
"\"",
"\"",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"*",
"uri",
"=",
"s",
"\n",
"return",
"true",
"\n",
"}"
] | // Scan a tag. | [
"Scan",
"a",
"tag",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go#L1959-L2013 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go | yaml_parser_scan_uri_escapes | func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool {
// Decode the required number of characters.
w := 1024
for w > 0 {
// Check for a URI-escaped octet.
if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
return false
}
if !(parser.buffer[parser.buffer_pos] == '%' &&
is_hex(parser.buffer, parser.buffer_pos+1) &&
is_hex(parser.buffer, parser.buffer_pos+2)) {
return yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find URI escaped octet")
}
// Get the octet.
octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2))
// If it is the leading octet, determine the length of the UTF-8 sequence.
if w == 1024 {
w = width(octet)
if w == 0 {
return yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "found an incorrect leading UTF-8 octet")
}
} else {
// Check if the trailing octet is correct.
if octet&0xC0 != 0x80 {
return yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "found an incorrect trailing UTF-8 octet")
}
}
// Copy the octet and move the pointers.
*s = append(*s, octet)
skip(parser)
skip(parser)
skip(parser)
w--
}
return true
} | go | func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool {
// Decode the required number of characters.
w := 1024
for w > 0 {
// Check for a URI-escaped octet.
if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
return false
}
if !(parser.buffer[parser.buffer_pos] == '%' &&
is_hex(parser.buffer, parser.buffer_pos+1) &&
is_hex(parser.buffer, parser.buffer_pos+2)) {
return yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "did not find URI escaped octet")
}
// Get the octet.
octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2))
// If it is the leading octet, determine the length of the UTF-8 sequence.
if w == 1024 {
w = width(octet)
if w == 0 {
return yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "found an incorrect leading UTF-8 octet")
}
} else {
// Check if the trailing octet is correct.
if octet&0xC0 != 0x80 {
return yaml_parser_set_scanner_tag_error(parser, directive,
start_mark, "found an incorrect trailing UTF-8 octet")
}
}
// Copy the octet and move the pointers.
*s = append(*s, octet)
skip(parser)
skip(parser)
skip(parser)
w--
}
return true
} | [
"func",
"yaml_parser_scan_uri_escapes",
"(",
"parser",
"*",
"yaml_parser_t",
",",
"directive",
"bool",
",",
"start_mark",
"yaml_mark_t",
",",
"s",
"*",
"[",
"]",
"byte",
")",
"bool",
"{",
"// Decode the required number of characters.",
"w",
":=",
"1024",
"\n",
"for",
"w",
">",
"0",
"{",
"// Check for a URI-escaped octet.",
"if",
"parser",
".",
"unread",
"<",
"3",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"3",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"!",
"(",
"parser",
".",
"buffer",
"[",
"parser",
".",
"buffer_pos",
"]",
"==",
"'%'",
"&&",
"is_hex",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
"+",
"1",
")",
"&&",
"is_hex",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
"+",
"2",
")",
")",
"{",
"return",
"yaml_parser_set_scanner_tag_error",
"(",
"parser",
",",
"directive",
",",
"start_mark",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get the octet.",
"octet",
":=",
"byte",
"(",
"(",
"as_hex",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
"+",
"1",
")",
"<<",
"4",
")",
"+",
"as_hex",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
"+",
"2",
")",
")",
"\n\n",
"// If it is the leading octet, determine the length of the UTF-8 sequence.",
"if",
"w",
"==",
"1024",
"{",
"w",
"=",
"width",
"(",
"octet",
")",
"\n",
"if",
"w",
"==",
"0",
"{",
"return",
"yaml_parser_set_scanner_tag_error",
"(",
"parser",
",",
"directive",
",",
"start_mark",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Check if the trailing octet is correct.",
"if",
"octet",
"&",
"0xC0",
"!=",
"0x80",
"{",
"return",
"yaml_parser_set_scanner_tag_error",
"(",
"parser",
",",
"directive",
",",
"start_mark",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Copy the octet and move the pointers.",
"*",
"s",
"=",
"append",
"(",
"*",
"s",
",",
"octet",
")",
"\n",
"skip",
"(",
"parser",
")",
"\n",
"skip",
"(",
"parser",
")",
"\n",
"skip",
"(",
"parser",
")",
"\n",
"w",
"--",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Decode an URI-escape sequence corresponding to a single UTF-8 character. | [
"Decode",
"an",
"URI",
"-",
"escape",
"sequence",
"corresponding",
"to",
"a",
"single",
"UTF",
"-",
"8",
"character",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go#L2016-L2059 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go | yaml_parser_scan_block_scalar_breaks | func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool {
*end_mark = parser.mark
// Eat the intendation spaces and line breaks.
max_indent := 0
for {
// Eat the intendation spaces.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) {
skip(parser)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
if parser.mark.column > max_indent {
max_indent = parser.mark.column
}
// Check for a tab character messing the intendation.
if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) {
return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
start_mark, "found a tab character where an intendation space is expected")
}
// Have we found a non-empty line?
if !is_break(parser.buffer, parser.buffer_pos) {
break
}
// Consume the line break.
if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
return false
}
// [Go] Should really be returning breaks instead.
*breaks = read_line(parser, *breaks)
*end_mark = parser.mark
}
// Determine the indentation level if needed.
if *indent == 0 {
*indent = max_indent
if *indent < parser.indent+1 {
*indent = parser.indent + 1
}
if *indent < 1 {
*indent = 1
}
}
return true
} | go | func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool {
*end_mark = parser.mark
// Eat the intendation spaces and line breaks.
max_indent := 0
for {
// Eat the intendation spaces.
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) {
skip(parser)
if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
return false
}
}
if parser.mark.column > max_indent {
max_indent = parser.mark.column
}
// Check for a tab character messing the intendation.
if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) {
return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
start_mark, "found a tab character where an intendation space is expected")
}
// Have we found a non-empty line?
if !is_break(parser.buffer, parser.buffer_pos) {
break
}
// Consume the line break.
if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
return false
}
// [Go] Should really be returning breaks instead.
*breaks = read_line(parser, *breaks)
*end_mark = parser.mark
}
// Determine the indentation level if needed.
if *indent == 0 {
*indent = max_indent
if *indent < parser.indent+1 {
*indent = parser.indent + 1
}
if *indent < 1 {
*indent = 1
}
}
return true
} | [
"func",
"yaml_parser_scan_block_scalar_breaks",
"(",
"parser",
"*",
"yaml_parser_t",
",",
"indent",
"*",
"int",
",",
"breaks",
"*",
"[",
"]",
"byte",
",",
"start_mark",
"yaml_mark_t",
",",
"end_mark",
"*",
"yaml_mark_t",
")",
"bool",
"{",
"*",
"end_mark",
"=",
"parser",
".",
"mark",
"\n\n",
"// Eat the intendation spaces and line breaks.",
"max_indent",
":=",
"0",
"\n",
"for",
"{",
"// Eat the intendation spaces.",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"(",
"*",
"indent",
"==",
"0",
"||",
"parser",
".",
"mark",
".",
"column",
"<",
"*",
"indent",
")",
"&&",
"is_space",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"{",
"skip",
"(",
"parser",
")",
"\n",
"if",
"parser",
".",
"unread",
"<",
"1",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"parser",
".",
"mark",
".",
"column",
">",
"max_indent",
"{",
"max_indent",
"=",
"parser",
".",
"mark",
".",
"column",
"\n",
"}",
"\n\n",
"// Check for a tab character messing the intendation.",
"if",
"(",
"*",
"indent",
"==",
"0",
"||",
"parser",
".",
"mark",
".",
"column",
"<",
"*",
"indent",
")",
"&&",
"is_tab",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"{",
"return",
"yaml_parser_set_scanner_error",
"(",
"parser",
",",
"\"",
"\"",
",",
"start_mark",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Have we found a non-empty line?",
"if",
"!",
"is_break",
"(",
"parser",
".",
"buffer",
",",
"parser",
".",
"buffer_pos",
")",
"{",
"break",
"\n",
"}",
"\n\n",
"// Consume the line break.",
"if",
"parser",
".",
"unread",
"<",
"2",
"&&",
"!",
"yaml_parser_update_buffer",
"(",
"parser",
",",
"2",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"// [Go] Should really be returning breaks instead.",
"*",
"breaks",
"=",
"read_line",
"(",
"parser",
",",
"*",
"breaks",
")",
"\n",
"*",
"end_mark",
"=",
"parser",
".",
"mark",
"\n",
"}",
"\n\n",
"// Determine the indentation level if needed.",
"if",
"*",
"indent",
"==",
"0",
"{",
"*",
"indent",
"=",
"max_indent",
"\n",
"if",
"*",
"indent",
"<",
"parser",
".",
"indent",
"+",
"1",
"{",
"*",
"indent",
"=",
"parser",
".",
"indent",
"+",
"1",
"\n",
"}",
"\n",
"if",
"*",
"indent",
"<",
"1",
"{",
"*",
"indent",
"=",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Scan intendation spaces and line breaks for a block scalar. Determine the
// intendation level if needed. | [
"Scan",
"intendation",
"spaces",
"and",
"line",
"breaks",
"for",
"a",
"block",
"scalar",
".",
"Determine",
"the",
"intendation",
"level",
"if",
"needed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/gopkg.in/yaml.v2/scannerc.go#L2250-L2301 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/helpers.go | LabelSelectorAsSelector | func LabelSelectorAsSelector(ps *LabelSelector) (labels.Selector, error) {
if ps == nil {
return labels.Nothing(), nil
}
if len(ps.MatchLabels)+len(ps.MatchExpressions) == 0 {
return labels.Everything(), nil
}
selector := labels.NewSelector()
for k, v := range ps.MatchLabels {
r, err := labels.NewRequirement(k, labels.InOperator, sets.NewString(v))
if err != nil {
return nil, err
}
selector = selector.Add(*r)
}
for _, expr := range ps.MatchExpressions {
var op labels.Operator
switch expr.Operator {
case LabelSelectorOpIn:
op = labels.InOperator
case LabelSelectorOpNotIn:
op = labels.NotInOperator
case LabelSelectorOpExists:
op = labels.ExistsOperator
case LabelSelectorOpDoesNotExist:
op = labels.DoesNotExistOperator
default:
return nil, fmt.Errorf("%q is not a valid pod selector operator", expr.Operator)
}
r, err := labels.NewRequirement(expr.Key, op, sets.NewString(expr.Values...))
if err != nil {
return nil, err
}
selector = selector.Add(*r)
}
return selector, nil
} | go | func LabelSelectorAsSelector(ps *LabelSelector) (labels.Selector, error) {
if ps == nil {
return labels.Nothing(), nil
}
if len(ps.MatchLabels)+len(ps.MatchExpressions) == 0 {
return labels.Everything(), nil
}
selector := labels.NewSelector()
for k, v := range ps.MatchLabels {
r, err := labels.NewRequirement(k, labels.InOperator, sets.NewString(v))
if err != nil {
return nil, err
}
selector = selector.Add(*r)
}
for _, expr := range ps.MatchExpressions {
var op labels.Operator
switch expr.Operator {
case LabelSelectorOpIn:
op = labels.InOperator
case LabelSelectorOpNotIn:
op = labels.NotInOperator
case LabelSelectorOpExists:
op = labels.ExistsOperator
case LabelSelectorOpDoesNotExist:
op = labels.DoesNotExistOperator
default:
return nil, fmt.Errorf("%q is not a valid pod selector operator", expr.Operator)
}
r, err := labels.NewRequirement(expr.Key, op, sets.NewString(expr.Values...))
if err != nil {
return nil, err
}
selector = selector.Add(*r)
}
return selector, nil
} | [
"func",
"LabelSelectorAsSelector",
"(",
"ps",
"*",
"LabelSelector",
")",
"(",
"labels",
".",
"Selector",
",",
"error",
")",
"{",
"if",
"ps",
"==",
"nil",
"{",
"return",
"labels",
".",
"Nothing",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"if",
"len",
"(",
"ps",
".",
"MatchLabels",
")",
"+",
"len",
"(",
"ps",
".",
"MatchExpressions",
")",
"==",
"0",
"{",
"return",
"labels",
".",
"Everything",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"selector",
":=",
"labels",
".",
"NewSelector",
"(",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"ps",
".",
"MatchLabels",
"{",
"r",
",",
"err",
":=",
"labels",
".",
"NewRequirement",
"(",
"k",
",",
"labels",
".",
"InOperator",
",",
"sets",
".",
"NewString",
"(",
"v",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"selector",
"=",
"selector",
".",
"Add",
"(",
"*",
"r",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"expr",
":=",
"range",
"ps",
".",
"MatchExpressions",
"{",
"var",
"op",
"labels",
".",
"Operator",
"\n",
"switch",
"expr",
".",
"Operator",
"{",
"case",
"LabelSelectorOpIn",
":",
"op",
"=",
"labels",
".",
"InOperator",
"\n",
"case",
"LabelSelectorOpNotIn",
":",
"op",
"=",
"labels",
".",
"NotInOperator",
"\n",
"case",
"LabelSelectorOpExists",
":",
"op",
"=",
"labels",
".",
"ExistsOperator",
"\n",
"case",
"LabelSelectorOpDoesNotExist",
":",
"op",
"=",
"labels",
".",
"DoesNotExistOperator",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"expr",
".",
"Operator",
")",
"\n",
"}",
"\n",
"r",
",",
"err",
":=",
"labels",
".",
"NewRequirement",
"(",
"expr",
".",
"Key",
",",
"op",
",",
"sets",
".",
"NewString",
"(",
"expr",
".",
"Values",
"...",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"selector",
"=",
"selector",
".",
"Add",
"(",
"*",
"r",
")",
"\n",
"}",
"\n",
"return",
"selector",
",",
"nil",
"\n",
"}"
] | // LabelSelectorAsSelector converts the LabelSelector api type into a struct that implements
// labels.Selector | [
"LabelSelectorAsSelector",
"converts",
"the",
"LabelSelector",
"api",
"type",
"into",
"a",
"struct",
"that",
"implements",
"labels",
".",
"Selector"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/helpers.go#L29-L65 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/helpers.go | ScaleFromDeployment | func ScaleFromDeployment(deployment *Deployment) *Scale {
return &Scale{
ObjectMeta: api.ObjectMeta{
Name: deployment.Name,
Namespace: deployment.Namespace,
CreationTimestamp: deployment.CreationTimestamp,
},
Spec: ScaleSpec{
Replicas: deployment.Spec.Replicas,
},
Status: ScaleStatus{
Replicas: deployment.Status.Replicas,
Selector: deployment.Spec.Selector,
},
}
} | go | func ScaleFromDeployment(deployment *Deployment) *Scale {
return &Scale{
ObjectMeta: api.ObjectMeta{
Name: deployment.Name,
Namespace: deployment.Namespace,
CreationTimestamp: deployment.CreationTimestamp,
},
Spec: ScaleSpec{
Replicas: deployment.Spec.Replicas,
},
Status: ScaleStatus{
Replicas: deployment.Status.Replicas,
Selector: deployment.Spec.Selector,
},
}
} | [
"func",
"ScaleFromDeployment",
"(",
"deployment",
"*",
"Deployment",
")",
"*",
"Scale",
"{",
"return",
"&",
"Scale",
"{",
"ObjectMeta",
":",
"api",
".",
"ObjectMeta",
"{",
"Name",
":",
"deployment",
".",
"Name",
",",
"Namespace",
":",
"deployment",
".",
"Namespace",
",",
"CreationTimestamp",
":",
"deployment",
".",
"CreationTimestamp",
",",
"}",
",",
"Spec",
":",
"ScaleSpec",
"{",
"Replicas",
":",
"deployment",
".",
"Spec",
".",
"Replicas",
",",
"}",
",",
"Status",
":",
"ScaleStatus",
"{",
"Replicas",
":",
"deployment",
".",
"Status",
".",
"Replicas",
",",
"Selector",
":",
"deployment",
".",
"Spec",
".",
"Selector",
",",
"}",
",",
"}",
"\n",
"}"
] | // ScaleFromDeployment returns a scale subresource for a deployment. | [
"ScaleFromDeployment",
"returns",
"a",
"scale",
"subresource",
"for",
"a",
"deployment",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/helpers.go#L68-L83 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/iptables/iptables.go | Save | func (runner *runner) Save(table Table) ([]byte, error) {
runner.mu.Lock()
defer runner.mu.Unlock()
// run and return
args := []string{"-t", string(table)}
return runner.exec.Command(cmdIptablesSave, args...).CombinedOutput()
} | go | func (runner *runner) Save(table Table) ([]byte, error) {
runner.mu.Lock()
defer runner.mu.Unlock()
// run and return
args := []string{"-t", string(table)}
return runner.exec.Command(cmdIptablesSave, args...).CombinedOutput()
} | [
"func",
"(",
"runner",
"*",
"runner",
")",
"Save",
"(",
"table",
"Table",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"runner",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"runner",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// run and return",
"args",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"string",
"(",
"table",
")",
"}",
"\n",
"return",
"runner",
".",
"exec",
".",
"Command",
"(",
"cmdIptablesSave",
",",
"args",
"...",
")",
".",
"CombinedOutput",
"(",
")",
"\n",
"}"
] | // Save is part of Interface. | [
"Save",
"is",
"part",
"of",
"Interface",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/iptables/iptables.go#L291-L298 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/iptables/iptables.go | SaveAll | func (runner *runner) SaveAll() ([]byte, error) {
runner.mu.Lock()
defer runner.mu.Unlock()
// run and return
return runner.exec.Command(cmdIptablesSave, []string{}...).CombinedOutput()
} | go | func (runner *runner) SaveAll() ([]byte, error) {
runner.mu.Lock()
defer runner.mu.Unlock()
// run and return
return runner.exec.Command(cmdIptablesSave, []string{}...).CombinedOutput()
} | [
"func",
"(",
"runner",
"*",
"runner",
")",
"SaveAll",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"runner",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"runner",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// run and return",
"return",
"runner",
".",
"exec",
".",
"Command",
"(",
"cmdIptablesSave",
",",
"[",
"]",
"string",
"{",
"}",
"...",
")",
".",
"CombinedOutput",
"(",
")",
"\n",
"}"
] | // SaveAll is part of Interface. | [
"SaveAll",
"is",
"part",
"of",
"Interface",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/iptables/iptables.go#L301-L307 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion_generator.go | primitiveConversion | func primitiveConversion(inType, outType reflect.Type) (string, bool) {
switch inType.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64:
switch outType.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64:
return outType.Name(), true
}
}
return "", false
} | go | func primitiveConversion(inType, outType reflect.Type) (string, bool) {
switch inType.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64:
switch outType.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64:
return outType.Name(), true
}
}
return "", false
} | [
"func",
"primitiveConversion",
"(",
"inType",
",",
"outType",
"reflect",
".",
"Type",
")",
"(",
"string",
",",
"bool",
")",
"{",
"switch",
"inType",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Int",
",",
"reflect",
".",
"Int8",
",",
"reflect",
".",
"Int16",
",",
"reflect",
".",
"Int32",
",",
"reflect",
".",
"Int64",
",",
"reflect",
".",
"Uint",
",",
"reflect",
".",
"Uint8",
",",
"reflect",
".",
"Uint16",
",",
"reflect",
".",
"Uint32",
",",
"reflect",
".",
"Uint64",
",",
"reflect",
".",
"Float32",
",",
"reflect",
".",
"Float64",
":",
"switch",
"outType",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Int",
",",
"reflect",
".",
"Int8",
",",
"reflect",
".",
"Int16",
",",
"reflect",
".",
"Int32",
",",
"reflect",
".",
"Int64",
",",
"reflect",
".",
"Uint",
",",
"reflect",
".",
"Uint8",
",",
"reflect",
".",
"Uint16",
",",
"reflect",
".",
"Uint32",
",",
"reflect",
".",
"Uint64",
",",
"reflect",
".",
"Float32",
",",
"reflect",
".",
"Float64",
":",
"return",
"outType",
".",
"Name",
"(",
")",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}"
] | // primitiveConversion returns true if the two types can be converted via a cast. | [
"primitiveConversion",
"returns",
"true",
"if",
"the",
"two",
"types",
"can",
"be",
"converted",
"via",
"a",
"cast",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/conversion_generator.go#L127-L140 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/run.go | HandleResourceRequirements | func HandleResourceRequirements(params map[string]string) (api.ResourceRequirements, error) {
result := api.ResourceRequirements{}
limits, err := populateResourceList(params["limits"])
if err != nil {
return result, err
}
result.Limits = limits
requests, err := populateResourceList(params["requests"])
if err != nil {
return result, err
}
result.Requests = requests
return result, nil
} | go | func HandleResourceRequirements(params map[string]string) (api.ResourceRequirements, error) {
result := api.ResourceRequirements{}
limits, err := populateResourceList(params["limits"])
if err != nil {
return result, err
}
result.Limits = limits
requests, err := populateResourceList(params["requests"])
if err != nil {
return result, err
}
result.Requests = requests
return result, nil
} | [
"func",
"HandleResourceRequirements",
"(",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"api",
".",
"ResourceRequirements",
",",
"error",
")",
"{",
"result",
":=",
"api",
".",
"ResourceRequirements",
"{",
"}",
"\n",
"limits",
",",
"err",
":=",
"populateResourceList",
"(",
"params",
"[",
"\"",
"\"",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"result",
",",
"err",
"\n",
"}",
"\n",
"result",
".",
"Limits",
"=",
"limits",
"\n",
"requests",
",",
"err",
":=",
"populateResourceList",
"(",
"params",
"[",
"\"",
"\"",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"result",
",",
"err",
"\n",
"}",
"\n",
"result",
".",
"Requests",
"=",
"requests",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // HandleResourceRequirements parses the limits and requests parameters if specified | [
"HandleResourceRequirements",
"parses",
"the",
"limits",
"and",
"requests",
"parameters",
"if",
"specified"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/run.go#L330-L343 | train |
kubernetes-retired/contrib | release-notes/Godeps/_workspace/src/golang.org/x/oauth2/jws/jws.go | Decode | func Decode(payload string) (*ClaimSet, error) {
// decode returned id token to get expiry
s := strings.Split(payload, ".")
if len(s) < 2 {
// TODO(jbd): Provide more context about the error.
return nil, errors.New("jws: invalid token received")
}
decoded, err := base64Decode(s[1])
if err != nil {
return nil, err
}
c := &ClaimSet{}
err = json.NewDecoder(bytes.NewBuffer(decoded)).Decode(c)
return c, err
} | go | func Decode(payload string) (*ClaimSet, error) {
// decode returned id token to get expiry
s := strings.Split(payload, ".")
if len(s) < 2 {
// TODO(jbd): Provide more context about the error.
return nil, errors.New("jws: invalid token received")
}
decoded, err := base64Decode(s[1])
if err != nil {
return nil, err
}
c := &ClaimSet{}
err = json.NewDecoder(bytes.NewBuffer(decoded)).Decode(c)
return c, err
} | [
"func",
"Decode",
"(",
"payload",
"string",
")",
"(",
"*",
"ClaimSet",
",",
"error",
")",
"{",
"// decode returned id token to get expiry",
"s",
":=",
"strings",
".",
"Split",
"(",
"payload",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"s",
")",
"<",
"2",
"{",
"// TODO(jbd): Provide more context about the error.",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"decoded",
",",
"err",
":=",
"base64Decode",
"(",
"s",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"c",
":=",
"&",
"ClaimSet",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"bytes",
".",
"NewBuffer",
"(",
"decoded",
")",
")",
".",
"Decode",
"(",
"c",
")",
"\n",
"return",
"c",
",",
"err",
"\n",
"}"
] | // Decode decodes a claim set from a JWS payload. | [
"Decode",
"decodes",
"a",
"claim",
"set",
"from",
"a",
"JWS",
"payload",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/release-notes/Godeps/_workspace/src/golang.org/x/oauth2/jws/jws.go#L107-L121 | train |
kubernetes-retired/contrib | release-notes/Godeps/_workspace/src/golang.org/x/oauth2/jws/jws.go | Encode | func Encode(header *Header, c *ClaimSet, signature *rsa.PrivateKey) (string, error) {
head, err := header.encode()
if err != nil {
return "", err
}
cs, err := c.encode()
if err != nil {
return "", err
}
ss := fmt.Sprintf("%s.%s", head, cs)
h := sha256.New()
h.Write([]byte(ss))
b, err := rsa.SignPKCS1v15(rand.Reader, signature, crypto.SHA256, h.Sum(nil))
if err != nil {
return "", err
}
sig := base64Encode(b)
return fmt.Sprintf("%s.%s", ss, sig), nil
} | go | func Encode(header *Header, c *ClaimSet, signature *rsa.PrivateKey) (string, error) {
head, err := header.encode()
if err != nil {
return "", err
}
cs, err := c.encode()
if err != nil {
return "", err
}
ss := fmt.Sprintf("%s.%s", head, cs)
h := sha256.New()
h.Write([]byte(ss))
b, err := rsa.SignPKCS1v15(rand.Reader, signature, crypto.SHA256, h.Sum(nil))
if err != nil {
return "", err
}
sig := base64Encode(b)
return fmt.Sprintf("%s.%s", ss, sig), nil
} | [
"func",
"Encode",
"(",
"header",
"*",
"Header",
",",
"c",
"*",
"ClaimSet",
",",
"signature",
"*",
"rsa",
".",
"PrivateKey",
")",
"(",
"string",
",",
"error",
")",
"{",
"head",
",",
"err",
":=",
"header",
".",
"encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"cs",
",",
"err",
":=",
"c",
".",
"encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"ss",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"head",
",",
"cs",
")",
"\n",
"h",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"ss",
")",
")",
"\n",
"b",
",",
"err",
":=",
"rsa",
".",
"SignPKCS1v15",
"(",
"rand",
".",
"Reader",
",",
"signature",
",",
"crypto",
".",
"SHA256",
",",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"sig",
":=",
"base64Encode",
"(",
"b",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ss",
",",
"sig",
")",
",",
"nil",
"\n",
"}"
] | // Encode encodes a signed JWS with provided header and claim set. | [
"Encode",
"encodes",
"a",
"signed",
"JWS",
"with",
"provided",
"header",
"and",
"claim",
"set",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/release-notes/Godeps/_workspace/src/golang.org/x/oauth2/jws/jws.go#L124-L142 | train |
kubernetes-retired/contrib | release-notes/Godeps/_workspace/src/golang.org/x/oauth2/jws/jws.go | base64Decode | func base64Decode(s string) ([]byte, error) {
// add back missing padding
switch len(s) % 4 {
case 2:
s += "=="
case 3:
s += "="
}
return base64.URLEncoding.DecodeString(s)
} | go | func base64Decode(s string) ([]byte, error) {
// add back missing padding
switch len(s) % 4 {
case 2:
s += "=="
case 3:
s += "="
}
return base64.URLEncoding.DecodeString(s)
} | [
"func",
"base64Decode",
"(",
"s",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// add back missing padding",
"switch",
"len",
"(",
"s",
")",
"%",
"4",
"{",
"case",
"2",
":",
"s",
"+=",
"\"",
"\"",
"\n",
"case",
"3",
":",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"base64",
".",
"URLEncoding",
".",
"DecodeString",
"(",
"s",
")",
"\n",
"}"
] | // base64Decode decodes the Base64url encoded string | [
"base64Decode",
"decodes",
"the",
"Base64url",
"encoded",
"string"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/release-notes/Godeps/_workspace/src/golang.org/x/oauth2/jws/jws.go#L151-L160 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go | IntoSingular | func (r *Result) IntoSingular(b *bool) *Result {
*b = r.singular
return r
} | go | func (r *Result) IntoSingular(b *bool) *Result {
*b = r.singular
return r
} | [
"func",
"(",
"r",
"*",
"Result",
")",
"IntoSingular",
"(",
"b",
"*",
"bool",
")",
"*",
"Result",
"{",
"*",
"b",
"=",
"r",
".",
"singular",
"\n",
"return",
"r",
"\n",
"}"
] | // IntoSingular sets the provided boolean pointer to true if the Builder input
// reflected a single item, or multiple. | [
"IntoSingular",
"sets",
"the",
"provided",
"boolean",
"pointer",
"to",
"true",
"if",
"the",
"Builder",
"input",
"reflected",
"a",
"single",
"item",
"or",
"multiple",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go#L85-L88 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go | AsVersionedObject | func AsVersionedObject(infos []*Info, forceList bool, version string, encoder runtime.Encoder) (runtime.Object, error) {
objects, err := AsVersionedObjects(infos, version, encoder)
if err != nil {
return nil, err
}
var object runtime.Object
if len(objects) == 1 && !forceList {
object = objects[0]
} else {
object = &api.List{Items: objects}
converted, err := tryConvert(api.Scheme, object, version, registered.GroupOrDie(api.GroupName).GroupVersion.Version)
if err != nil {
return nil, err
}
object = converted
}
return object, nil
} | go | func AsVersionedObject(infos []*Info, forceList bool, version string, encoder runtime.Encoder) (runtime.Object, error) {
objects, err := AsVersionedObjects(infos, version, encoder)
if err != nil {
return nil, err
}
var object runtime.Object
if len(objects) == 1 && !forceList {
object = objects[0]
} else {
object = &api.List{Items: objects}
converted, err := tryConvert(api.Scheme, object, version, registered.GroupOrDie(api.GroupName).GroupVersion.Version)
if err != nil {
return nil, err
}
object = converted
}
return object, nil
} | [
"func",
"AsVersionedObject",
"(",
"infos",
"[",
"]",
"*",
"Info",
",",
"forceList",
"bool",
",",
"version",
"string",
",",
"encoder",
"runtime",
".",
"Encoder",
")",
"(",
"runtime",
".",
"Object",
",",
"error",
")",
"{",
"objects",
",",
"err",
":=",
"AsVersionedObjects",
"(",
"infos",
",",
"version",
",",
"encoder",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"object",
"runtime",
".",
"Object",
"\n",
"if",
"len",
"(",
"objects",
")",
"==",
"1",
"&&",
"!",
"forceList",
"{",
"object",
"=",
"objects",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"object",
"=",
"&",
"api",
".",
"List",
"{",
"Items",
":",
"objects",
"}",
"\n",
"converted",
",",
"err",
":=",
"tryConvert",
"(",
"api",
".",
"Scheme",
",",
"object",
",",
"version",
",",
"registered",
".",
"GroupOrDie",
"(",
"api",
".",
"GroupName",
")",
".",
"GroupVersion",
".",
"Version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"object",
"=",
"converted",
"\n",
"}",
"\n",
"return",
"object",
",",
"nil",
"\n",
"}"
] | // AsVersionedObject converts a list of infos into a single object - either a List containing
// the objects as children, or if only a single Object is present, as that object. The provided
// version will be preferred as the conversion target, but the Object's mapping version will be
// used if that version is not present. | [
"AsVersionedObject",
"converts",
"a",
"list",
"of",
"infos",
"into",
"a",
"single",
"object",
"-",
"either",
"a",
"List",
"containing",
"the",
"objects",
"as",
"children",
"or",
"if",
"only",
"a",
"single",
"Object",
"is",
"present",
"as",
"that",
"object",
".",
"The",
"provided",
"version",
"will",
"be",
"preferred",
"as",
"the",
"conversion",
"target",
"but",
"the",
"Object",
"s",
"mapping",
"version",
"will",
"be",
"used",
"if",
"that",
"version",
"is",
"not",
"present",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go#L213-L231 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go | AsVersionedObjects | func AsVersionedObjects(infos []*Info, version string, encoder runtime.Encoder) ([]runtime.Object, error) {
objects := []runtime.Object{}
for _, info := range infos {
if info.Object == nil {
continue
}
// TODO: use info.VersionedObject as the value?
// objects that are not part of api.Scheme must be converted to JSON
// TODO: convert to map[string]interface{}, attach to runtime.Unknown?
if len(version) > 0 {
if _, err := api.Scheme.ObjectKind(info.Object); runtime.IsNotRegisteredError(err) {
// TODO: ideally this would encode to version, but we don't expose multiple codecs here.
data, err := runtime.Encode(encoder, info.Object)
if err != nil {
return nil, err
}
objects = append(objects, &runtime.Unknown{RawJSON: data})
continue
}
}
converted, err := tryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.GroupVersionKind.GroupVersion().String())
if err != nil {
return nil, err
}
objects = append(objects, converted)
}
return objects, nil
} | go | func AsVersionedObjects(infos []*Info, version string, encoder runtime.Encoder) ([]runtime.Object, error) {
objects := []runtime.Object{}
for _, info := range infos {
if info.Object == nil {
continue
}
// TODO: use info.VersionedObject as the value?
// objects that are not part of api.Scheme must be converted to JSON
// TODO: convert to map[string]interface{}, attach to runtime.Unknown?
if len(version) > 0 {
if _, err := api.Scheme.ObjectKind(info.Object); runtime.IsNotRegisteredError(err) {
// TODO: ideally this would encode to version, but we don't expose multiple codecs here.
data, err := runtime.Encode(encoder, info.Object)
if err != nil {
return nil, err
}
objects = append(objects, &runtime.Unknown{RawJSON: data})
continue
}
}
converted, err := tryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.GroupVersionKind.GroupVersion().String())
if err != nil {
return nil, err
}
objects = append(objects, converted)
}
return objects, nil
} | [
"func",
"AsVersionedObjects",
"(",
"infos",
"[",
"]",
"*",
"Info",
",",
"version",
"string",
",",
"encoder",
"runtime",
".",
"Encoder",
")",
"(",
"[",
"]",
"runtime",
".",
"Object",
",",
"error",
")",
"{",
"objects",
":=",
"[",
"]",
"runtime",
".",
"Object",
"{",
"}",
"\n",
"for",
"_",
",",
"info",
":=",
"range",
"infos",
"{",
"if",
"info",
".",
"Object",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"// TODO: use info.VersionedObject as the value?",
"// objects that are not part of api.Scheme must be converted to JSON",
"// TODO: convert to map[string]interface{}, attach to runtime.Unknown?",
"if",
"len",
"(",
"version",
")",
">",
"0",
"{",
"if",
"_",
",",
"err",
":=",
"api",
".",
"Scheme",
".",
"ObjectKind",
"(",
"info",
".",
"Object",
")",
";",
"runtime",
".",
"IsNotRegisteredError",
"(",
"err",
")",
"{",
"// TODO: ideally this would encode to version, but we don't expose multiple codecs here.",
"data",
",",
"err",
":=",
"runtime",
".",
"Encode",
"(",
"encoder",
",",
"info",
".",
"Object",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"objects",
"=",
"append",
"(",
"objects",
",",
"&",
"runtime",
".",
"Unknown",
"{",
"RawJSON",
":",
"data",
"}",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n\n",
"converted",
",",
"err",
":=",
"tryConvert",
"(",
"info",
".",
"Mapping",
".",
"ObjectConvertor",
",",
"info",
".",
"Object",
",",
"version",
",",
"info",
".",
"Mapping",
".",
"GroupVersionKind",
".",
"GroupVersion",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"objects",
"=",
"append",
"(",
"objects",
",",
"converted",
")",
"\n",
"}",
"\n",
"return",
"objects",
",",
"nil",
"\n",
"}"
] | // AsVersionedObjects converts a list of infos into versioned objects. The provided
// version will be preferred as the conversion target, but the Object's mapping version will be
// used if that version is not present. | [
"AsVersionedObjects",
"converts",
"a",
"list",
"of",
"infos",
"into",
"versioned",
"objects",
".",
"The",
"provided",
"version",
"will",
"be",
"preferred",
"as",
"the",
"conversion",
"target",
"but",
"the",
"Object",
"s",
"mapping",
"version",
"will",
"be",
"used",
"if",
"that",
"version",
"is",
"not",
"present",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/result.go#L236-L266 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | StandardErrorMessage | func StandardErrorMessage(err error) (string, bool) {
if debugErr, ok := err.(debugError); ok {
glog.V(4).Infof(debugErr.DebugError())
}
_, isStatus := err.(errors.APIStatus)
switch {
case isStatus:
return fmt.Sprintf("Error from server: %s", err.Error()), true
case errors.IsUnexpectedObjectError(err):
return fmt.Sprintf("Server returned an unexpected response: %s", err.Error()), true
}
switch t := err.(type) {
case *url.Error:
glog.V(4).Infof("Connection error: %s %s: %v", t.Op, t.URL, t.Err)
switch {
case strings.Contains(t.Err.Error(), "connection refused"):
host := t.URL
if server, err := url.Parse(t.URL); err == nil {
host = server.Host
}
return fmt.Sprintf("The connection to the server %s was refused - did you specify the right host or port?", host), true
}
return fmt.Sprintf("Unable to connect to the server: %v", t.Err), true
}
return "", false
} | go | func StandardErrorMessage(err error) (string, bool) {
if debugErr, ok := err.(debugError); ok {
glog.V(4).Infof(debugErr.DebugError())
}
_, isStatus := err.(errors.APIStatus)
switch {
case isStatus:
return fmt.Sprintf("Error from server: %s", err.Error()), true
case errors.IsUnexpectedObjectError(err):
return fmt.Sprintf("Server returned an unexpected response: %s", err.Error()), true
}
switch t := err.(type) {
case *url.Error:
glog.V(4).Infof("Connection error: %s %s: %v", t.Op, t.URL, t.Err)
switch {
case strings.Contains(t.Err.Error(), "connection refused"):
host := t.URL
if server, err := url.Parse(t.URL); err == nil {
host = server.Host
}
return fmt.Sprintf("The connection to the server %s was refused - did you specify the right host or port?", host), true
}
return fmt.Sprintf("Unable to connect to the server: %v", t.Err), true
}
return "", false
} | [
"func",
"StandardErrorMessage",
"(",
"err",
"error",
")",
"(",
"string",
",",
"bool",
")",
"{",
"if",
"debugErr",
",",
"ok",
":=",
"err",
".",
"(",
"debugError",
")",
";",
"ok",
"{",
"glog",
".",
"V",
"(",
"4",
")",
".",
"Infof",
"(",
"debugErr",
".",
"DebugError",
"(",
")",
")",
"\n",
"}",
"\n",
"_",
",",
"isStatus",
":=",
"err",
".",
"(",
"errors",
".",
"APIStatus",
")",
"\n",
"switch",
"{",
"case",
"isStatus",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
",",
"true",
"\n",
"case",
"errors",
".",
"IsUnexpectedObjectError",
"(",
"err",
")",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
",",
"true",
"\n",
"}",
"\n",
"switch",
"t",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"url",
".",
"Error",
":",
"glog",
".",
"V",
"(",
"4",
")",
".",
"Infof",
"(",
"\"",
"\"",
",",
"t",
".",
"Op",
",",
"t",
".",
"URL",
",",
"t",
".",
"Err",
")",
"\n",
"switch",
"{",
"case",
"strings",
".",
"Contains",
"(",
"t",
".",
"Err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
":",
"host",
":=",
"t",
".",
"URL",
"\n",
"if",
"server",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"t",
".",
"URL",
")",
";",
"err",
"==",
"nil",
"{",
"host",
"=",
"server",
".",
"Host",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"host",
")",
",",
"true",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Err",
")",
",",
"true",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}"
] | // StandardErrorMessage translates common errors into a human readable message, or returns
// false if the error is not one of the recognized types. It may also log extended
// information to glog.
//
// This method is generic to the command in use and may be used by non-Kubectl
// commands. | [
"StandardErrorMessage",
"translates",
"common",
"errors",
"into",
"a",
"human",
"readable",
"message",
"or",
"returns",
"false",
"if",
"the",
"error",
"is",
"not",
"one",
"of",
"the",
"recognized",
"types",
".",
"It",
"may",
"also",
"log",
"extended",
"information",
"to",
"glog",
".",
"This",
"method",
"is",
"generic",
"to",
"the",
"command",
"in",
"use",
"and",
"may",
"be",
"used",
"by",
"non",
"-",
"Kubectl",
"commands",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L170-L195 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | isWatch | func isWatch(cmd *cobra.Command) bool {
if w, err := cmd.Flags().GetBool("watch"); w && err == nil {
return true
}
if wo, err := cmd.Flags().GetBool("watch-only"); wo && err == nil {
return true
}
return false
} | go | func isWatch(cmd *cobra.Command) bool {
if w, err := cmd.Flags().GetBool("watch"); w && err == nil {
return true
}
if wo, err := cmd.Flags().GetBool("watch-only"); wo && err == nil {
return true
}
return false
} | [
"func",
"isWatch",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
")",
"bool",
"{",
"if",
"w",
",",
"err",
":=",
"cmd",
".",
"Flags",
"(",
")",
".",
"GetBool",
"(",
"\"",
"\"",
")",
";",
"w",
"&&",
"err",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"if",
"wo",
",",
"err",
":=",
"cmd",
".",
"Flags",
"(",
")",
".",
"GetBool",
"(",
"\"",
"\"",
")",
";",
"wo",
"&&",
"err",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Whether this cmd need watching objects. | [
"Whether",
"this",
"cmd",
"need",
"watching",
"objects",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L244-L254 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | GetWideFlag | func GetWideFlag(cmd *cobra.Command) bool {
f := cmd.Flags().Lookup("output")
if f.Value.String() == "wide" {
return true
}
return false
} | go | func GetWideFlag(cmd *cobra.Command) bool {
f := cmd.Flags().Lookup("output")
if f.Value.String() == "wide" {
return true
}
return false
} | [
"func",
"GetWideFlag",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
")",
"bool",
"{",
"f",
":=",
"cmd",
".",
"Flags",
"(",
")",
".",
"Lookup",
"(",
"\"",
"\"",
")",
"\n",
"if",
"f",
".",
"Value",
".",
"String",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // GetWideFlag is used to determine if "-o wide" is used | [
"GetWideFlag",
"is",
"used",
"to",
"determine",
"if",
"-",
"o",
"wide",
"is",
"used"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L282-L288 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | UpdateObject | func UpdateObject(info *resource.Info, codec runtime.Codec, updateFn func(runtime.Object) error) (runtime.Object, error) {
helper := resource.NewHelper(info.Client, info.Mapping)
if err := updateFn(info.Object); err != nil {
return nil, err
}
// Update the annotation used by kubectl apply
if err := kubectl.UpdateApplyAnnotation(info, codec); err != nil {
return nil, err
}
if _, err := helper.Replace(info.Namespace, info.Name, true, info.Object); err != nil {
return nil, err
}
return info.Object, nil
} | go | func UpdateObject(info *resource.Info, codec runtime.Codec, updateFn func(runtime.Object) error) (runtime.Object, error) {
helper := resource.NewHelper(info.Client, info.Mapping)
if err := updateFn(info.Object); err != nil {
return nil, err
}
// Update the annotation used by kubectl apply
if err := kubectl.UpdateApplyAnnotation(info, codec); err != nil {
return nil, err
}
if _, err := helper.Replace(info.Namespace, info.Name, true, info.Object); err != nil {
return nil, err
}
return info.Object, nil
} | [
"func",
"UpdateObject",
"(",
"info",
"*",
"resource",
".",
"Info",
",",
"codec",
"runtime",
".",
"Codec",
",",
"updateFn",
"func",
"(",
"runtime",
".",
"Object",
")",
"error",
")",
"(",
"runtime",
".",
"Object",
",",
"error",
")",
"{",
"helper",
":=",
"resource",
".",
"NewHelper",
"(",
"info",
".",
"Client",
",",
"info",
".",
"Mapping",
")",
"\n\n",
"if",
"err",
":=",
"updateFn",
"(",
"info",
".",
"Object",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Update the annotation used by kubectl apply",
"if",
"err",
":=",
"kubectl",
".",
"UpdateApplyAnnotation",
"(",
"info",
",",
"codec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"helper",
".",
"Replace",
"(",
"info",
".",
"Namespace",
",",
"info",
".",
"Name",
",",
"true",
",",
"info",
".",
"Object",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"info",
".",
"Object",
",",
"nil",
"\n",
"}"
] | // UpdateObject updates resource object with updateFn | [
"UpdateObject",
"updates",
"resource",
"object",
"with",
"updateFn"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L437-L454 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | RecordChangeCause | func RecordChangeCause(obj runtime.Object, changeCause string) error {
meta, err := api.ObjectMetaFor(obj)
if err != nil {
return err
}
if meta.Annotations == nil {
meta.Annotations = make(map[string]string)
}
meta.Annotations[kubectl.ChangeCauseAnnotation] = changeCause
return nil
} | go | func RecordChangeCause(obj runtime.Object, changeCause string) error {
meta, err := api.ObjectMetaFor(obj)
if err != nil {
return err
}
if meta.Annotations == nil {
meta.Annotations = make(map[string]string)
}
meta.Annotations[kubectl.ChangeCauseAnnotation] = changeCause
return nil
} | [
"func",
"RecordChangeCause",
"(",
"obj",
"runtime",
".",
"Object",
",",
"changeCause",
"string",
")",
"error",
"{",
"meta",
",",
"err",
":=",
"api",
".",
"ObjectMetaFor",
"(",
"obj",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"meta",
".",
"Annotations",
"==",
"nil",
"{",
"meta",
".",
"Annotations",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"}",
"\n",
"meta",
".",
"Annotations",
"[",
"kubectl",
".",
"ChangeCauseAnnotation",
"]",
"=",
"changeCause",
"\n",
"return",
"nil",
"\n",
"}"
] | // RecordChangeCause annotate change-cause to input runtime object. | [
"RecordChangeCause",
"annotate",
"change",
"-",
"cause",
"to",
"input",
"runtime",
"object",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L466-L476 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | ChangeResourcePatch | func ChangeResourcePatch(info *resource.Info, changeCause string) ([]byte, error) {
oldData, err := json.Marshal(info.Object)
if err != nil {
return nil, err
}
if err := RecordChangeCause(info.Object, changeCause); err != nil {
return nil, err
}
newData, err := json.Marshal(info.Object)
if err != nil {
return nil, err
}
return strategicpatch.CreateTwoWayMergePatch(oldData, newData, info.Object)
} | go | func ChangeResourcePatch(info *resource.Info, changeCause string) ([]byte, error) {
oldData, err := json.Marshal(info.Object)
if err != nil {
return nil, err
}
if err := RecordChangeCause(info.Object, changeCause); err != nil {
return nil, err
}
newData, err := json.Marshal(info.Object)
if err != nil {
return nil, err
}
return strategicpatch.CreateTwoWayMergePatch(oldData, newData, info.Object)
} | [
"func",
"ChangeResourcePatch",
"(",
"info",
"*",
"resource",
".",
"Info",
",",
"changeCause",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"oldData",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"info",
".",
"Object",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"RecordChangeCause",
"(",
"info",
".",
"Object",
",",
"changeCause",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"newData",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"info",
".",
"Object",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"strategicpatch",
".",
"CreateTwoWayMergePatch",
"(",
"oldData",
",",
"newData",
",",
"info",
".",
"Object",
")",
"\n",
"}"
] | // ChangeResourcePatch creates a strategic merge patch between the origin input resource info
// and the annotated with change-cause input resource info. | [
"ChangeResourcePatch",
"creates",
"a",
"strategic",
"merge",
"patch",
"between",
"the",
"origin",
"input",
"resource",
"info",
"and",
"the",
"annotated",
"with",
"change",
"-",
"cause",
"input",
"resource",
"info",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L480-L493 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | ContainsChangeCause | func ContainsChangeCause(info *resource.Info) bool {
annotations, err := info.Mapping.MetadataAccessor.Annotations(info.Object)
if err != nil {
return false
}
return len(annotations[kubectl.ChangeCauseAnnotation]) > 0
} | go | func ContainsChangeCause(info *resource.Info) bool {
annotations, err := info.Mapping.MetadataAccessor.Annotations(info.Object)
if err != nil {
return false
}
return len(annotations[kubectl.ChangeCauseAnnotation]) > 0
} | [
"func",
"ContainsChangeCause",
"(",
"info",
"*",
"resource",
".",
"Info",
")",
"bool",
"{",
"annotations",
",",
"err",
":=",
"info",
".",
"Mapping",
".",
"MetadataAccessor",
".",
"Annotations",
"(",
"info",
".",
"Object",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"len",
"(",
"annotations",
"[",
"kubectl",
".",
"ChangeCauseAnnotation",
"]",
")",
">",
"0",
"\n",
"}"
] | // containsChangeCause checks if input resource info contains change-cause annotation. | [
"containsChangeCause",
"checks",
"if",
"input",
"resource",
"info",
"contains",
"change",
"-",
"cause",
"annotation",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L496-L502 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go | ShouldRecord | func ShouldRecord(cmd *cobra.Command, info *resource.Info) bool {
return GetRecordFlag(cmd) || ContainsChangeCause(info)
} | go | func ShouldRecord(cmd *cobra.Command, info *resource.Info) bool {
return GetRecordFlag(cmd) || ContainsChangeCause(info)
} | [
"func",
"ShouldRecord",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"info",
"*",
"resource",
".",
"Info",
")",
"bool",
"{",
"return",
"GetRecordFlag",
"(",
"cmd",
")",
"||",
"ContainsChangeCause",
"(",
"info",
")",
"\n",
"}"
] | // ShouldRecord checks if we should record current change cause | [
"ShouldRecord",
"checks",
"if",
"we",
"should",
"record",
"current",
"change",
"cause"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/cmd/util/helpers.go#L505-L507 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go | newBuffer | func newBuffer() *buffer {
e := new(element)
b := &buffer{
Cond: newCond(),
head: e,
tail: e,
}
return b
} | go | func newBuffer() *buffer {
e := new(element)
b := &buffer{
Cond: newCond(),
head: e,
tail: e,
}
return b
} | [
"func",
"newBuffer",
"(",
")",
"*",
"buffer",
"{",
"e",
":=",
"new",
"(",
"element",
")",
"\n",
"b",
":=",
"&",
"buffer",
"{",
"Cond",
":",
"newCond",
"(",
")",
",",
"head",
":",
"e",
",",
"tail",
":",
"e",
",",
"}",
"\n",
"return",
"b",
"\n",
"}"
] | // newBuffer returns an empty buffer that is not closed. | [
"newBuffer",
"returns",
"an",
"empty",
"buffer",
"that",
"is",
"not",
"closed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go#L32-L40 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go | write | func (b *buffer) write(buf []byte) {
b.Cond.L.Lock()
e := &element{buf: buf}
b.tail.next = e
b.tail = e
b.Cond.Signal()
b.Cond.L.Unlock()
} | go | func (b *buffer) write(buf []byte) {
b.Cond.L.Lock()
e := &element{buf: buf}
b.tail.next = e
b.tail = e
b.Cond.Signal()
b.Cond.L.Unlock()
} | [
"func",
"(",
"b",
"*",
"buffer",
")",
"write",
"(",
"buf",
"[",
"]",
"byte",
")",
"{",
"b",
".",
"Cond",
".",
"L",
".",
"Lock",
"(",
")",
"\n",
"e",
":=",
"&",
"element",
"{",
"buf",
":",
"buf",
"}",
"\n",
"b",
".",
"tail",
".",
"next",
"=",
"e",
"\n",
"b",
".",
"tail",
"=",
"e",
"\n",
"b",
".",
"Cond",
".",
"Signal",
"(",
")",
"\n",
"b",
".",
"Cond",
".",
"L",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // write makes buf available for Read to receive.
// buf must not be modified after the call to write. | [
"write",
"makes",
"buf",
"available",
"for",
"Read",
"to",
"receive",
".",
"buf",
"must",
"not",
"be",
"modified",
"after",
"the",
"call",
"to",
"write",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go#L44-L51 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go | eof | func (b *buffer) eof() error {
b.Cond.L.Lock()
b.closed = true
b.Cond.Signal()
b.Cond.L.Unlock()
return nil
} | go | func (b *buffer) eof() error {
b.Cond.L.Lock()
b.closed = true
b.Cond.Signal()
b.Cond.L.Unlock()
return nil
} | [
"func",
"(",
"b",
"*",
"buffer",
")",
"eof",
"(",
")",
"error",
"{",
"b",
".",
"Cond",
".",
"L",
".",
"Lock",
"(",
")",
"\n",
"b",
".",
"closed",
"=",
"true",
"\n",
"b",
".",
"Cond",
".",
"Signal",
"(",
")",
"\n",
"b",
".",
"Cond",
".",
"L",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // eof closes the buffer. Reads from the buffer once all
// the data has been consumed will receive os.EOF. | [
"eof",
"closes",
"the",
"buffer",
".",
"Reads",
"from",
"the",
"buffer",
"once",
"all",
"the",
"data",
"has",
"been",
"consumed",
"will",
"receive",
"os",
".",
"EOF",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go#L55-L61 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go | Read | func (b *buffer) Read(buf []byte) (n int, err error) {
b.Cond.L.Lock()
defer b.Cond.L.Unlock()
for len(buf) > 0 {
// if there is data in b.head, copy it
if len(b.head.buf) > 0 {
r := copy(buf, b.head.buf)
buf, b.head.buf = buf[r:], b.head.buf[r:]
n += r
continue
}
// if there is a next buffer, make it the head
if len(b.head.buf) == 0 && b.head != b.tail {
b.head = b.head.next
continue
}
// if at least one byte has been copied, return
if n > 0 {
break
}
// if nothing was read, and there is nothing outstanding
// check to see if the buffer is closed.
if b.closed {
err = io.EOF
break
}
// out of buffers, wait for producer
b.Cond.Wait()
}
return
} | go | func (b *buffer) Read(buf []byte) (n int, err error) {
b.Cond.L.Lock()
defer b.Cond.L.Unlock()
for len(buf) > 0 {
// if there is data in b.head, copy it
if len(b.head.buf) > 0 {
r := copy(buf, b.head.buf)
buf, b.head.buf = buf[r:], b.head.buf[r:]
n += r
continue
}
// if there is a next buffer, make it the head
if len(b.head.buf) == 0 && b.head != b.tail {
b.head = b.head.next
continue
}
// if at least one byte has been copied, return
if n > 0 {
break
}
// if nothing was read, and there is nothing outstanding
// check to see if the buffer is closed.
if b.closed {
err = io.EOF
break
}
// out of buffers, wait for producer
b.Cond.Wait()
}
return
} | [
"func",
"(",
"b",
"*",
"buffer",
")",
"Read",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"b",
".",
"Cond",
".",
"L",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"Cond",
".",
"L",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"len",
"(",
"buf",
")",
">",
"0",
"{",
"// if there is data in b.head, copy it",
"if",
"len",
"(",
"b",
".",
"head",
".",
"buf",
")",
">",
"0",
"{",
"r",
":=",
"copy",
"(",
"buf",
",",
"b",
".",
"head",
".",
"buf",
")",
"\n",
"buf",
",",
"b",
".",
"head",
".",
"buf",
"=",
"buf",
"[",
"r",
":",
"]",
",",
"b",
".",
"head",
".",
"buf",
"[",
"r",
":",
"]",
"\n",
"n",
"+=",
"r",
"\n",
"continue",
"\n",
"}",
"\n",
"// if there is a next buffer, make it the head",
"if",
"len",
"(",
"b",
".",
"head",
".",
"buf",
")",
"==",
"0",
"&&",
"b",
".",
"head",
"!=",
"b",
".",
"tail",
"{",
"b",
".",
"head",
"=",
"b",
".",
"head",
".",
"next",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// if at least one byte has been copied, return",
"if",
"n",
">",
"0",
"{",
"break",
"\n",
"}",
"\n\n",
"// if nothing was read, and there is nothing outstanding",
"// check to see if the buffer is closed.",
"if",
"b",
".",
"closed",
"{",
"err",
"=",
"io",
".",
"EOF",
"\n",
"break",
"\n",
"}",
"\n",
"// out of buffers, wait for producer",
"b",
".",
"Cond",
".",
"Wait",
"(",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Read reads data from the internal buffer in buf. Reads will block
// if no data is available, or until the buffer is closed. | [
"Read",
"reads",
"data",
"from",
"the",
"internal",
"buffer",
"in",
"buf",
".",
"Reads",
"will",
"block",
"if",
"no",
"data",
"is",
"available",
"or",
"until",
"the",
"buffer",
"is",
"closed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/buffer.go#L65-L98 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go | ValidateHorizontalPodAutoscalerName | func ValidateHorizontalPodAutoscalerName(name string, prefix bool) (bool, string) {
// TODO: finally move it to pkg/api/validation and use nameIsDNSSubdomain function
return apivalidation.ValidateReplicationControllerName(name, prefix)
} | go | func ValidateHorizontalPodAutoscalerName(name string, prefix bool) (bool, string) {
// TODO: finally move it to pkg/api/validation and use nameIsDNSSubdomain function
return apivalidation.ValidateReplicationControllerName(name, prefix)
} | [
"func",
"ValidateHorizontalPodAutoscalerName",
"(",
"name",
"string",
",",
"prefix",
"bool",
")",
"(",
"bool",
",",
"string",
")",
"{",
"// TODO: finally move it to pkg/api/validation and use nameIsDNSSubdomain function",
"return",
"apivalidation",
".",
"ValidateReplicationControllerName",
"(",
"name",
",",
"prefix",
")",
"\n",
"}"
] | // ValidateHorizontalPodAutoscaler can be used to check whether the given autoscaler name is valid.
// Prefix indicates this name will be used as part of generation, in which case trailing dashes are allowed. | [
"ValidateHorizontalPodAutoscaler",
"can",
"be",
"used",
"to",
"check",
"whether",
"the",
"given",
"autoscaler",
"name",
"is",
"valid",
".",
"Prefix",
"indicates",
"this",
"name",
"will",
"be",
"used",
"as",
"part",
"of",
"generation",
"in",
"which",
"case",
"trailing",
"dashes",
"are",
"allowed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go#L38-L41 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go | ValidateDaemonSetName | func ValidateDaemonSetName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | go | func ValidateDaemonSetName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | [
"func",
"ValidateDaemonSetName",
"(",
"name",
"string",
",",
"prefix",
"bool",
")",
"(",
"bool",
",",
"string",
")",
"{",
"return",
"apivalidation",
".",
"NameIsDNSSubdomain",
"(",
"name",
",",
"prefix",
")",
"\n",
"}"
] | // ValidateDaemonSetName can be used to check whether the given daemon set name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed. | [
"ValidateDaemonSetName",
"can",
"be",
"used",
"to",
"check",
"whether",
"the",
"given",
"daemon",
"set",
"name",
"is",
"valid",
".",
"Prefix",
"indicates",
"this",
"name",
"will",
"be",
"used",
"as",
"part",
"of",
"generation",
"in",
"which",
"case",
"trailing",
"dashes",
"are",
"allowed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go#L212-L214 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go | ValidateDeploymentName | func ValidateDeploymentName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | go | func ValidateDeploymentName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | [
"func",
"ValidateDeploymentName",
"(",
"name",
"string",
",",
"prefix",
"bool",
")",
"(",
"bool",
",",
"string",
")",
"{",
"return",
"apivalidation",
".",
"NameIsDNSSubdomain",
"(",
"name",
",",
"prefix",
")",
"\n",
"}"
] | // Validates that the given name can be used as a deployment name. | [
"Validates",
"that",
"the",
"given",
"name",
"can",
"be",
"used",
"as",
"a",
"deployment",
"name",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go#L217-L219 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go | ValidateDeploymentSpec | func ValidateDeploymentSpec(spec *extensions.DeploymentSpec, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
allErrs = append(allErrs, apivalidation.ValidateNonEmptySelector(spec.Selector, fldPath.Child("selector"))...)
allErrs = append(allErrs, apivalidation.ValidatePositiveField(int64(spec.Replicas), fldPath.Child("replicas"))...)
allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpecForRC(&spec.Template, spec.Selector, spec.Replicas, fldPath.Child("template"))...)
allErrs = append(allErrs, ValidateDeploymentStrategy(&spec.Strategy, fldPath.Child("strategy"))...)
// empty string is a valid UniqueLabelKey
if len(spec.UniqueLabelKey) > 0 {
allErrs = append(allErrs, apivalidation.ValidateLabelName(spec.UniqueLabelKey, fldPath.Child("uniqueLabel"))...)
}
return allErrs
} | go | func ValidateDeploymentSpec(spec *extensions.DeploymentSpec, fldPath *field.Path) field.ErrorList {
allErrs := field.ErrorList{}
allErrs = append(allErrs, apivalidation.ValidateNonEmptySelector(spec.Selector, fldPath.Child("selector"))...)
allErrs = append(allErrs, apivalidation.ValidatePositiveField(int64(spec.Replicas), fldPath.Child("replicas"))...)
allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpecForRC(&spec.Template, spec.Selector, spec.Replicas, fldPath.Child("template"))...)
allErrs = append(allErrs, ValidateDeploymentStrategy(&spec.Strategy, fldPath.Child("strategy"))...)
// empty string is a valid UniqueLabelKey
if len(spec.UniqueLabelKey) > 0 {
allErrs = append(allErrs, apivalidation.ValidateLabelName(spec.UniqueLabelKey, fldPath.Child("uniqueLabel"))...)
}
return allErrs
} | [
"func",
"ValidateDeploymentSpec",
"(",
"spec",
"*",
"extensions",
".",
"DeploymentSpec",
",",
"fldPath",
"*",
"field",
".",
"Path",
")",
"field",
".",
"ErrorList",
"{",
"allErrs",
":=",
"field",
".",
"ErrorList",
"{",
"}",
"\n",
"allErrs",
"=",
"append",
"(",
"allErrs",
",",
"apivalidation",
".",
"ValidateNonEmptySelector",
"(",
"spec",
".",
"Selector",
",",
"fldPath",
".",
"Child",
"(",
"\"",
"\"",
")",
")",
"...",
")",
"\n",
"allErrs",
"=",
"append",
"(",
"allErrs",
",",
"apivalidation",
".",
"ValidatePositiveField",
"(",
"int64",
"(",
"spec",
".",
"Replicas",
")",
",",
"fldPath",
".",
"Child",
"(",
"\"",
"\"",
")",
")",
"...",
")",
"\n",
"allErrs",
"=",
"append",
"(",
"allErrs",
",",
"apivalidation",
".",
"ValidatePodTemplateSpecForRC",
"(",
"&",
"spec",
".",
"Template",
",",
"spec",
".",
"Selector",
",",
"spec",
".",
"Replicas",
",",
"fldPath",
".",
"Child",
"(",
"\"",
"\"",
")",
")",
"...",
")",
"\n",
"allErrs",
"=",
"append",
"(",
"allErrs",
",",
"ValidateDeploymentStrategy",
"(",
"&",
"spec",
".",
"Strategy",
",",
"fldPath",
".",
"Child",
"(",
"\"",
"\"",
")",
")",
"...",
")",
"\n",
"// empty string is a valid UniqueLabelKey",
"if",
"len",
"(",
"spec",
".",
"UniqueLabelKey",
")",
">",
"0",
"{",
"allErrs",
"=",
"append",
"(",
"allErrs",
",",
"apivalidation",
".",
"ValidateLabelName",
"(",
"spec",
".",
"UniqueLabelKey",
",",
"fldPath",
".",
"Child",
"(",
"\"",
"\"",
")",
")",
"...",
")",
"\n",
"}",
"\n",
"return",
"allErrs",
"\n",
"}"
] | // Validates given deployment spec. | [
"Validates",
"given",
"deployment",
"spec",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go#L288-L299 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go | ValidateIngressName | func ValidateIngressName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | go | func ValidateIngressName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | [
"func",
"ValidateIngressName",
"(",
"name",
"string",
",",
"prefix",
"bool",
")",
"(",
"bool",
",",
"string",
")",
"{",
"return",
"apivalidation",
".",
"NameIsDNSSubdomain",
"(",
"name",
",",
"prefix",
")",
"\n",
"}"
] | // ValidateIngressName validates that the given name can be used as an Ingress name. | [
"ValidateIngressName",
"validates",
"that",
"the",
"given",
"name",
"can",
"be",
"used",
"as",
"an",
"Ingress",
"name",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go#L409-L411 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go | ValidateConfigMapName | func ValidateConfigMapName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | go | func ValidateConfigMapName(name string, prefix bool) (bool, string) {
return apivalidation.NameIsDNSSubdomain(name, prefix)
} | [
"func",
"ValidateConfigMapName",
"(",
"name",
"string",
",",
"prefix",
"bool",
")",
"(",
"bool",
",",
"string",
")",
"{",
"return",
"apivalidation",
".",
"NameIsDNSSubdomain",
"(",
"name",
",",
"prefix",
")",
"\n",
"}"
] | // ValidateConfigMapName can be used to check whether the given ConfigMap name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed. | [
"ValidateConfigMapName",
"can",
"be",
"used",
"to",
"check",
"whether",
"the",
"given",
"ConfigMap",
"name",
"is",
"valid",
".",
"Prefix",
"indicates",
"this",
"name",
"will",
"be",
"used",
"as",
"part",
"of",
"generation",
"in",
"which",
"case",
"trailing",
"dashes",
"are",
"allowed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/apis/extensions/validation/validation.go#L604-L606 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/keyring.go | Lookup | func (dk *BasicDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
// range over the index as iterating over a map does not provide a predictable ordering
ret := []docker.AuthConfiguration{}
for _, k := range dk.index {
// both k and image are schemeless URLs because even though schemes are allowed
// in the credential configurations, we remove them in Add.
if matched, _ := urlsMatchStr(k, image); !matched {
continue
}
ret = append(ret, dk.creds[k]...)
}
if len(ret) > 0 {
return ret, true
}
// Use credentials for the default registry if provided, and appropriate
if isDefaultRegistryMatch(image) {
if auth, ok := dk.creds[defaultRegistryHost]; ok {
return auth, true
}
}
return []docker.AuthConfiguration{}, false
} | go | func (dk *BasicDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
// range over the index as iterating over a map does not provide a predictable ordering
ret := []docker.AuthConfiguration{}
for _, k := range dk.index {
// both k and image are schemeless URLs because even though schemes are allowed
// in the credential configurations, we remove them in Add.
if matched, _ := urlsMatchStr(k, image); !matched {
continue
}
ret = append(ret, dk.creds[k]...)
}
if len(ret) > 0 {
return ret, true
}
// Use credentials for the default registry if provided, and appropriate
if isDefaultRegistryMatch(image) {
if auth, ok := dk.creds[defaultRegistryHost]; ok {
return auth, true
}
}
return []docker.AuthConfiguration{}, false
} | [
"func",
"(",
"dk",
"*",
"BasicDockerKeyring",
")",
"Lookup",
"(",
"image",
"string",
")",
"(",
"[",
"]",
"docker",
".",
"AuthConfiguration",
",",
"bool",
")",
"{",
"// range over the index as iterating over a map does not provide a predictable ordering",
"ret",
":=",
"[",
"]",
"docker",
".",
"AuthConfiguration",
"{",
"}",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"dk",
".",
"index",
"{",
"// both k and image are schemeless URLs because even though schemes are allowed",
"// in the credential configurations, we remove them in Add.",
"if",
"matched",
",",
"_",
":=",
"urlsMatchStr",
"(",
"k",
",",
"image",
")",
";",
"!",
"matched",
"{",
"continue",
"\n",
"}",
"\n\n",
"ret",
"=",
"append",
"(",
"ret",
",",
"dk",
".",
"creds",
"[",
"k",
"]",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"ret",
")",
">",
"0",
"{",
"return",
"ret",
",",
"true",
"\n",
"}",
"\n\n",
"// Use credentials for the default registry if provided, and appropriate",
"if",
"isDefaultRegistryMatch",
"(",
"image",
")",
"{",
"if",
"auth",
",",
"ok",
":=",
"dk",
".",
"creds",
"[",
"defaultRegistryHost",
"]",
";",
"ok",
"{",
"return",
"auth",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"[",
"]",
"docker",
".",
"AuthConfiguration",
"{",
"}",
",",
"false",
"\n",
"}"
] | // Lookup implements the DockerKeyring method for fetching credentials based on image name.
// Multiple credentials may be returned if there are multiple potentially valid credentials
// available. This allows for rotation. | [
"Lookup",
"implements",
"the",
"DockerKeyring",
"method",
"for",
"fetching",
"credentials",
"based",
"on",
"image",
"name",
".",
"Multiple",
"credentials",
"may",
"be",
"returned",
"if",
"there",
"are",
"multiple",
"potentially",
"valid",
"credentials",
"available",
".",
"This",
"allows",
"for",
"rotation",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/keyring.go#L218-L243 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/keyring.go | Lookup | func (dk *lazyDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
keyring := &BasicDockerKeyring{}
for _, p := range dk.Providers {
keyring.Add(p.Provide())
}
return keyring.Lookup(image)
} | go | func (dk *lazyDockerKeyring) Lookup(image string) ([]docker.AuthConfiguration, bool) {
keyring := &BasicDockerKeyring{}
for _, p := range dk.Providers {
keyring.Add(p.Provide())
}
return keyring.Lookup(image)
} | [
"func",
"(",
"dk",
"*",
"lazyDockerKeyring",
")",
"Lookup",
"(",
"image",
"string",
")",
"(",
"[",
"]",
"docker",
".",
"AuthConfiguration",
",",
"bool",
")",
"{",
"keyring",
":=",
"&",
"BasicDockerKeyring",
"{",
"}",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"dk",
".",
"Providers",
"{",
"keyring",
".",
"Add",
"(",
"p",
".",
"Provide",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"keyring",
".",
"Lookup",
"(",
"image",
")",
"\n",
"}"
] | // Lookup implements the DockerKeyring method for fetching credentials
// based on image name. | [
"Lookup",
"implements",
"the",
"DockerKeyring",
"method",
"for",
"fetching",
"credentials",
"based",
"on",
"image",
"name",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/credentialprovider/keyring.go#L247-L255 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/agent/forward.go | RequestAgentForwarding | func RequestAgentForwarding(session *ssh.Session) error {
ok, err := session.SendRequest("[email protected]", true, nil)
if err != nil {
return err
}
if !ok {
return errors.New("forwarding request denied")
}
return nil
} | go | func RequestAgentForwarding(session *ssh.Session) error {
ok, err := session.SendRequest("[email protected]", true, nil)
if err != nil {
return err
}
if !ok {
return errors.New("forwarding request denied")
}
return nil
} | [
"func",
"RequestAgentForwarding",
"(",
"session",
"*",
"ssh",
".",
"Session",
")",
"error",
"{",
"ok",
",",
"err",
":=",
"session",
".",
"SendRequest",
"(",
"\"",
"\"",
",",
"true",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // RequestAgentForwarding sets up agent forwarding for the session.
// ForwardToAgent or ForwardToRemote should be called to route
// the authentication requests. | [
"RequestAgentForwarding",
"sets",
"up",
"agent",
"forwarding",
"for",
"the",
"session",
".",
"ForwardToAgent",
"or",
"ForwardToRemote",
"should",
"be",
"called",
"to",
"route",
"the",
"authentication",
"requests",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/agent/forward.go#L19-L28 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/agent/forward.go | ForwardToAgent | func ForwardToAgent(client *ssh.Client, keyring Agent) error {
channels := client.HandleChannelOpen(channelType)
if channels == nil {
return errors.New("agent: already have handler for " + channelType)
}
go func() {
for ch := range channels {
channel, reqs, err := ch.Accept()
if err != nil {
continue
}
go ssh.DiscardRequests(reqs)
go func() {
ServeAgent(keyring, channel)
channel.Close()
}()
}
}()
return nil
} | go | func ForwardToAgent(client *ssh.Client, keyring Agent) error {
channels := client.HandleChannelOpen(channelType)
if channels == nil {
return errors.New("agent: already have handler for " + channelType)
}
go func() {
for ch := range channels {
channel, reqs, err := ch.Accept()
if err != nil {
continue
}
go ssh.DiscardRequests(reqs)
go func() {
ServeAgent(keyring, channel)
channel.Close()
}()
}
}()
return nil
} | [
"func",
"ForwardToAgent",
"(",
"client",
"*",
"ssh",
".",
"Client",
",",
"keyring",
"Agent",
")",
"error",
"{",
"channels",
":=",
"client",
".",
"HandleChannelOpen",
"(",
"channelType",
")",
"\n",
"if",
"channels",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"channelType",
")",
"\n",
"}",
"\n\n",
"go",
"func",
"(",
")",
"{",
"for",
"ch",
":=",
"range",
"channels",
"{",
"channel",
",",
"reqs",
",",
"err",
":=",
"ch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"go",
"ssh",
".",
"DiscardRequests",
"(",
"reqs",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"ServeAgent",
"(",
"keyring",
",",
"channel",
")",
"\n",
"channel",
".",
"Close",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // ForwardToAgent routes authentication requests to the given keyring. | [
"ForwardToAgent",
"routes",
"authentication",
"requests",
"to",
"the",
"given",
"keyring",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/agent/forward.go#L31-L51 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/agent/forward.go | ForwardToRemote | func ForwardToRemote(client *ssh.Client, addr string) error {
channels := client.HandleChannelOpen(channelType)
if channels == nil {
return errors.New("agent: already have handler for " + channelType)
}
conn, err := net.Dial("unix", addr)
if err != nil {
return err
}
conn.Close()
go func() {
for ch := range channels {
channel, reqs, err := ch.Accept()
if err != nil {
continue
}
go ssh.DiscardRequests(reqs)
go forwardUnixSocket(channel, addr)
}
}()
return nil
} | go | func ForwardToRemote(client *ssh.Client, addr string) error {
channels := client.HandleChannelOpen(channelType)
if channels == nil {
return errors.New("agent: already have handler for " + channelType)
}
conn, err := net.Dial("unix", addr)
if err != nil {
return err
}
conn.Close()
go func() {
for ch := range channels {
channel, reqs, err := ch.Accept()
if err != nil {
continue
}
go ssh.DiscardRequests(reqs)
go forwardUnixSocket(channel, addr)
}
}()
return nil
} | [
"func",
"ForwardToRemote",
"(",
"client",
"*",
"ssh",
".",
"Client",
",",
"addr",
"string",
")",
"error",
"{",
"channels",
":=",
"client",
".",
"HandleChannelOpen",
"(",
"channelType",
")",
"\n",
"if",
"channels",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"channelType",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
".",
"Close",
"(",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"for",
"ch",
":=",
"range",
"channels",
"{",
"channel",
",",
"reqs",
",",
"err",
":=",
"ch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"go",
"ssh",
".",
"DiscardRequests",
"(",
"reqs",
")",
"\n",
"go",
"forwardUnixSocket",
"(",
"channel",
",",
"addr",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // ForwardToRemote routes authentication requests to the ssh-agent
// process serving on the given unix socket. | [
"ForwardToRemote",
"routes",
"authentication",
"requests",
"to",
"the",
"ssh",
"-",
"agent",
"process",
"serving",
"on",
"the",
"given",
"unix",
"socket",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/agent/forward.go#L57-L79 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go | Create | func (c *namespaces) Create(namespace *api.Namespace) (*api.Namespace, error) {
result := &api.Namespace{}
err := c.r.Post().Resource("namespaces").Body(namespace).Do().Into(result)
return result, err
} | go | func (c *namespaces) Create(namespace *api.Namespace) (*api.Namespace, error) {
result := &api.Namespace{}
err := c.r.Post().Resource("namespaces").Body(namespace).Do().Into(result)
return result, err
} | [
"func",
"(",
"c",
"*",
"namespaces",
")",
"Create",
"(",
"namespace",
"*",
"api",
".",
"Namespace",
")",
"(",
"*",
"api",
".",
"Namespace",
",",
"error",
")",
"{",
"result",
":=",
"&",
"api",
".",
"Namespace",
"{",
"}",
"\n",
"err",
":=",
"c",
".",
"r",
".",
"Post",
"(",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Body",
"(",
"namespace",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // Create creates a new namespace. | [
"Create",
"creates",
"a",
"new",
"namespace",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go#L52-L56 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go | List | func (c *namespaces) List(opts api.ListOptions) (*api.NamespaceList, error) {
result := &api.NamespaceList{}
err := c.r.Get().
Resource("namespaces").
VersionedParams(&opts, api.Scheme).
Do().Into(result)
return result, err
} | go | func (c *namespaces) List(opts api.ListOptions) (*api.NamespaceList, error) {
result := &api.NamespaceList{}
err := c.r.Get().
Resource("namespaces").
VersionedParams(&opts, api.Scheme).
Do().Into(result)
return result, err
} | [
"func",
"(",
"c",
"*",
"namespaces",
")",
"List",
"(",
"opts",
"api",
".",
"ListOptions",
")",
"(",
"*",
"api",
".",
"NamespaceList",
",",
"error",
")",
"{",
"result",
":=",
"&",
"api",
".",
"NamespaceList",
"{",
"}",
"\n",
"err",
":=",
"c",
".",
"r",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"VersionedParams",
"(",
"&",
"opts",
",",
"api",
".",
"Scheme",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // List lists all the namespaces in the cluster. | [
"List",
"lists",
"all",
"the",
"namespaces",
"in",
"the",
"cluster",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go#L59-L66 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go | Update | func (c *namespaces) Update(namespace *api.Namespace) (result *api.Namespace, err error) {
result = &api.Namespace{}
if len(namespace.ResourceVersion) == 0 {
err = fmt.Errorf("invalid update object, missing resource version: %v", namespace)
return
}
err = c.r.Put().Resource("namespaces").Name(namespace.Name).Body(namespace).Do().Into(result)
return
} | go | func (c *namespaces) Update(namespace *api.Namespace) (result *api.Namespace, err error) {
result = &api.Namespace{}
if len(namespace.ResourceVersion) == 0 {
err = fmt.Errorf("invalid update object, missing resource version: %v", namespace)
return
}
err = c.r.Put().Resource("namespaces").Name(namespace.Name).Body(namespace).Do().Into(result)
return
} | [
"func",
"(",
"c",
"*",
"namespaces",
")",
"Update",
"(",
"namespace",
"*",
"api",
".",
"Namespace",
")",
"(",
"result",
"*",
"api",
".",
"Namespace",
",",
"err",
"error",
")",
"{",
"result",
"=",
"&",
"api",
".",
"Namespace",
"{",
"}",
"\n",
"if",
"len",
"(",
"namespace",
".",
"ResourceVersion",
")",
"==",
"0",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"namespace",
")",
"\n",
"return",
"\n",
"}",
"\n",
"err",
"=",
"c",
".",
"r",
".",
"Put",
"(",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Name",
"(",
"namespace",
".",
"Name",
")",
".",
"Body",
"(",
"namespace",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"\n",
"}"
] | // Update takes the representation of a namespace to update. Returns the server's representation of the namespace, and an error, if it occurs. | [
"Update",
"takes",
"the",
"representation",
"of",
"a",
"namespace",
"to",
"update",
".",
"Returns",
"the",
"server",
"s",
"representation",
"of",
"the",
"namespace",
"and",
"an",
"error",
"if",
"it",
"occurs",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go#L69-L77 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go | Delete | func (c *namespaces) Delete(name string) error {
return c.r.Delete().Resource("namespaces").Name(name).Do().Error()
} | go | func (c *namespaces) Delete(name string) error {
return c.r.Delete().Resource("namespaces").Name(name).Do().Error()
} | [
"func",
"(",
"c",
"*",
"namespaces",
")",
"Delete",
"(",
"name",
"string",
")",
"error",
"{",
"return",
"c",
".",
"r",
".",
"Delete",
"(",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Name",
"(",
"name",
")",
".",
"Do",
"(",
")",
".",
"Error",
"(",
")",
"\n",
"}"
] | // Delete deletes an existing namespace. | [
"Delete",
"deletes",
"an",
"existing",
"namespace",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/namespaces.go#L109-L111 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/deep_copy_generator.go | ReplaceType | func (g *deepCopyGenerator) ReplaceType(pkgPath, name string, t interface{}) {
g.replace[pkgPathNamePair{pkgPath, name}] = reflect.TypeOf(t)
} | go | func (g *deepCopyGenerator) ReplaceType(pkgPath, name string, t interface{}) {
g.replace[pkgPathNamePair{pkgPath, name}] = reflect.TypeOf(t)
} | [
"func",
"(",
"g",
"*",
"deepCopyGenerator",
")",
"ReplaceType",
"(",
"pkgPath",
",",
"name",
"string",
",",
"t",
"interface",
"{",
"}",
")",
"{",
"g",
".",
"replace",
"[",
"pkgPathNamePair",
"{",
"pkgPath",
",",
"name",
"}",
"]",
"=",
"reflect",
".",
"TypeOf",
"(",
"t",
")",
"\n",
"}"
] | // ReplaceType registers a replacement type to be used instead of the named type | [
"ReplaceType",
"registers",
"a",
"replacement",
"type",
"to",
"be",
"used",
"instead",
"of",
"the",
"named",
"type"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime/deep_copy_generator.go#L197-L199 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/decode.go | Decode | func (s *Scheme) Decode(data []byte) (interface{}, error) {
return s.DecodeToVersion(data, unversioned.GroupVersion{})
} | go | func (s *Scheme) Decode(data []byte) (interface{}, error) {
return s.DecodeToVersion(data, unversioned.GroupVersion{})
} | [
"func",
"(",
"s",
"*",
"Scheme",
")",
"Decode",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"s",
".",
"DecodeToVersion",
"(",
"data",
",",
"unversioned",
".",
"GroupVersion",
"{",
"}",
")",
"\n",
"}"
] | // Decode converts a JSON string back into a pointer to an api object.
// Deduces the type based upon the fields added by the MetaInsertionFactory
// technique. The object will be converted, if necessary, into the
// s.InternalVersion type before being returned. Decode will not decode
// objects without version set unless InternalVersion is also "". | [
"Decode",
"converts",
"a",
"JSON",
"string",
"back",
"into",
"a",
"pointer",
"to",
"an",
"api",
"object",
".",
"Deduces",
"the",
"type",
"based",
"upon",
"the",
"fields",
"added",
"by",
"the",
"MetaInsertionFactory",
"technique",
".",
"The",
"object",
"will",
"be",
"converted",
"if",
"necessary",
"into",
"the",
"s",
".",
"InternalVersion",
"type",
"before",
"being",
"returned",
".",
"Decode",
"will",
"not",
"decode",
"objects",
"without",
"version",
"set",
"unless",
"InternalVersion",
"is",
"also",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/decode.go#L66-L68 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/decode.go | DecodeInto | func (s *Scheme) DecodeInto(data []byte, obj interface{}) error {
return s.DecodeIntoWithSpecifiedVersionKind(data, obj, unversioned.GroupVersionKind{})
} | go | func (s *Scheme) DecodeInto(data []byte, obj interface{}) error {
return s.DecodeIntoWithSpecifiedVersionKind(data, obj, unversioned.GroupVersionKind{})
} | [
"func",
"(",
"s",
"*",
"Scheme",
")",
"DecodeInto",
"(",
"data",
"[",
"]",
"byte",
",",
"obj",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"s",
".",
"DecodeIntoWithSpecifiedVersionKind",
"(",
"data",
",",
"obj",
",",
"unversioned",
".",
"GroupVersionKind",
"{",
"}",
")",
"\n",
"}"
] | // DecodeInto parses a JSON string and stores it in obj. Returns an error
// if data.Kind is set and doesn't match the type of obj. Obj should be a
// pointer to an api type.
// If obj's version doesn't match that in data, an attempt will be made to convert
// data into obj's version. | [
"DecodeInto",
"parses",
"a",
"JSON",
"string",
"and",
"stores",
"it",
"in",
"obj",
".",
"Returns",
"an",
"error",
"if",
"data",
".",
"Kind",
"is",
"set",
"and",
"doesn",
"t",
"match",
"the",
"type",
"of",
"obj",
".",
"Obj",
"should",
"be",
"a",
"pointer",
"to",
"an",
"api",
"type",
".",
"If",
"obj",
"s",
"version",
"doesn",
"t",
"match",
"that",
"in",
"data",
"an",
"attempt",
"will",
"be",
"made",
"to",
"convert",
"data",
"into",
"obj",
"s",
"version",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/decode.go#L117-L119 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go | newServiceAccounts | func newServiceAccounts(c *Client, ns string) ServiceAccountsInterface {
return &serviceAccounts{
client: c,
namespace: ns,
}
} | go | func newServiceAccounts(c *Client, ns string) ServiceAccountsInterface {
return &serviceAccounts{
client: c,
namespace: ns,
}
} | [
"func",
"newServiceAccounts",
"(",
"c",
"*",
"Client",
",",
"ns",
"string",
")",
"ServiceAccountsInterface",
"{",
"return",
"&",
"serviceAccounts",
"{",
"client",
":",
"c",
",",
"namespace",
":",
"ns",
",",
"}",
"\n",
"}"
] | // newServiceAccounts returns a new serviceAccounts object. | [
"newServiceAccounts",
"returns",
"a",
"new",
"serviceAccounts",
"object",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go#L44-L49 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go | List | func (s *serviceAccounts) List(opts api.ListOptions) (*api.ServiceAccountList, error) {
result := &api.ServiceAccountList{}
err := s.client.Get().
Namespace(s.namespace).
Resource("serviceAccounts").
VersionedParams(&opts, api.Scheme).
Do().
Into(result)
return result, err
} | go | func (s *serviceAccounts) List(opts api.ListOptions) (*api.ServiceAccountList, error) {
result := &api.ServiceAccountList{}
err := s.client.Get().
Namespace(s.namespace).
Resource("serviceAccounts").
VersionedParams(&opts, api.Scheme).
Do().
Into(result)
return result, err
} | [
"func",
"(",
"s",
"*",
"serviceAccounts",
")",
"List",
"(",
"opts",
"api",
".",
"ListOptions",
")",
"(",
"*",
"api",
".",
"ServiceAccountList",
",",
"error",
")",
"{",
"result",
":=",
"&",
"api",
".",
"ServiceAccountList",
"{",
"}",
"\n\n",
"err",
":=",
"s",
".",
"client",
".",
"Get",
"(",
")",
".",
"Namespace",
"(",
"s",
".",
"namespace",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"VersionedParams",
"(",
"&",
"opts",
",",
"api",
".",
"Scheme",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // List returns a list of serviceAccounts matching the selectors. | [
"List",
"returns",
"a",
"list",
"of",
"serviceAccounts",
"matching",
"the",
"selectors",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go#L64-L75 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go | Get | func (s *serviceAccounts) Get(name string) (*api.ServiceAccount, error) {
result := &api.ServiceAccount{}
err := s.client.Get().
Namespace(s.namespace).
Resource("serviceAccounts").
Name(name).
Do().
Into(result)
return result, err
} | go | func (s *serviceAccounts) Get(name string) (*api.ServiceAccount, error) {
result := &api.ServiceAccount{}
err := s.client.Get().
Namespace(s.namespace).
Resource("serviceAccounts").
Name(name).
Do().
Into(result)
return result, err
} | [
"func",
"(",
"s",
"*",
"serviceAccounts",
")",
"Get",
"(",
"name",
"string",
")",
"(",
"*",
"api",
".",
"ServiceAccount",
",",
"error",
")",
"{",
"result",
":=",
"&",
"api",
".",
"ServiceAccount",
"{",
"}",
"\n",
"err",
":=",
"s",
".",
"client",
".",
"Get",
"(",
")",
".",
"Namespace",
"(",
"s",
".",
"namespace",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Name",
"(",
"name",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // Get returns the given serviceAccount, or an error. | [
"Get",
"returns",
"the",
"given",
"serviceAccount",
"or",
"an",
"error",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go#L78-L88 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go | Watch | func (s *serviceAccounts) Watch(opts api.ListOptions) (watch.Interface, error) {
return s.client.Get().
Prefix("watch").
Namespace(s.namespace).
Resource("serviceAccounts").
VersionedParams(&opts, api.Scheme).
Watch()
} | go | func (s *serviceAccounts) Watch(opts api.ListOptions) (watch.Interface, error) {
return s.client.Get().
Prefix("watch").
Namespace(s.namespace).
Resource("serviceAccounts").
VersionedParams(&opts, api.Scheme).
Watch()
} | [
"func",
"(",
"s",
"*",
"serviceAccounts",
")",
"Watch",
"(",
"opts",
"api",
".",
"ListOptions",
")",
"(",
"watch",
".",
"Interface",
",",
"error",
")",
"{",
"return",
"s",
".",
"client",
".",
"Get",
"(",
")",
".",
"Prefix",
"(",
"\"",
"\"",
")",
".",
"Namespace",
"(",
"s",
".",
"namespace",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"VersionedParams",
"(",
"&",
"opts",
",",
"api",
".",
"Scheme",
")",
".",
"Watch",
"(",
")",
"\n",
"}"
] | // Watch starts watching for serviceAccounts matching the given selectors. | [
"Watch",
"starts",
"watching",
"for",
"serviceAccounts",
"matching",
"the",
"given",
"selectors",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/service_accounts.go#L91-L98 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/config/config.go | Channel | func (m *Mux) Channel(source string) chan interface{} {
if len(source) == 0 {
panic("Channel given an empty name")
}
m.sourceLock.Lock()
defer m.sourceLock.Unlock()
channel, exists := m.sources[source]
if exists {
return channel
}
newChannel := make(chan interface{})
m.sources[source] = newChannel
go util.Until(func() { m.listen(source, newChannel) }, 0, util.NeverStop)
return newChannel
} | go | func (m *Mux) Channel(source string) chan interface{} {
if len(source) == 0 {
panic("Channel given an empty name")
}
m.sourceLock.Lock()
defer m.sourceLock.Unlock()
channel, exists := m.sources[source]
if exists {
return channel
}
newChannel := make(chan interface{})
m.sources[source] = newChannel
go util.Until(func() { m.listen(source, newChannel) }, 0, util.NeverStop)
return newChannel
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Channel",
"(",
"source",
"string",
")",
"chan",
"interface",
"{",
"}",
"{",
"if",
"len",
"(",
"source",
")",
"==",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"m",
".",
"sourceLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"sourceLock",
".",
"Unlock",
"(",
")",
"\n",
"channel",
",",
"exists",
":=",
"m",
".",
"sources",
"[",
"source",
"]",
"\n",
"if",
"exists",
"{",
"return",
"channel",
"\n",
"}",
"\n",
"newChannel",
":=",
"make",
"(",
"chan",
"interface",
"{",
"}",
")",
"\n",
"m",
".",
"sources",
"[",
"source",
"]",
"=",
"newChannel",
"\n",
"go",
"util",
".",
"Until",
"(",
"func",
"(",
")",
"{",
"m",
".",
"listen",
"(",
"source",
",",
"newChannel",
")",
"}",
",",
"0",
",",
"util",
".",
"NeverStop",
")",
"\n",
"return",
"newChannel",
"\n",
"}"
] | // Channel returns a channel where a configuration source
// can send updates of new configurations. Multiple calls with the same
// source will return the same channel. This allows change and state based sources
// to use the same channel. Different source names however will be treated as a
// union. | [
"Channel",
"returns",
"a",
"channel",
"where",
"a",
"configuration",
"source",
"can",
"send",
"updates",
"of",
"new",
"configurations",
".",
"Multiple",
"calls",
"with",
"the",
"same",
"source",
"will",
"return",
"the",
"same",
"channel",
".",
"This",
"allows",
"change",
"and",
"state",
"based",
"sources",
"to",
"use",
"the",
"same",
"channel",
".",
"Different",
"source",
"names",
"however",
"will",
"be",
"treated",
"as",
"a",
"union",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/config/config.go#L65-L79 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/interfaces.go | ClientForMapping | func (f ClientMapperFunc) ClientForMapping(mapping *meta.RESTMapping) (RESTClient, error) {
return f(mapping)
} | go | func (f ClientMapperFunc) ClientForMapping(mapping *meta.RESTMapping) (RESTClient, error) {
return f(mapping)
} | [
"func",
"(",
"f",
"ClientMapperFunc",
")",
"ClientForMapping",
"(",
"mapping",
"*",
"meta",
".",
"RESTMapping",
")",
"(",
"RESTClient",
",",
"error",
")",
"{",
"return",
"f",
"(",
"mapping",
")",
"\n",
"}"
] | // ClientForMapping implements ClientMapper | [
"ClientForMapping",
"implements",
"ClientMapper"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/resource/interfaces.go#L44-L46 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/ssh.go | Open | func (l *SSHTunnelList) Open() error {
var openTunnels []SSHTunnelEntry
for ix := range l.entries {
if err := l.entries[ix].Tunnel.Open(); err != nil {
glog.Errorf("Failed to open tunnel %v: %v", l.entries[ix], err)
} else {
openTunnels = append(openTunnels, l.entries[ix])
}
}
l.entries = openTunnels
if len(l.entries) == 0 {
return errors.New("Failed to open any tunnels.")
}
return nil
} | go | func (l *SSHTunnelList) Open() error {
var openTunnels []SSHTunnelEntry
for ix := range l.entries {
if err := l.entries[ix].Tunnel.Open(); err != nil {
glog.Errorf("Failed to open tunnel %v: %v", l.entries[ix], err)
} else {
openTunnels = append(openTunnels, l.entries[ix])
}
}
l.entries = openTunnels
if len(l.entries) == 0 {
return errors.New("Failed to open any tunnels.")
}
return nil
} | [
"func",
"(",
"l",
"*",
"SSHTunnelList",
")",
"Open",
"(",
")",
"error",
"{",
"var",
"openTunnels",
"[",
"]",
"SSHTunnelEntry",
"\n",
"for",
"ix",
":=",
"range",
"l",
".",
"entries",
"{",
"if",
"err",
":=",
"l",
".",
"entries",
"[",
"ix",
"]",
".",
"Tunnel",
".",
"Open",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"l",
".",
"entries",
"[",
"ix",
"]",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"openTunnels",
"=",
"append",
"(",
"openTunnels",
",",
"l",
".",
"entries",
"[",
"ix",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"l",
".",
"entries",
"=",
"openTunnels",
"\n",
"if",
"len",
"(",
"l",
".",
"entries",
")",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Open attempts to open all tunnels in the list, and removes any tunnels that
// failed to open. | [
"Open",
"attempts",
"to",
"open",
"all",
"tunnels",
"in",
"the",
"list",
"and",
"removes",
"any",
"tunnels",
"that",
"failed",
"to",
"open",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/ssh.go#L269-L283 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/ssh.go | Close | func (l *SSHTunnelList) Close() {
for ix := range l.entries {
entry := l.entries[ix]
go func() {
defer HandleCrash()
time.Sleep(1 * time.Minute)
if err := entry.Tunnel.Close(); err != nil {
glog.Errorf("Failed to close tunnel %v: %v", entry, err)
}
}()
}
} | go | func (l *SSHTunnelList) Close() {
for ix := range l.entries {
entry := l.entries[ix]
go func() {
defer HandleCrash()
time.Sleep(1 * time.Minute)
if err := entry.Tunnel.Close(); err != nil {
glog.Errorf("Failed to close tunnel %v: %v", entry, err)
}
}()
}
} | [
"func",
"(",
"l",
"*",
"SSHTunnelList",
")",
"Close",
"(",
")",
"{",
"for",
"ix",
":=",
"range",
"l",
".",
"entries",
"{",
"entry",
":=",
"l",
".",
"entries",
"[",
"ix",
"]",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"HandleCrash",
"(",
")",
"\n",
"time",
".",
"Sleep",
"(",
"1",
"*",
"time",
".",
"Minute",
")",
"\n",
"if",
"err",
":=",
"entry",
".",
"Tunnel",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"glog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"entry",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Close asynchronously closes all tunnels in the list after waiting for 1
// minute. Tunnels will still be open upon this function's return, but should
// no longer be used. | [
"Close",
"asynchronously",
"closes",
"all",
"tunnels",
"in",
"the",
"list",
"after",
"waiting",
"for",
"1",
"minute",
".",
"Tunnels",
"will",
"still",
"be",
"open",
"upon",
"this",
"function",
"s",
"return",
"but",
"should",
"no",
"longer",
"be",
"used",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/ssh.go#L288-L299 | train |
kubernetes-retired/contrib | docker-micro-benchmark/helpers/helpers.go | LogEVar | func LogEVar(vars map[string]interface{}) {
for k, v := range vars {
fmt.Printf("%s=%v ", k, v)
}
fmt.Println()
} | go | func LogEVar(vars map[string]interface{}) {
for k, v := range vars {
fmt.Printf("%s=%v ", k, v)
}
fmt.Println()
} | [
"func",
"LogEVar",
"(",
"vars",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"vars",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"}"
] | // LogEVar prints all the environment variables | [
"LogEVar",
"prints",
"all",
"the",
"environment",
"variables"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/docker-micro-benchmark/helpers/helpers.go#L48-L53 | train |
kubernetes-retired/contrib | docker-micro-benchmark/helpers/helpers.go | LogLabels | func LogLabels(labels ...string) {
content := "time\t"
for _, percentile := range percentiles {
content += fmt.Sprintf("%%%02d\t", int(percentile*100))
}
content += strings.Join(labels, "\t")
fmt.Println(content)
} | go | func LogLabels(labels ...string) {
content := "time\t"
for _, percentile := range percentiles {
content += fmt.Sprintf("%%%02d\t", int(percentile*100))
}
content += strings.Join(labels, "\t")
fmt.Println(content)
} | [
"func",
"LogLabels",
"(",
"labels",
"...",
"string",
")",
"{",
"content",
":=",
"\"",
"\\t",
"\"",
"\n",
"for",
"_",
",",
"percentile",
":=",
"range",
"percentiles",
"{",
"content",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\t",
"\"",
",",
"int",
"(",
"percentile",
"*",
"100",
")",
")",
"\n",
"}",
"\n",
"content",
"+=",
"strings",
".",
"Join",
"(",
"labels",
",",
"\"",
"\\t",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"content",
")",
"\n",
"}"
] | // LogLabels prints the labels of the result table | [
"LogLabels",
"prints",
"the",
"labels",
"of",
"the",
"result",
"table"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/docker-micro-benchmark/helpers/helpers.go#L56-L63 | train |
kubernetes-retired/contrib | docker-micro-benchmark/helpers/helpers.go | LogResult | func LogResult(latencies []int, variables ...string) {
sort.Ints(latencies)
results := []float64{}
for _, percentile := range percentiles {
n := int(math.Ceil((1 - percentile) * float64(len(latencies))))
result := float64(latencies[len(latencies)-n]) / 1000000
results = append(results, result)
}
var str string
for _, result := range results {
str += fmt.Sprintf("%.2f\t", result)
}
log(str + strings.Join(variables, "\t"))
} | go | func LogResult(latencies []int, variables ...string) {
sort.Ints(latencies)
results := []float64{}
for _, percentile := range percentiles {
n := int(math.Ceil((1 - percentile) * float64(len(latencies))))
result := float64(latencies[len(latencies)-n]) / 1000000
results = append(results, result)
}
var str string
for _, result := range results {
str += fmt.Sprintf("%.2f\t", result)
}
log(str + strings.Join(variables, "\t"))
} | [
"func",
"LogResult",
"(",
"latencies",
"[",
"]",
"int",
",",
"variables",
"...",
"string",
")",
"{",
"sort",
".",
"Ints",
"(",
"latencies",
")",
"\n",
"results",
":=",
"[",
"]",
"float64",
"{",
"}",
"\n",
"for",
"_",
",",
"percentile",
":=",
"range",
"percentiles",
"{",
"n",
":=",
"int",
"(",
"math",
".",
"Ceil",
"(",
"(",
"1",
"-",
"percentile",
")",
"*",
"float64",
"(",
"len",
"(",
"latencies",
")",
")",
")",
")",
"\n",
"result",
":=",
"float64",
"(",
"latencies",
"[",
"len",
"(",
"latencies",
")",
"-",
"n",
"]",
")",
"/",
"1000000",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"result",
")",
"\n",
"}",
"\n",
"var",
"str",
"string",
"\n",
"for",
"_",
",",
"result",
":=",
"range",
"results",
"{",
"str",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\t",
"\"",
",",
"result",
")",
"\n",
"}",
"\n",
"log",
"(",
"str",
"+",
"strings",
".",
"Join",
"(",
"variables",
",",
"\"",
"\\t",
"\"",
")",
")",
"\n",
"}"
] | // LogResult prints the item of the result table | [
"LogResult",
"prints",
"the",
"item",
"of",
"the",
"result",
"table"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/docker-micro-benchmark/helpers/helpers.go#L66-L79 | train |
kubernetes-retired/contrib | docker-micro-benchmark/helpers/helpers.go | Itoas | func Itoas(nums ...int) []string {
r := []string{}
for _, n := range nums {
r = append(r, fmt.Sprintf("%d", n))
}
return r
} | go | func Itoas(nums ...int) []string {
r := []string{}
for _, n := range nums {
r = append(r, fmt.Sprintf("%d", n))
}
return r
} | [
"func",
"Itoas",
"(",
"nums",
"...",
"int",
")",
"[",
"]",
"string",
"{",
"r",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"nums",
"{",
"r",
"=",
"append",
"(",
"r",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"n",
")",
")",
"\n",
"}",
"\n",
"return",
"r",
"\n",
"}"
] | // Itoas converts int numbers to a slice of string | [
"Itoas",
"converts",
"int",
"numbers",
"to",
"a",
"slice",
"of",
"string"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/docker-micro-benchmark/helpers/helpers.go#L82-L88 | train |
kubernetes-retired/contrib | docker-micro-benchmark/helpers/helpers.go | Ftoas | func Ftoas(nums ...float64) []string {
r := []string{}
for _, n := range nums {
r = append(r, fmt.Sprintf("%0.4f", n))
}
return r
} | go | func Ftoas(nums ...float64) []string {
r := []string{}
for _, n := range nums {
r = append(r, fmt.Sprintf("%0.4f", n))
}
return r
} | [
"func",
"Ftoas",
"(",
"nums",
"...",
"float64",
")",
"[",
"]",
"string",
"{",
"r",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"nums",
"{",
"r",
"=",
"append",
"(",
"r",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"n",
")",
")",
"\n",
"}",
"\n",
"return",
"r",
"\n",
"}"
] | // Ftoas converts float64 numbers to a slice of string | [
"Ftoas",
"converts",
"float64",
"numbers",
"to",
"a",
"slice",
"of",
"string"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/docker-micro-benchmark/helpers/helpers.go#L91-L97 | train |
kubernetes-retired/contrib | docker-micro-benchmark/Godeps/_workspace/src/golang.org/x/net/proxy/per_host.go | Dial | func (p *PerHost) Dial(network, addr string) (c net.Conn, err error) {
host, _, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
return p.dialerForRequest(host).Dial(network, addr)
} | go | func (p *PerHost) Dial(network, addr string) (c net.Conn, err error) {
host, _, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
return p.dialerForRequest(host).Dial(network, addr)
} | [
"func",
"(",
"p",
"*",
"PerHost",
")",
"Dial",
"(",
"network",
",",
"addr",
"string",
")",
"(",
"c",
"net",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"dialerForRequest",
"(",
"host",
")",
".",
"Dial",
"(",
"network",
",",
"addr",
")",
"\n",
"}"
] | // Dial connects to the address addr on the given network through either
// defaultDialer or bypass. | [
"Dial",
"connects",
"to",
"the",
"address",
"addr",
"on",
"the",
"given",
"network",
"through",
"either",
"defaultDialer",
"or",
"bypass",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/docker-micro-benchmark/Godeps/_workspace/src/golang.org/x/net/proxy/per_host.go#L35-L42 | train |
kubernetes-retired/contrib | docker-micro-benchmark/Godeps/_workspace/src/golang.org/x/net/proxy/per_host.go | AddHost | func (p *PerHost) AddHost(host string) {
if strings.HasSuffix(host, ".") {
host = host[:len(host)-1]
}
p.bypassHosts = append(p.bypassHosts, host)
} | go | func (p *PerHost) AddHost(host string) {
if strings.HasSuffix(host, ".") {
host = host[:len(host)-1]
}
p.bypassHosts = append(p.bypassHosts, host)
} | [
"func",
"(",
"p",
"*",
"PerHost",
")",
"AddHost",
"(",
"host",
"string",
")",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"host",
",",
"\"",
"\"",
")",
"{",
"host",
"=",
"host",
"[",
":",
"len",
"(",
"host",
")",
"-",
"1",
"]",
"\n",
"}",
"\n",
"p",
".",
"bypassHosts",
"=",
"append",
"(",
"p",
".",
"bypassHosts",
",",
"host",
")",
"\n",
"}"
] | // AddHost specifies a hostname that will use the bypass proxy. | [
"AddHost",
"specifies",
"a",
"hostname",
"that",
"will",
"use",
"the",
"bypass",
"proxy",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/docker-micro-benchmark/Godeps/_workspace/src/golang.org/x/net/proxy/per_host.go#L135-L140 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/io/io.go | SavePodToFile | func SavePodToFile(pod *api.Pod, filePath string, perm os.FileMode) error {
if filePath == "" {
return fmt.Errorf("file path not specified")
}
data, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
if err != nil {
return fmt.Errorf("failed encoding pod: %v", err)
}
return ioutil.WriteFile(filePath, data, perm)
} | go | func SavePodToFile(pod *api.Pod, filePath string, perm os.FileMode) error {
if filePath == "" {
return fmt.Errorf("file path not specified")
}
data, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
if err != nil {
return fmt.Errorf("failed encoding pod: %v", err)
}
return ioutil.WriteFile(filePath, data, perm)
} | [
"func",
"SavePodToFile",
"(",
"pod",
"*",
"api",
".",
"Pod",
",",
"filePath",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"error",
"{",
"if",
"filePath",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"data",
",",
"err",
":=",
"latest",
".",
"GroupOrDie",
"(",
"api",
".",
"GroupName",
")",
".",
"Codec",
".",
"Encode",
"(",
"pod",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"ioutil",
".",
"WriteFile",
"(",
"filePath",
",",
"data",
",",
"perm",
")",
"\n",
"}"
] | // SavePodToFile will encode and save a pod to a given path & permissions | [
"SavePodToFile",
"will",
"encode",
"and",
"save",
"a",
"pod",
"to",
"a",
"given",
"path",
"&",
"permissions"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/io/io.go#L49-L58 | train |
kubernetes-retired/contrib | node-perf-dash/downloader.go | NewGoogleGCSDownloader | func NewGoogleGCSDownloader() *GoogleGCSDownloader {
return &GoogleGCSDownloader{
GoogleGCSBucketUtils: utils.NewUtils(utils.KubekinsBucket, utils.LogDir),
}
} | go | func NewGoogleGCSDownloader() *GoogleGCSDownloader {
return &GoogleGCSDownloader{
GoogleGCSBucketUtils: utils.NewUtils(utils.KubekinsBucket, utils.LogDir),
}
} | [
"func",
"NewGoogleGCSDownloader",
"(",
")",
"*",
"GoogleGCSDownloader",
"{",
"return",
"&",
"GoogleGCSDownloader",
"{",
"GoogleGCSBucketUtils",
":",
"utils",
".",
"NewUtils",
"(",
"utils",
".",
"KubekinsBucket",
",",
"utils",
".",
"LogDir",
")",
",",
"}",
"\n",
"}"
] | // NewGoogleGCSDownloader creates a new GoogleGCSDownloader | [
"NewGoogleGCSDownloader",
"creates",
"a",
"new",
"GoogleGCSDownloader"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/node-perf-dash/downloader.go#L100-L104 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go | HandleChannelOpen | func (c *Client) HandleChannelOpen(channelType string) <-chan NewChannel {
c.mu.Lock()
defer c.mu.Unlock()
if c.channelHandlers == nil {
// The SSH channel has been closed.
c := make(chan NewChannel)
close(c)
return c
}
ch := c.channelHandlers[channelType]
if ch != nil {
return nil
}
ch = make(chan NewChannel, 16)
c.channelHandlers[channelType] = ch
return ch
} | go | func (c *Client) HandleChannelOpen(channelType string) <-chan NewChannel {
c.mu.Lock()
defer c.mu.Unlock()
if c.channelHandlers == nil {
// The SSH channel has been closed.
c := make(chan NewChannel)
close(c)
return c
}
ch := c.channelHandlers[channelType]
if ch != nil {
return nil
}
ch = make(chan NewChannel, 16)
c.channelHandlers[channelType] = ch
return ch
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"HandleChannelOpen",
"(",
"channelType",
"string",
")",
"<-",
"chan",
"NewChannel",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"c",
".",
"channelHandlers",
"==",
"nil",
"{",
"// The SSH channel has been closed.",
"c",
":=",
"make",
"(",
"chan",
"NewChannel",
")",
"\n",
"close",
"(",
"c",
")",
"\n",
"return",
"c",
"\n",
"}",
"\n\n",
"ch",
":=",
"c",
".",
"channelHandlers",
"[",
"channelType",
"]",
"\n",
"if",
"ch",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"ch",
"=",
"make",
"(",
"chan",
"NewChannel",
",",
"16",
")",
"\n",
"c",
".",
"channelHandlers",
"[",
"channelType",
"]",
"=",
"ch",
"\n",
"return",
"ch",
"\n",
"}"
] | // HandleChannelOpen returns a channel on which NewChannel requests
// for the given type are sent. If the type already is being handled,
// nil is returned. The channel is closed when the connection is closed. | [
"HandleChannelOpen",
"returns",
"a",
"channel",
"on",
"which",
"NewChannel",
"requests",
"for",
"the",
"given",
"type",
"are",
"sent",
".",
"If",
"the",
"type",
"already",
"is",
"being",
"handled",
"nil",
"is",
"returned",
".",
"The",
"channel",
"is",
"closed",
"when",
"the",
"connection",
"is",
"closed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go#L27-L45 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go | NewClient | func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client {
conn := &Client{
Conn: c,
channelHandlers: make(map[string]chan NewChannel, 1),
}
go conn.handleGlobalRequests(reqs)
go conn.handleChannelOpens(chans)
go func() {
conn.Wait()
conn.forwards.closeAll()
}()
go conn.forwards.handleChannels(conn.HandleChannelOpen("forwarded-tcpip"))
return conn
} | go | func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client {
conn := &Client{
Conn: c,
channelHandlers: make(map[string]chan NewChannel, 1),
}
go conn.handleGlobalRequests(reqs)
go conn.handleChannelOpens(chans)
go func() {
conn.Wait()
conn.forwards.closeAll()
}()
go conn.forwards.handleChannels(conn.HandleChannelOpen("forwarded-tcpip"))
return conn
} | [
"func",
"NewClient",
"(",
"c",
"Conn",
",",
"chans",
"<-",
"chan",
"NewChannel",
",",
"reqs",
"<-",
"chan",
"*",
"Request",
")",
"*",
"Client",
"{",
"conn",
":=",
"&",
"Client",
"{",
"Conn",
":",
"c",
",",
"channelHandlers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"chan",
"NewChannel",
",",
"1",
")",
",",
"}",
"\n\n",
"go",
"conn",
".",
"handleGlobalRequests",
"(",
"reqs",
")",
"\n",
"go",
"conn",
".",
"handleChannelOpens",
"(",
"chans",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"conn",
".",
"Wait",
"(",
")",
"\n",
"conn",
".",
"forwards",
".",
"closeAll",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"go",
"conn",
".",
"forwards",
".",
"handleChannels",
"(",
"conn",
".",
"HandleChannelOpen",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"conn",
"\n",
"}"
] | // NewClient creates a Client on top of the given connection. | [
"NewClient",
"creates",
"a",
"Client",
"on",
"top",
"of",
"the",
"given",
"connection",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go#L48-L62 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go | NewClientConn | func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error) {
fullConf := *config
fullConf.SetDefaults()
conn := &connection{
sshConn: sshConn{conn: c},
}
if err := conn.clientHandshake(addr, &fullConf); err != nil {
c.Close()
return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %v", err)
}
conn.mux = newMux(conn.transport)
return conn, conn.mux.incomingChannels, conn.mux.incomingRequests, nil
} | go | func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error) {
fullConf := *config
fullConf.SetDefaults()
conn := &connection{
sshConn: sshConn{conn: c},
}
if err := conn.clientHandshake(addr, &fullConf); err != nil {
c.Close()
return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %v", err)
}
conn.mux = newMux(conn.transport)
return conn, conn.mux.incomingChannels, conn.mux.incomingRequests, nil
} | [
"func",
"NewClientConn",
"(",
"c",
"net",
".",
"Conn",
",",
"addr",
"string",
",",
"config",
"*",
"ClientConfig",
")",
"(",
"Conn",
",",
"<-",
"chan",
"NewChannel",
",",
"<-",
"chan",
"*",
"Request",
",",
"error",
")",
"{",
"fullConf",
":=",
"*",
"config",
"\n",
"fullConf",
".",
"SetDefaults",
"(",
")",
"\n",
"conn",
":=",
"&",
"connection",
"{",
"sshConn",
":",
"sshConn",
"{",
"conn",
":",
"c",
"}",
",",
"}",
"\n\n",
"if",
"err",
":=",
"conn",
".",
"clientHandshake",
"(",
"addr",
",",
"&",
"fullConf",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"conn",
".",
"mux",
"=",
"newMux",
"(",
"conn",
".",
"transport",
")",
"\n",
"return",
"conn",
",",
"conn",
".",
"mux",
".",
"incomingChannels",
",",
"conn",
".",
"mux",
".",
"incomingRequests",
",",
"nil",
"\n",
"}"
] | // NewClientConn establishes an authenticated SSH connection using c
// as the underlying transport. The Request and NewChannel channels
// must be serviced or the connection will hang. | [
"NewClientConn",
"establishes",
"an",
"authenticated",
"SSH",
"connection",
"using",
"c",
"as",
"the",
"underlying",
"transport",
".",
"The",
"Request",
"and",
"NewChannel",
"channels",
"must",
"be",
"serviced",
"or",
"the",
"connection",
"will",
"hang",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go#L67-L80 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go | clientHandshake | func (c *connection) clientHandshake(dialAddress string, config *ClientConfig) error {
if config.ClientVersion != "" {
c.clientVersion = []byte(config.ClientVersion)
} else {
c.clientVersion = []byte(packageVersion)
}
var err error
c.serverVersion, err = exchangeVersions(c.sshConn.conn, c.clientVersion)
if err != nil {
return err
}
c.transport = newClientTransport(
newTransport(c.sshConn.conn, config.Rand, true /* is client */),
c.clientVersion, c.serverVersion, config, dialAddress, c.sshConn.RemoteAddr())
if err := c.transport.requestKeyChange(); err != nil {
return err
}
if packet, err := c.transport.readPacket(); err != nil {
return err
} else if packet[0] != msgNewKeys {
return unexpectedMessageError(msgNewKeys, packet[0])
}
// We just did the key change, so the session ID is established.
c.sessionID = c.transport.getSessionID()
return c.clientAuthenticate(config)
} | go | func (c *connection) clientHandshake(dialAddress string, config *ClientConfig) error {
if config.ClientVersion != "" {
c.clientVersion = []byte(config.ClientVersion)
} else {
c.clientVersion = []byte(packageVersion)
}
var err error
c.serverVersion, err = exchangeVersions(c.sshConn.conn, c.clientVersion)
if err != nil {
return err
}
c.transport = newClientTransport(
newTransport(c.sshConn.conn, config.Rand, true /* is client */),
c.clientVersion, c.serverVersion, config, dialAddress, c.sshConn.RemoteAddr())
if err := c.transport.requestKeyChange(); err != nil {
return err
}
if packet, err := c.transport.readPacket(); err != nil {
return err
} else if packet[0] != msgNewKeys {
return unexpectedMessageError(msgNewKeys, packet[0])
}
// We just did the key change, so the session ID is established.
c.sessionID = c.transport.getSessionID()
return c.clientAuthenticate(config)
} | [
"func",
"(",
"c",
"*",
"connection",
")",
"clientHandshake",
"(",
"dialAddress",
"string",
",",
"config",
"*",
"ClientConfig",
")",
"error",
"{",
"if",
"config",
".",
"ClientVersion",
"!=",
"\"",
"\"",
"{",
"c",
".",
"clientVersion",
"=",
"[",
"]",
"byte",
"(",
"config",
".",
"ClientVersion",
")",
"\n",
"}",
"else",
"{",
"c",
".",
"clientVersion",
"=",
"[",
"]",
"byte",
"(",
"packageVersion",
")",
"\n",
"}",
"\n",
"var",
"err",
"error",
"\n",
"c",
".",
"serverVersion",
",",
"err",
"=",
"exchangeVersions",
"(",
"c",
".",
"sshConn",
".",
"conn",
",",
"c",
".",
"clientVersion",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"transport",
"=",
"newClientTransport",
"(",
"newTransport",
"(",
"c",
".",
"sshConn",
".",
"conn",
",",
"config",
".",
"Rand",
",",
"true",
"/* is client */",
")",
",",
"c",
".",
"clientVersion",
",",
"c",
".",
"serverVersion",
",",
"config",
",",
"dialAddress",
",",
"c",
".",
"sshConn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"if",
"err",
":=",
"c",
".",
"transport",
".",
"requestKeyChange",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"packet",
",",
"err",
":=",
"c",
".",
"transport",
".",
"readPacket",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"packet",
"[",
"0",
"]",
"!=",
"msgNewKeys",
"{",
"return",
"unexpectedMessageError",
"(",
"msgNewKeys",
",",
"packet",
"[",
"0",
"]",
")",
"\n",
"}",
"\n\n",
"// We just did the key change, so the session ID is established.",
"c",
".",
"sessionID",
"=",
"c",
".",
"transport",
".",
"getSessionID",
"(",
")",
"\n\n",
"return",
"c",
".",
"clientAuthenticate",
"(",
"config",
")",
"\n",
"}"
] | // clientHandshake performs the client side key exchange. See RFC 4253 Section
// 7. | [
"clientHandshake",
"performs",
"the",
"client",
"side",
"key",
"exchange",
".",
"See",
"RFC",
"4253",
"Section",
"7",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go#L84-L113 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go | verifyHostKeySignature | func verifyHostKeySignature(hostKey PublicKey, result *kexResult) error {
sig, rest, ok := parseSignatureBody(result.Signature)
if len(rest) > 0 || !ok {
return errors.New("ssh: signature parse error")
}
return hostKey.Verify(result.H, sig)
} | go | func verifyHostKeySignature(hostKey PublicKey, result *kexResult) error {
sig, rest, ok := parseSignatureBody(result.Signature)
if len(rest) > 0 || !ok {
return errors.New("ssh: signature parse error")
}
return hostKey.Verify(result.H, sig)
} | [
"func",
"verifyHostKeySignature",
"(",
"hostKey",
"PublicKey",
",",
"result",
"*",
"kexResult",
")",
"error",
"{",
"sig",
",",
"rest",
",",
"ok",
":=",
"parseSignatureBody",
"(",
"result",
".",
"Signature",
")",
"\n",
"if",
"len",
"(",
"rest",
")",
">",
"0",
"||",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"hostKey",
".",
"Verify",
"(",
"result",
".",
"H",
",",
"sig",
")",
"\n",
"}"
] | // verifyHostKeySignature verifies the host key obtained in the key
// exchange. | [
"verifyHostKeySignature",
"verifies",
"the",
"host",
"key",
"obtained",
"in",
"the",
"key",
"exchange",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go#L117-L124 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go | handleChannelOpens | func (c *Client) handleChannelOpens(in <-chan NewChannel) {
for ch := range in {
c.mu.Lock()
handler := c.channelHandlers[ch.ChannelType()]
c.mu.Unlock()
if handler != nil {
handler <- ch
} else {
ch.Reject(UnknownChannelType, fmt.Sprintf("unknown channel type: %v", ch.ChannelType()))
}
}
c.mu.Lock()
for _, ch := range c.channelHandlers {
close(ch)
}
c.channelHandlers = nil
c.mu.Unlock()
} | go | func (c *Client) handleChannelOpens(in <-chan NewChannel) {
for ch := range in {
c.mu.Lock()
handler := c.channelHandlers[ch.ChannelType()]
c.mu.Unlock()
if handler != nil {
handler <- ch
} else {
ch.Reject(UnknownChannelType, fmt.Sprintf("unknown channel type: %v", ch.ChannelType()))
}
}
c.mu.Lock()
for _, ch := range c.channelHandlers {
close(ch)
}
c.channelHandlers = nil
c.mu.Unlock()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"handleChannelOpens",
"(",
"in",
"<-",
"chan",
"NewChannel",
")",
"{",
"for",
"ch",
":=",
"range",
"in",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"handler",
":=",
"c",
".",
"channelHandlers",
"[",
"ch",
".",
"ChannelType",
"(",
")",
"]",
"\n",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"handler",
"!=",
"nil",
"{",
"handler",
"<-",
"ch",
"\n",
"}",
"else",
"{",
"ch",
".",
"Reject",
"(",
"UnknownChannelType",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ch",
".",
"ChannelType",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"for",
"_",
",",
"ch",
":=",
"range",
"c",
".",
"channelHandlers",
"{",
"close",
"(",
"ch",
")",
"\n",
"}",
"\n",
"c",
".",
"channelHandlers",
"=",
"nil",
"\n",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // handleChannelOpens channel open messages from the remote side. | [
"handleChannelOpens",
"channel",
"open",
"messages",
"from",
"the",
"remote",
"side",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go#L145-L164 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go | Dial | func Dial(network, addr string, config *ClientConfig) (*Client, error) {
conn, err := net.Dial(network, addr)
if err != nil {
return nil, err
}
c, chans, reqs, err := NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
return NewClient(c, chans, reqs), nil
} | go | func Dial(network, addr string, config *ClientConfig) (*Client, error) {
conn, err := net.Dial(network, addr)
if err != nil {
return nil, err
}
c, chans, reqs, err := NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
return NewClient(c, chans, reqs), nil
} | [
"func",
"Dial",
"(",
"network",
",",
"addr",
"string",
",",
"config",
"*",
"ClientConfig",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"network",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"c",
",",
"chans",
",",
"reqs",
",",
"err",
":=",
"NewClientConn",
"(",
"conn",
",",
"addr",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewClient",
"(",
"c",
",",
"chans",
",",
"reqs",
")",
",",
"nil",
"\n",
"}"
] | // Dial starts a client connection to the given SSH server. It is a
// convenience function that connects to the given network address,
// initiates the SSH handshake, and then sets up a Client. For access
// to incoming channels and requests, use net.Dial with NewClientConn
// instead. | [
"Dial",
"starts",
"a",
"client",
"connection",
"to",
"the",
"given",
"SSH",
"server",
".",
"It",
"is",
"a",
"convenience",
"function",
"that",
"connects",
"to",
"the",
"given",
"network",
"address",
"initiates",
"the",
"SSH",
"handshake",
"and",
"then",
"sets",
"up",
"a",
"Client",
".",
"For",
"access",
"to",
"incoming",
"channels",
"and",
"requests",
"use",
"net",
".",
"Dial",
"with",
"NewClientConn",
"instead",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/golang.org/x/crypto/ssh/client.go#L171-L181 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/meta.go | Interpret | func (SimpleMetaFactory) Interpret(data []byte) (unversioned.GroupVersionKind, error) {
findKind := struct {
APIVersion string `json:"apiVersion,omitempty"`
Kind string `json:"kind,omitempty"`
}{}
err := json.Unmarshal(data, &findKind)
if err != nil {
return unversioned.GroupVersionKind{}, fmt.Errorf("couldn't get version/kind; json parse error: %v", err)
}
gv, err := unversioned.ParseGroupVersion(findKind.APIVersion)
if err != nil {
return unversioned.GroupVersionKind{}, fmt.Errorf("couldn't parse apiVersion: %v", err)
}
return gv.WithKind(findKind.Kind), nil
} | go | func (SimpleMetaFactory) Interpret(data []byte) (unversioned.GroupVersionKind, error) {
findKind := struct {
APIVersion string `json:"apiVersion,omitempty"`
Kind string `json:"kind,omitempty"`
}{}
err := json.Unmarshal(data, &findKind)
if err != nil {
return unversioned.GroupVersionKind{}, fmt.Errorf("couldn't get version/kind; json parse error: %v", err)
}
gv, err := unversioned.ParseGroupVersion(findKind.APIVersion)
if err != nil {
return unversioned.GroupVersionKind{}, fmt.Errorf("couldn't parse apiVersion: %v", err)
}
return gv.WithKind(findKind.Kind), nil
} | [
"func",
"(",
"SimpleMetaFactory",
")",
"Interpret",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"unversioned",
".",
"GroupVersionKind",
",",
"error",
")",
"{",
"findKind",
":=",
"struct",
"{",
"APIVersion",
"string",
"`json:\"apiVersion,omitempty\"`",
"\n",
"Kind",
"string",
"`json:\"kind,omitempty\"`",
"\n",
"}",
"{",
"}",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"findKind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"unversioned",
".",
"GroupVersionKind",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"gv",
",",
"err",
":=",
"unversioned",
".",
"ParseGroupVersion",
"(",
"findKind",
".",
"APIVersion",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"unversioned",
".",
"GroupVersionKind",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"gv",
".",
"WithKind",
"(",
"findKind",
".",
"Kind",
")",
",",
"nil",
"\n",
"}"
] | // Interpret will return the group,version,kind of the JSON wire-format
// encoding of an object, or an error. | [
"Interpret",
"will",
"return",
"the",
"group",
"version",
"kind",
"of",
"the",
"JSON",
"wire",
"-",
"format",
"encoding",
"of",
"an",
"object",
"or",
"an",
"error",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/conversion/meta.go#L58-L73 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/helper.go | ServerAPIVersions | func ServerAPIVersions(c *Config) (groupVersions []string, err error) {
transport, err := TransportFor(c)
if err != nil {
return nil, err
}
client := http.Client{Transport: transport}
configCopy := *c
configCopy.GroupVersion = nil
configCopy.Prefix = ""
baseURL, err := defaultServerUrlFor(c)
if err != nil {
return nil, err
}
// Get the groupVersions exposed at /api
baseURL.Path = "/api"
resp, err := client.Get(baseURL.String())
if err != nil {
return nil, err
}
var v unversioned.APIVersions
defer resp.Body.Close()
err = json.NewDecoder(resp.Body).Decode(&v)
if err != nil {
return nil, fmt.Errorf("unexpected error: %v", err)
}
groupVersions = append(groupVersions, v.Versions...)
// Get the groupVersions exposed at /apis
baseURL.Path = "/apis"
resp2, err := client.Get(baseURL.String())
if err != nil {
return nil, err
}
var apiGroupList unversioned.APIGroupList
defer resp2.Body.Close()
err = json.NewDecoder(resp2.Body).Decode(&apiGroupList)
if err != nil {
return nil, fmt.Errorf("unexpected error: %v", err)
}
groupVersions = append(groupVersions, ExtractGroupVersions(&apiGroupList)...)
return groupVersions, nil
} | go | func ServerAPIVersions(c *Config) (groupVersions []string, err error) {
transport, err := TransportFor(c)
if err != nil {
return nil, err
}
client := http.Client{Transport: transport}
configCopy := *c
configCopy.GroupVersion = nil
configCopy.Prefix = ""
baseURL, err := defaultServerUrlFor(c)
if err != nil {
return nil, err
}
// Get the groupVersions exposed at /api
baseURL.Path = "/api"
resp, err := client.Get(baseURL.String())
if err != nil {
return nil, err
}
var v unversioned.APIVersions
defer resp.Body.Close()
err = json.NewDecoder(resp.Body).Decode(&v)
if err != nil {
return nil, fmt.Errorf("unexpected error: %v", err)
}
groupVersions = append(groupVersions, v.Versions...)
// Get the groupVersions exposed at /apis
baseURL.Path = "/apis"
resp2, err := client.Get(baseURL.String())
if err != nil {
return nil, err
}
var apiGroupList unversioned.APIGroupList
defer resp2.Body.Close()
err = json.NewDecoder(resp2.Body).Decode(&apiGroupList)
if err != nil {
return nil, fmt.Errorf("unexpected error: %v", err)
}
groupVersions = append(groupVersions, ExtractGroupVersions(&apiGroupList)...)
return groupVersions, nil
} | [
"func",
"ServerAPIVersions",
"(",
"c",
"*",
"Config",
")",
"(",
"groupVersions",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"transport",
",",
"err",
":=",
"TransportFor",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"client",
":=",
"http",
".",
"Client",
"{",
"Transport",
":",
"transport",
"}",
"\n\n",
"configCopy",
":=",
"*",
"c",
"\n",
"configCopy",
".",
"GroupVersion",
"=",
"nil",
"\n",
"configCopy",
".",
"Prefix",
"=",
"\"",
"\"",
"\n",
"baseURL",
",",
"err",
":=",
"defaultServerUrlFor",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// Get the groupVersions exposed at /api",
"baseURL",
".",
"Path",
"=",
"\"",
"\"",
"\n",
"resp",
",",
"err",
":=",
"client",
".",
"Get",
"(",
"baseURL",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"v",
"unversioned",
".",
"APIVersions",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"groupVersions",
"=",
"append",
"(",
"groupVersions",
",",
"v",
".",
"Versions",
"...",
")",
"\n",
"// Get the groupVersions exposed at /apis",
"baseURL",
".",
"Path",
"=",
"\"",
"\"",
"\n",
"resp2",
",",
"err",
":=",
"client",
".",
"Get",
"(",
"baseURL",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"apiGroupList",
"unversioned",
".",
"APIGroupList",
"\n",
"defer",
"resp2",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp2",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"apiGroupList",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"groupVersions",
"=",
"append",
"(",
"groupVersions",
",",
"ExtractGroupVersions",
"(",
"&",
"apiGroupList",
")",
"...",
")",
"\n\n",
"return",
"groupVersions",
",",
"nil",
"\n",
"}"
] | // ServerAPIVersions returns the GroupVersions supported by the API server.
// It creates a RESTClient based on the passed in config, but it doesn't rely
// on the Version, Codec, and Prefix of the config, because it uses AbsPath and
// takes the raw response. | [
"ServerAPIVersions",
"returns",
"the",
"GroupVersions",
"supported",
"by",
"the",
"API",
"server",
".",
"It",
"creates",
"a",
"RESTClient",
"based",
"on",
"the",
"passed",
"in",
"config",
"but",
"it",
"doesn",
"t",
"rely",
"on",
"the",
"Version",
"Codec",
"and",
"Prefix",
"of",
"the",
"config",
"because",
"it",
"uses",
"AbsPath",
"and",
"takes",
"the",
"raw",
"response",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/helper.go#L185-L228 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go | List | func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *extensions.HorizontalPodAutoscalerList, err error) {
result = &extensions.HorizontalPodAutoscalerList{}
err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").VersionedParams(&opts, api.Scheme).Do().Into(result)
return
} | go | func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *extensions.HorizontalPodAutoscalerList, err error) {
result = &extensions.HorizontalPodAutoscalerList{}
err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").VersionedParams(&opts, api.Scheme).Do().Into(result)
return
} | [
"func",
"(",
"c",
"*",
"horizontalPodAutoscalers",
")",
"List",
"(",
"opts",
"api",
".",
"ListOptions",
")",
"(",
"result",
"*",
"extensions",
".",
"HorizontalPodAutoscalerList",
",",
"err",
"error",
")",
"{",
"result",
"=",
"&",
"extensions",
".",
"HorizontalPodAutoscalerList",
"{",
"}",
"\n",
"err",
"=",
"c",
".",
"client",
".",
"Get",
"(",
")",
".",
"Namespace",
"(",
"c",
".",
"ns",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"VersionedParams",
"(",
"&",
"opts",
",",
"api",
".",
"Scheme",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"\n",
"}"
] | // List takes label and field selectors, and returns the list of horizontalPodAutoscalers that match those selectors. | [
"List",
"takes",
"label",
"and",
"field",
"selectors",
"and",
"returns",
"the",
"list",
"of",
"horizontalPodAutoscalers",
"that",
"match",
"those",
"selectors",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go#L56-L60 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go | Get | func (c *horizontalPodAutoscalers) Get(name string) (result *extensions.HorizontalPodAutoscaler, err error) {
result = &extensions.HorizontalPodAutoscaler{}
err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Do().Into(result)
return
} | go | func (c *horizontalPodAutoscalers) Get(name string) (result *extensions.HorizontalPodAutoscaler, err error) {
result = &extensions.HorizontalPodAutoscaler{}
err = c.client.Get().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(name).Do().Into(result)
return
} | [
"func",
"(",
"c",
"*",
"horizontalPodAutoscalers",
")",
"Get",
"(",
"name",
"string",
")",
"(",
"result",
"*",
"extensions",
".",
"HorizontalPodAutoscaler",
",",
"err",
"error",
")",
"{",
"result",
"=",
"&",
"extensions",
".",
"HorizontalPodAutoscaler",
"{",
"}",
"\n",
"err",
"=",
"c",
".",
"client",
".",
"Get",
"(",
")",
".",
"Namespace",
"(",
"c",
".",
"ns",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Name",
"(",
"name",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"\n",
"}"
] | // Get takes the name of the horizontalPodAutoscaler, and returns the corresponding HorizontalPodAutoscaler object, and an error if it occurs | [
"Get",
"takes",
"the",
"name",
"of",
"the",
"horizontalPodAutoscaler",
"and",
"returns",
"the",
"corresponding",
"HorizontalPodAutoscaler",
"object",
"and",
"an",
"error",
"if",
"it",
"occurs"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go#L63-L67 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go | Update | func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
result = &extensions.HorizontalPodAutoscaler{}
err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).Body(horizontalPodAutoscaler).Do().Into(result)
return
} | go | func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *extensions.HorizontalPodAutoscaler) (result *extensions.HorizontalPodAutoscaler, err error) {
result = &extensions.HorizontalPodAutoscaler{}
err = c.client.Put().Namespace(c.ns).Resource("horizontalPodAutoscalers").Name(horizontalPodAutoscaler.Name).Body(horizontalPodAutoscaler).Do().Into(result)
return
} | [
"func",
"(",
"c",
"*",
"horizontalPodAutoscalers",
")",
"Update",
"(",
"horizontalPodAutoscaler",
"*",
"extensions",
".",
"HorizontalPodAutoscaler",
")",
"(",
"result",
"*",
"extensions",
".",
"HorizontalPodAutoscaler",
",",
"err",
"error",
")",
"{",
"result",
"=",
"&",
"extensions",
".",
"HorizontalPodAutoscaler",
"{",
"}",
"\n",
"err",
"=",
"c",
".",
"client",
".",
"Put",
"(",
")",
".",
"Namespace",
"(",
"c",
".",
"ns",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Name",
"(",
"horizontalPodAutoscaler",
".",
"Name",
")",
".",
"Body",
"(",
"horizontalPodAutoscaler",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"\n",
"}"
] | // Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if it occurs. | [
"Update",
"takes",
"the",
"representation",
"of",
"a",
"horizontalPodAutoscaler",
"and",
"updates",
"it",
".",
"Returns",
"the",
"server",
"s",
"representation",
"of",
"the",
"horizontalPodAutoscaler",
"and",
"an",
"error",
"if",
"it",
"occurs",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/horizontalpodautoscaler.go#L82-L86 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/nodes.go | List | func (c *nodes) List(opts api.ListOptions) (*api.NodeList, error) {
result := &api.NodeList{}
err := c.r.Get().Resource(c.resourceName()).VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
return result, err
} | go | func (c *nodes) List(opts api.ListOptions) (*api.NodeList, error) {
result := &api.NodeList{}
err := c.r.Get().Resource(c.resourceName()).VersionedParams(&opts, api.ParameterCodec).Do().Into(result)
return result, err
} | [
"func",
"(",
"c",
"*",
"nodes",
")",
"List",
"(",
"opts",
"api",
".",
"ListOptions",
")",
"(",
"*",
"api",
".",
"NodeList",
",",
"error",
")",
"{",
"result",
":=",
"&",
"api",
".",
"NodeList",
"{",
"}",
"\n",
"err",
":=",
"c",
".",
"r",
".",
"Get",
"(",
")",
".",
"Resource",
"(",
"c",
".",
"resourceName",
"(",
")",
")",
".",
"VersionedParams",
"(",
"&",
"opts",
",",
"api",
".",
"ParameterCodec",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // List takes a selector, and returns the list of nodes that match that selector in the cluster. | [
"List",
"takes",
"a",
"selector",
"and",
"returns",
"the",
"list",
"of",
"nodes",
"that",
"match",
"that",
"selector",
"in",
"the",
"cluster",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/nodes.go#L61-L65 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/fake_handler.go | ValidateRequest | func (f *FakeHandler) ValidateRequest(t TestInterface, expectedPath, expectedMethod string, body *string) {
f.lock.Lock()
defer f.lock.Unlock()
if f.requestCount != 1 {
t.Logf("Expected 1 call, but got %v. Only the last call is recorded and checked.", f.requestCount)
}
f.hasBeenChecked = true
expectURL, err := url.Parse(expectedPath)
if err != nil {
t.Errorf("Couldn't parse %v as a URL.", expectedPath)
}
if f.RequestReceived == nil {
t.Errorf("Unexpected nil request received for %s", expectedPath)
return
}
if f.RequestReceived.URL.Path != expectURL.Path {
t.Errorf("Unexpected request path for request %#v, received: %q, expected: %q", f.RequestReceived, f.RequestReceived.URL.Path, expectURL.Path)
}
if e, a := expectURL.Query(), f.RequestReceived.URL.Query(); !reflect.DeepEqual(e, a) {
t.Errorf("Unexpected query for request %#v, received: %q, expected: %q", f.RequestReceived, a, e)
}
if f.RequestReceived.Method != expectedMethod {
t.Errorf("Unexpected method: %q, expected: %q", f.RequestReceived.Method, expectedMethod)
}
if body != nil {
if *body != f.RequestBody {
t.Errorf("Received body:\n%s\n Doesn't match expected body:\n%s", f.RequestBody, *body)
}
}
} | go | func (f *FakeHandler) ValidateRequest(t TestInterface, expectedPath, expectedMethod string, body *string) {
f.lock.Lock()
defer f.lock.Unlock()
if f.requestCount != 1 {
t.Logf("Expected 1 call, but got %v. Only the last call is recorded and checked.", f.requestCount)
}
f.hasBeenChecked = true
expectURL, err := url.Parse(expectedPath)
if err != nil {
t.Errorf("Couldn't parse %v as a URL.", expectedPath)
}
if f.RequestReceived == nil {
t.Errorf("Unexpected nil request received for %s", expectedPath)
return
}
if f.RequestReceived.URL.Path != expectURL.Path {
t.Errorf("Unexpected request path for request %#v, received: %q, expected: %q", f.RequestReceived, f.RequestReceived.URL.Path, expectURL.Path)
}
if e, a := expectURL.Query(), f.RequestReceived.URL.Query(); !reflect.DeepEqual(e, a) {
t.Errorf("Unexpected query for request %#v, received: %q, expected: %q", f.RequestReceived, a, e)
}
if f.RequestReceived.Method != expectedMethod {
t.Errorf("Unexpected method: %q, expected: %q", f.RequestReceived.Method, expectedMethod)
}
if body != nil {
if *body != f.RequestBody {
t.Errorf("Received body:\n%s\n Doesn't match expected body:\n%s", f.RequestBody, *body)
}
}
} | [
"func",
"(",
"f",
"*",
"FakeHandler",
")",
"ValidateRequest",
"(",
"t",
"TestInterface",
",",
"expectedPath",
",",
"expectedMethod",
"string",
",",
"body",
"*",
"string",
")",
"{",
"f",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"f",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"f",
".",
"requestCount",
"!=",
"1",
"{",
"t",
".",
"Logf",
"(",
"\"",
"\"",
",",
"f",
".",
"requestCount",
")",
"\n",
"}",
"\n",
"f",
".",
"hasBeenChecked",
"=",
"true",
"\n\n",
"expectURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"expectedPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"expectedPath",
")",
"\n",
"}",
"\n",
"if",
"f",
".",
"RequestReceived",
"==",
"nil",
"{",
"t",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"expectedPath",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"f",
".",
"RequestReceived",
".",
"URL",
".",
"Path",
"!=",
"expectURL",
".",
"Path",
"{",
"t",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
"RequestReceived",
",",
"f",
".",
"RequestReceived",
".",
"URL",
".",
"Path",
",",
"expectURL",
".",
"Path",
")",
"\n",
"}",
"\n",
"if",
"e",
",",
"a",
":=",
"expectURL",
".",
"Query",
"(",
")",
",",
"f",
".",
"RequestReceived",
".",
"URL",
".",
"Query",
"(",
")",
";",
"!",
"reflect",
".",
"DeepEqual",
"(",
"e",
",",
"a",
")",
"{",
"t",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
"RequestReceived",
",",
"a",
",",
"e",
")",
"\n",
"}",
"\n",
"if",
"f",
".",
"RequestReceived",
".",
"Method",
"!=",
"expectedMethod",
"{",
"t",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
"RequestReceived",
".",
"Method",
",",
"expectedMethod",
")",
"\n",
"}",
"\n",
"if",
"body",
"!=",
"nil",
"{",
"if",
"*",
"body",
"!=",
"f",
".",
"RequestBody",
"{",
"t",
".",
"Errorf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\"",
",",
"f",
".",
"RequestBody",
",",
"*",
"body",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // ValidateRequest verifies that FakeHandler received a request with expected path, method, and body. | [
"ValidateRequest",
"verifies",
"that",
"FakeHandler",
"received",
"a",
"request",
"with",
"expected",
"path",
"method",
"and",
"body",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/util/fake_handler.go#L89-L119 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rollback.go | watchRollbackEvent | func watchRollbackEvent(w watch.Interface) string {
signals := make(chan os.Signal, 1)
signal.Notify(signals, os.Interrupt, os.Kill, syscall.SIGTERM)
for {
select {
case event, ok := <-w.ResultChan():
if !ok {
return ""
}
obj, ok := event.Object.(*api.Event)
if !ok {
w.Stop()
return ""
}
isRollback, result := isRollbackEvent(obj)
if isRollback {
w.Stop()
return result
}
case <-signals:
w.Stop()
}
}
} | go | func watchRollbackEvent(w watch.Interface) string {
signals := make(chan os.Signal, 1)
signal.Notify(signals, os.Interrupt, os.Kill, syscall.SIGTERM)
for {
select {
case event, ok := <-w.ResultChan():
if !ok {
return ""
}
obj, ok := event.Object.(*api.Event)
if !ok {
w.Stop()
return ""
}
isRollback, result := isRollbackEvent(obj)
if isRollback {
w.Stop()
return result
}
case <-signals:
w.Stop()
}
}
} | [
"func",
"watchRollbackEvent",
"(",
"w",
"watch",
".",
"Interface",
")",
"string",
"{",
"signals",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"signals",
",",
"os",
".",
"Interrupt",
",",
"os",
".",
"Kill",
",",
"syscall",
".",
"SIGTERM",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"event",
",",
"ok",
":=",
"<-",
"w",
".",
"ResultChan",
"(",
")",
":",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"obj",
",",
"ok",
":=",
"event",
".",
"Object",
".",
"(",
"*",
"api",
".",
"Event",
")",
"\n",
"if",
"!",
"ok",
"{",
"w",
".",
"Stop",
"(",
")",
"\n",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"isRollback",
",",
"result",
":=",
"isRollbackEvent",
"(",
"obj",
")",
"\n",
"if",
"isRollback",
"{",
"w",
".",
"Stop",
"(",
")",
"\n",
"return",
"result",
"\n",
"}",
"\n",
"case",
"<-",
"signals",
":",
"w",
".",
"Stop",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // watchRollbackEvent watches for rollback events and returns rollback result | [
"watchRollbackEvent",
"watches",
"for",
"rollback",
"events",
"and",
"returns",
"rollback",
"result"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rollback.go#L80-L103 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rollback.go | isRollbackEvent | func isRollbackEvent(e *api.Event) (bool, string) {
rollbackEventReasons := []string{deploymentutil.RollbackRevisionNotFound, deploymentutil.RollbackTemplateUnchanged, deploymentutil.RollbackDone}
for _, reason := range rollbackEventReasons {
if e.Reason == reason {
if reason == deploymentutil.RollbackDone {
return true, "rolled back"
}
return true, fmt.Sprintf("skipped rollback (%s: %s)", e.Reason, e.Message)
}
}
return false, ""
} | go | func isRollbackEvent(e *api.Event) (bool, string) {
rollbackEventReasons := []string{deploymentutil.RollbackRevisionNotFound, deploymentutil.RollbackTemplateUnchanged, deploymentutil.RollbackDone}
for _, reason := range rollbackEventReasons {
if e.Reason == reason {
if reason == deploymentutil.RollbackDone {
return true, "rolled back"
}
return true, fmt.Sprintf("skipped rollback (%s: %s)", e.Reason, e.Message)
}
}
return false, ""
} | [
"func",
"isRollbackEvent",
"(",
"e",
"*",
"api",
".",
"Event",
")",
"(",
"bool",
",",
"string",
")",
"{",
"rollbackEventReasons",
":=",
"[",
"]",
"string",
"{",
"deploymentutil",
".",
"RollbackRevisionNotFound",
",",
"deploymentutil",
".",
"RollbackTemplateUnchanged",
",",
"deploymentutil",
".",
"RollbackDone",
"}",
"\n",
"for",
"_",
",",
"reason",
":=",
"range",
"rollbackEventReasons",
"{",
"if",
"e",
".",
"Reason",
"==",
"reason",
"{",
"if",
"reason",
"==",
"deploymentutil",
".",
"RollbackDone",
"{",
"return",
"true",
",",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"true",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"Reason",
",",
"e",
".",
"Message",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"\"",
"\"",
"\n",
"}"
] | // isRollbackEvent checks if the input event is about rollback, and returns true and
// related result string back if it is. | [
"isRollbackEvent",
"checks",
"if",
"the",
"input",
"event",
"is",
"about",
"rollback",
"and",
"returns",
"true",
"and",
"related",
"result",
"string",
"back",
"if",
"it",
"is",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubectl/rollback.go#L107-L118 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go | isResourceGuaranteed | func isResourceGuaranteed(container *api.Container, resource api.ResourceName) bool {
// A container resource is guaranteed if its request == limit.
// If request == limit, the user is very confident of resource consumption.
req, hasReq := container.Resources.Requests[resource]
limit, hasLimit := container.Resources.Limits[resource]
if !hasReq || !hasLimit {
return false
}
return req.Cmp(limit) == 0 && req.Value() != 0
} | go | func isResourceGuaranteed(container *api.Container, resource api.ResourceName) bool {
// A container resource is guaranteed if its request == limit.
// If request == limit, the user is very confident of resource consumption.
req, hasReq := container.Resources.Requests[resource]
limit, hasLimit := container.Resources.Limits[resource]
if !hasReq || !hasLimit {
return false
}
return req.Cmp(limit) == 0 && req.Value() != 0
} | [
"func",
"isResourceGuaranteed",
"(",
"container",
"*",
"api",
".",
"Container",
",",
"resource",
"api",
".",
"ResourceName",
")",
"bool",
"{",
"// A container resource is guaranteed if its request == limit.",
"// If request == limit, the user is very confident of resource consumption.",
"req",
",",
"hasReq",
":=",
"container",
".",
"Resources",
".",
"Requests",
"[",
"resource",
"]",
"\n",
"limit",
",",
"hasLimit",
":=",
"container",
".",
"Resources",
".",
"Limits",
"[",
"resource",
"]",
"\n",
"if",
"!",
"hasReq",
"||",
"!",
"hasLimit",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"req",
".",
"Cmp",
"(",
"limit",
")",
"==",
"0",
"&&",
"req",
".",
"Value",
"(",
")",
"!=",
"0",
"\n",
"}"
] | // isResourceGuaranteed returns true if the container's resource requirements are Guaranteed. | [
"isResourceGuaranteed",
"returns",
"true",
"if",
"the",
"container",
"s",
"resource",
"requirements",
"are",
"Guaranteed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go#L30-L39 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go | isResourceBestEffort | func isResourceBestEffort(container *api.Container, resource api.ResourceName) bool {
// A container resource is best-effort if its request is unspecified or 0.
// If a request is specified, then the user expects some kind of resource guarantee.
req, hasReq := container.Resources.Requests[resource]
return !hasReq || req.Value() == 0
} | go | func isResourceBestEffort(container *api.Container, resource api.ResourceName) bool {
// A container resource is best-effort if its request is unspecified or 0.
// If a request is specified, then the user expects some kind of resource guarantee.
req, hasReq := container.Resources.Requests[resource]
return !hasReq || req.Value() == 0
} | [
"func",
"isResourceBestEffort",
"(",
"container",
"*",
"api",
".",
"Container",
",",
"resource",
"api",
".",
"ResourceName",
")",
"bool",
"{",
"// A container resource is best-effort if its request is unspecified or 0.",
"// If a request is specified, then the user expects some kind of resource guarantee.",
"req",
",",
"hasReq",
":=",
"container",
".",
"Resources",
".",
"Requests",
"[",
"resource",
"]",
"\n",
"return",
"!",
"hasReq",
"||",
"req",
".",
"Value",
"(",
")",
"==",
"0",
"\n",
"}"
] | // isResourceBestEffort returns true if the container's resource requirements are best-effort. | [
"isResourceBestEffort",
"returns",
"true",
"if",
"the",
"container",
"s",
"resource",
"requirements",
"are",
"best",
"-",
"effort",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go#L42-L47 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go | GetQoS | func GetQoS(container *api.Container) map[api.ResourceName]string {
resourceToQoS := map[api.ResourceName]string{}
for resource := range allResources(container) {
switch {
case isResourceGuaranteed(container, resource):
resourceToQoS[resource] = Guaranteed
case isResourceBestEffort(container, resource):
resourceToQoS[resource] = BestEffort
default:
resourceToQoS[resource] = Burstable
}
}
return resourceToQoS
} | go | func GetQoS(container *api.Container) map[api.ResourceName]string {
resourceToQoS := map[api.ResourceName]string{}
for resource := range allResources(container) {
switch {
case isResourceGuaranteed(container, resource):
resourceToQoS[resource] = Guaranteed
case isResourceBestEffort(container, resource):
resourceToQoS[resource] = BestEffort
default:
resourceToQoS[resource] = Burstable
}
}
return resourceToQoS
} | [
"func",
"GetQoS",
"(",
"container",
"*",
"api",
".",
"Container",
")",
"map",
"[",
"api",
".",
"ResourceName",
"]",
"string",
"{",
"resourceToQoS",
":=",
"map",
"[",
"api",
".",
"ResourceName",
"]",
"string",
"{",
"}",
"\n",
"for",
"resource",
":=",
"range",
"allResources",
"(",
"container",
")",
"{",
"switch",
"{",
"case",
"isResourceGuaranteed",
"(",
"container",
",",
"resource",
")",
":",
"resourceToQoS",
"[",
"resource",
"]",
"=",
"Guaranteed",
"\n",
"case",
"isResourceBestEffort",
"(",
"container",
",",
"resource",
")",
":",
"resourceToQoS",
"[",
"resource",
"]",
"=",
"BestEffort",
"\n",
"default",
":",
"resourceToQoS",
"[",
"resource",
"]",
"=",
"Burstable",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"resourceToQoS",
"\n",
"}"
] | // GetQos returns a mapping of resource name to QoS class of a container | [
"GetQos",
"returns",
"a",
"mapping",
"of",
"resource",
"name",
"to",
"QoS",
"class",
"of",
"a",
"container"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go#L50-L63 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go | allResources | func allResources(container *api.Container) map[api.ResourceName]bool {
resources := map[api.ResourceName]bool{}
for _, resource := range supportedComputeResources {
resources[resource] = false
}
for resource := range container.Resources.Requests {
resources[resource] = true
}
for resource := range container.Resources.Limits {
resources[resource] = true
}
return resources
} | go | func allResources(container *api.Container) map[api.ResourceName]bool {
resources := map[api.ResourceName]bool{}
for _, resource := range supportedComputeResources {
resources[resource] = false
}
for resource := range container.Resources.Requests {
resources[resource] = true
}
for resource := range container.Resources.Limits {
resources[resource] = true
}
return resources
} | [
"func",
"allResources",
"(",
"container",
"*",
"api",
".",
"Container",
")",
"map",
"[",
"api",
".",
"ResourceName",
"]",
"bool",
"{",
"resources",
":=",
"map",
"[",
"api",
".",
"ResourceName",
"]",
"bool",
"{",
"}",
"\n",
"for",
"_",
",",
"resource",
":=",
"range",
"supportedComputeResources",
"{",
"resources",
"[",
"resource",
"]",
"=",
"false",
"\n",
"}",
"\n",
"for",
"resource",
":=",
"range",
"container",
".",
"Resources",
".",
"Requests",
"{",
"resources",
"[",
"resource",
"]",
"=",
"true",
"\n",
"}",
"\n",
"for",
"resource",
":=",
"range",
"container",
".",
"Resources",
".",
"Limits",
"{",
"resources",
"[",
"resource",
"]",
"=",
"true",
"\n",
"}",
"\n",
"return",
"resources",
"\n",
"}"
] | // allResources returns a set of all possible resources whose mapped key value is true if present on the container | [
"allResources",
"returns",
"a",
"set",
"of",
"all",
"possible",
"resources",
"whose",
"mapped",
"key",
"value",
"is",
"true",
"if",
"present",
"on",
"the",
"container"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/util/qos.go#L72-L84 | train |
kubernetes-retired/contrib | election/lib/election.go | NewSimpleElection | func NewSimpleElection(electionId, id string, callback func(leader string), c client.Interface) (*leaderelection.LeaderElector, error) {
return NewElection(electionId, id, api.NamespaceDefault, 10*time.Second, callback, c)
} | go | func NewSimpleElection(electionId, id string, callback func(leader string), c client.Interface) (*leaderelection.LeaderElector, error) {
return NewElection(electionId, id, api.NamespaceDefault, 10*time.Second, callback, c)
} | [
"func",
"NewSimpleElection",
"(",
"electionId",
",",
"id",
"string",
",",
"callback",
"func",
"(",
"leader",
"string",
")",
",",
"c",
"client",
".",
"Interface",
")",
"(",
"*",
"leaderelection",
".",
"LeaderElector",
",",
"error",
")",
"{",
"return",
"NewElection",
"(",
"electionId",
",",
"id",
",",
"api",
".",
"NamespaceDefault",
",",
"10",
"*",
"time",
".",
"Second",
",",
"callback",
",",
"c",
")",
"\n",
"}"
] | // NewSimpleElection creates an election, it defaults namespace to 'default' and ttl to 10s | [
"NewSimpleElection",
"creates",
"an",
"election",
"it",
"defaults",
"namespace",
"to",
"default",
"and",
"ttl",
"to",
"10s"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/election/lib/election.go#L56-L58 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/errors/etcd/etcd.go | InterpretUpdateError | func InterpretUpdateError(err error, qualifiedResource unversioned.GroupResource, name string) error {
switch {
case storage.IsTestFailed(err), storage.IsNodeExist(err):
return errors.NewConflict(qualifiedResource, name, err)
case storage.IsUnreachable(err):
return errors.NewServerTimeout(qualifiedResource, "update", 2) // TODO: make configurable or handled at a higher level
default:
return err
}
} | go | func InterpretUpdateError(err error, qualifiedResource unversioned.GroupResource, name string) error {
switch {
case storage.IsTestFailed(err), storage.IsNodeExist(err):
return errors.NewConflict(qualifiedResource, name, err)
case storage.IsUnreachable(err):
return errors.NewServerTimeout(qualifiedResource, "update", 2) // TODO: make configurable or handled at a higher level
default:
return err
}
} | [
"func",
"InterpretUpdateError",
"(",
"err",
"error",
",",
"qualifiedResource",
"unversioned",
".",
"GroupResource",
",",
"name",
"string",
")",
"error",
"{",
"switch",
"{",
"case",
"storage",
".",
"IsTestFailed",
"(",
"err",
")",
",",
"storage",
".",
"IsNodeExist",
"(",
"err",
")",
":",
"return",
"errors",
".",
"NewConflict",
"(",
"qualifiedResource",
",",
"name",
",",
"err",
")",
"\n",
"case",
"storage",
".",
"IsUnreachable",
"(",
"err",
")",
":",
"return",
"errors",
".",
"NewServerTimeout",
"(",
"qualifiedResource",
",",
"\"",
"\"",
",",
"2",
")",
"// TODO: make configurable or handled at a higher level",
"\n",
"default",
":",
"return",
"err",
"\n",
"}",
"\n",
"}"
] | // InterpretUpdateError converts a generic error on a update
// operation into the appropriate API error. | [
"InterpretUpdateError",
"converts",
"a",
"generic",
"error",
"on",
"a",
"update",
"operation",
"into",
"the",
"appropriate",
"API",
"error",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/errors/etcd/etcd.go#L66-L75 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/controller.go | Requeue | func (c *Controller) Requeue(obj interface{}) error {
return c.config.Queue.AddIfNotPresent(cache.Deltas{
cache.Delta{
Type: cache.Sync,
Object: obj,
},
})
} | go | func (c *Controller) Requeue(obj interface{}) error {
return c.config.Queue.AddIfNotPresent(cache.Deltas{
cache.Delta{
Type: cache.Sync,
Object: obj,
},
})
} | [
"func",
"(",
"c",
"*",
"Controller",
")",
"Requeue",
"(",
"obj",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"c",
".",
"config",
".",
"Queue",
".",
"AddIfNotPresent",
"(",
"cache",
".",
"Deltas",
"{",
"cache",
".",
"Delta",
"{",
"Type",
":",
"cache",
".",
"Sync",
",",
"Object",
":",
"obj",
",",
"}",
",",
"}",
")",
"\n",
"}"
] | // Requeue adds the provided object back into the queue if it does not already exist. | [
"Requeue",
"adds",
"the",
"provided",
"object",
"back",
"into",
"the",
"queue",
"if",
"it",
"does",
"not",
"already",
"exist",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/controller/framework/controller.go#L106-L113 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/core_client.go | NewForConfig | func NewForConfig(c *unversioned.Config) (*CoreClient, error) {
config := *c
if err := setConfigDefaults(&config); err != nil {
return nil, err
}
client, err := unversioned.RESTClientFor(&config)
if err != nil {
return nil, err
}
return &CoreClient{client}, nil
} | go | func NewForConfig(c *unversioned.Config) (*CoreClient, error) {
config := *c
if err := setConfigDefaults(&config); err != nil {
return nil, err
}
client, err := unversioned.RESTClientFor(&config)
if err != nil {
return nil, err
}
return &CoreClient{client}, nil
} | [
"func",
"NewForConfig",
"(",
"c",
"*",
"unversioned",
".",
"Config",
")",
"(",
"*",
"CoreClient",
",",
"error",
")",
"{",
"config",
":=",
"*",
"c",
"\n",
"if",
"err",
":=",
"setConfigDefaults",
"(",
"&",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"unversioned",
".",
"RESTClientFor",
"(",
"&",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"CoreClient",
"{",
"client",
"}",
",",
"nil",
"\n",
"}"
] | // NewForConfig creates a new CoreClient for the given config. | [
"NewForConfig",
"creates",
"a",
"new",
"CoreClient",
"for",
"the",
"given",
"config",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/core_client.go#L114-L124 | train |
kubernetes-retired/contrib | service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/core_client.go | NewForConfigOrDie | func NewForConfigOrDie(c *unversioned.Config) *CoreClient {
client, err := NewForConfig(c)
if err != nil {
panic(err)
}
return client
} | go | func NewForConfigOrDie(c *unversioned.Config) *CoreClient {
client, err := NewForConfig(c)
if err != nil {
panic(err)
}
return client
} | [
"func",
"NewForConfigOrDie",
"(",
"c",
"*",
"unversioned",
".",
"Config",
")",
"*",
"CoreClient",
"{",
"client",
",",
"err",
":=",
"NewForConfig",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"client",
"\n",
"}"
] | // NewForConfigOrDie creates a new CoreClient for the given config and
// panics if there is an error in the config. | [
"NewForConfigOrDie",
"creates",
"a",
"new",
"CoreClient",
"for",
"the",
"given",
"config",
"and",
"panics",
"if",
"there",
"is",
"an",
"error",
"in",
"the",
"config",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/core_client.go#L128-L134 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/memory_policy.go | isMemoryBestEffort | func isMemoryBestEffort(container *api.Container) bool {
// A container is memory best-effort if its memory request is unspecified or 0.
// If a request is specified, then the user expects some kind of resource guarantee.
return container.Resources.Requests.Memory().Value() == 0
} | go | func isMemoryBestEffort(container *api.Container) bool {
// A container is memory best-effort if its memory request is unspecified or 0.
// If a request is specified, then the user expects some kind of resource guarantee.
return container.Resources.Requests.Memory().Value() == 0
} | [
"func",
"isMemoryBestEffort",
"(",
"container",
"*",
"api",
".",
"Container",
")",
"bool",
"{",
"// A container is memory best-effort if its memory request is unspecified or 0.",
"// If a request is specified, then the user expects some kind of resource guarantee.",
"return",
"container",
".",
"Resources",
".",
"Requests",
".",
"Memory",
"(",
")",
".",
"Value",
"(",
")",
"==",
"0",
"\n",
"}"
] | // isMemoryBestEffort returns true if the container's memory requirements are best-effort. | [
"isMemoryBestEffort",
"returns",
"true",
"if",
"the",
"container",
"s",
"memory",
"requirements",
"are",
"best",
"-",
"effort",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/memory_policy.go#L30-L34 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/memory_policy.go | isMemoryGuaranteed | func isMemoryGuaranteed(container *api.Container) bool {
// A container is memory guaranteed if its memory request == memory limit.
// If memory request == memory limit, the user is very confident of resource consumption.
memoryRequest := container.Resources.Requests.Memory()
memoryLimit := container.Resources.Limits.Memory()
return (*memoryRequest).Cmp(*memoryLimit) == 0 && memoryRequest.Value() != 0
} | go | func isMemoryGuaranteed(container *api.Container) bool {
// A container is memory guaranteed if its memory request == memory limit.
// If memory request == memory limit, the user is very confident of resource consumption.
memoryRequest := container.Resources.Requests.Memory()
memoryLimit := container.Resources.Limits.Memory()
return (*memoryRequest).Cmp(*memoryLimit) == 0 && memoryRequest.Value() != 0
} | [
"func",
"isMemoryGuaranteed",
"(",
"container",
"*",
"api",
".",
"Container",
")",
"bool",
"{",
"// A container is memory guaranteed if its memory request == memory limit.",
"// If memory request == memory limit, the user is very confident of resource consumption.",
"memoryRequest",
":=",
"container",
".",
"Resources",
".",
"Requests",
".",
"Memory",
"(",
")",
"\n",
"memoryLimit",
":=",
"container",
".",
"Resources",
".",
"Limits",
".",
"Memory",
"(",
")",
"\n",
"return",
"(",
"*",
"memoryRequest",
")",
".",
"Cmp",
"(",
"*",
"memoryLimit",
")",
"==",
"0",
"&&",
"memoryRequest",
".",
"Value",
"(",
")",
"!=",
"0",
"\n",
"}"
] | // isMemoryGuaranteed returns true if the container's memory requirements are Guaranteed. | [
"isMemoryGuaranteed",
"returns",
"true",
"if",
"the",
"container",
"s",
"memory",
"requirements",
"are",
"Guaranteed",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/kubelet/qos/memory_policy.go#L37-L43 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/mux.go | loop | func (m *Broadcaster) loop() {
// Deliberately not catching crashes here. Yes, bring down the process if there's a
// bug in watch.Broadcaster.
for {
event, ok := <-m.incoming
if !ok {
break
}
if event.Type == internalRunFunctionMarker {
event.Object.(functionFakeRuntimeObject)()
continue
}
m.distribute(event)
}
m.closeAll()
m.distributing.Done()
} | go | func (m *Broadcaster) loop() {
// Deliberately not catching crashes here. Yes, bring down the process if there's a
// bug in watch.Broadcaster.
for {
event, ok := <-m.incoming
if !ok {
break
}
if event.Type == internalRunFunctionMarker {
event.Object.(functionFakeRuntimeObject)()
continue
}
m.distribute(event)
}
m.closeAll()
m.distributing.Done()
} | [
"func",
"(",
"m",
"*",
"Broadcaster",
")",
"loop",
"(",
")",
"{",
"// Deliberately not catching crashes here. Yes, bring down the process if there's a",
"// bug in watch.Broadcaster.",
"for",
"{",
"event",
",",
"ok",
":=",
"<-",
"m",
".",
"incoming",
"\n",
"if",
"!",
"ok",
"{",
"break",
"\n",
"}",
"\n",
"if",
"event",
".",
"Type",
"==",
"internalRunFunctionMarker",
"{",
"event",
".",
"Object",
".",
"(",
"functionFakeRuntimeObject",
")",
"(",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"m",
".",
"distribute",
"(",
"event",
")",
"\n",
"}",
"\n",
"m",
".",
"closeAll",
"(",
")",
"\n",
"m",
".",
"distributing",
".",
"Done",
"(",
")",
"\n",
"}"
] | // loop receives from m.incoming and distributes to all watchers. | [
"loop",
"receives",
"from",
"m",
".",
"incoming",
"and",
"distributes",
"to",
"all",
"watchers",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/mux.go#L197-L213 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go | Get | func (c *services) Get(name string) (result *api.Service, err error) {
result = &api.Service{}
err = c.r.Get().Namespace(c.ns).Resource("services").Name(name).Do().Into(result)
return
} | go | func (c *services) Get(name string) (result *api.Service, err error) {
result = &api.Service{}
err = c.r.Get().Namespace(c.ns).Resource("services").Name(name).Do().Into(result)
return
} | [
"func",
"(",
"c",
"*",
"services",
")",
"Get",
"(",
"name",
"string",
")",
"(",
"result",
"*",
"api",
".",
"Service",
",",
"err",
"error",
")",
"{",
"result",
"=",
"&",
"api",
".",
"Service",
"{",
"}",
"\n",
"err",
"=",
"c",
".",
"r",
".",
"Get",
"(",
")",
".",
"Namespace",
"(",
"c",
".",
"ns",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Name",
"(",
"name",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"\n",
"}"
] | // Get returns information about a particular service. | [
"Get",
"returns",
"information",
"about",
"a",
"particular",
"service",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go#L65-L69 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go | Create | func (c *services) Create(svc *api.Service) (result *api.Service, err error) {
result = &api.Service{}
err = c.r.Post().Namespace(c.ns).Resource("services").Body(svc).Do().Into(result)
return
} | go | func (c *services) Create(svc *api.Service) (result *api.Service, err error) {
result = &api.Service{}
err = c.r.Post().Namespace(c.ns).Resource("services").Body(svc).Do().Into(result)
return
} | [
"func",
"(",
"c",
"*",
"services",
")",
"Create",
"(",
"svc",
"*",
"api",
".",
"Service",
")",
"(",
"result",
"*",
"api",
".",
"Service",
",",
"err",
"error",
")",
"{",
"result",
"=",
"&",
"api",
".",
"Service",
"{",
"}",
"\n",
"err",
"=",
"c",
".",
"r",
".",
"Post",
"(",
")",
".",
"Namespace",
"(",
"c",
".",
"ns",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Body",
"(",
"svc",
")",
".",
"Do",
"(",
")",
".",
"Into",
"(",
"result",
")",
"\n",
"return",
"\n",
"}"
] | // Create creates a new service. | [
"Create",
"creates",
"a",
"new",
"service",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go#L72-L76 | train |
kubernetes-retired/contrib | scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go | ProxyGet | func (c *services) ProxyGet(scheme, name, port, path string, params map[string]string) ResponseWrapper {
request := c.r.Get().
Prefix("proxy").
Namespace(c.ns).
Resource("services").
Name(util.JoinSchemeNamePort(scheme, name, port)).
Suffix(path)
for k, v := range params {
request = request.Param(k, v)
}
return request
} | go | func (c *services) ProxyGet(scheme, name, port, path string, params map[string]string) ResponseWrapper {
request := c.r.Get().
Prefix("proxy").
Namespace(c.ns).
Resource("services").
Name(util.JoinSchemeNamePort(scheme, name, port)).
Suffix(path)
for k, v := range params {
request = request.Param(k, v)
}
return request
} | [
"func",
"(",
"c",
"*",
"services",
")",
"ProxyGet",
"(",
"scheme",
",",
"name",
",",
"port",
",",
"path",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"ResponseWrapper",
"{",
"request",
":=",
"c",
".",
"r",
".",
"Get",
"(",
")",
".",
"Prefix",
"(",
"\"",
"\"",
")",
".",
"Namespace",
"(",
"c",
".",
"ns",
")",
".",
"Resource",
"(",
"\"",
"\"",
")",
".",
"Name",
"(",
"util",
".",
"JoinSchemeNamePort",
"(",
"scheme",
",",
"name",
",",
"port",
")",
")",
".",
"Suffix",
"(",
"path",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"params",
"{",
"request",
"=",
"request",
".",
"Param",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"return",
"request",
"\n",
"}"
] | // ProxyGet returns a response of the service by calling it through the proxy. | [
"ProxyGet",
"returns",
"a",
"response",
"of",
"the",
"service",
"by",
"calling",
"it",
"through",
"the",
"proxy",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/scale-demo/Godeps/_workspace/src/k8s.io/kubernetes/pkg/client/unversioned/services.go#L101-L112 | train |
kubernetes-retired/contrib | release-notes/Godeps/_workspace/src/golang.org/x/oauth2/clientcredentials/clientcredentials.go | Token | func (c *Config) Token(ctx context.Context) (*oauth2.Token, error) {
return retrieveToken(ctx, c, url.Values{
"grant_type": {"client_credentials"},
"scope": internal.CondVal(strings.Join(c.Scopes, " ")),
})
} | go | func (c *Config) Token(ctx context.Context) (*oauth2.Token, error) {
return retrieveToken(ctx, c, url.Values{
"grant_type": {"client_credentials"},
"scope": internal.CondVal(strings.Join(c.Scopes, " ")),
})
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Token",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"oauth2",
".",
"Token",
",",
"error",
")",
"{",
"return",
"retrieveToken",
"(",
"ctx",
",",
"c",
",",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"{",
"\"",
"\"",
"}",
",",
"\"",
"\"",
":",
"internal",
".",
"CondVal",
"(",
"strings",
".",
"Join",
"(",
"c",
".",
"Scopes",
",",
"\"",
"\"",
")",
")",
",",
"}",
")",
"\n",
"}"
] | // Token uses client credentials to retreive a token.
// The HTTP client to use is derived from the context.
// If nil, http.DefaultClient is used. | [
"Token",
"uses",
"client",
"credentials",
"to",
"retreive",
"a",
"token",
".",
"The",
"HTTP",
"client",
"to",
"use",
"is",
"derived",
"from",
"the",
"context",
".",
"If",
"nil",
"http",
".",
"DefaultClient",
"is",
"used",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/release-notes/Godeps/_workspace/src/golang.org/x/oauth2/clientcredentials/clientcredentials.go#L72-L77 | train |
kubernetes-retired/contrib | release-notes/Godeps/_workspace/src/golang.org/x/oauth2/clientcredentials/clientcredentials.go | TokenSource | func (c *Config) TokenSource(ctx context.Context) oauth2.TokenSource {
source := &tokenSource{
ctx: ctx,
conf: c,
}
return oauth2.ReuseTokenSource(nil, source)
} | go | func (c *Config) TokenSource(ctx context.Context) oauth2.TokenSource {
source := &tokenSource{
ctx: ctx,
conf: c,
}
return oauth2.ReuseTokenSource(nil, source)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"TokenSource",
"(",
"ctx",
"context",
".",
"Context",
")",
"oauth2",
".",
"TokenSource",
"{",
"source",
":=",
"&",
"tokenSource",
"{",
"ctx",
":",
"ctx",
",",
"conf",
":",
"c",
",",
"}",
"\n",
"return",
"oauth2",
".",
"ReuseTokenSource",
"(",
"nil",
",",
"source",
")",
"\n",
"}"
] | // TokenSource returns a TokenSource that returns t until t expires,
// automatically refreshing it as necessary using the provided context and the
// client ID and client secret.
//
// Most users will use Config.Client instead. | [
"TokenSource",
"returns",
"a",
"TokenSource",
"that",
"returns",
"t",
"until",
"t",
"expires",
"automatically",
"refreshing",
"it",
"as",
"necessary",
"using",
"the",
"provided",
"context",
"and",
"the",
"client",
"ID",
"and",
"client",
"secret",
".",
"Most",
"users",
"will",
"use",
"Config",
".",
"Client",
"instead",
"."
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/release-notes/Godeps/_workspace/src/golang.org/x/oauth2/clientcredentials/clientcredentials.go#L92-L98 | train |
kubernetes-retired/contrib | service-loadbalancer/loadbalancer_log.go | newSyslogServer | func newSyslogServer(path string) (*syslogServer, error) {
glog.Infof("Starting syslog server for haproxy using %v as socket", path)
// remove the socket file if exists
os.Remove(path)
server := &syslogServer{syslog.NewServer()}
server.AddHandler(newHandler())
err := server.Listen(path)
if err != nil {
return nil, err
}
return server, nil
} | go | func newSyslogServer(path string) (*syslogServer, error) {
glog.Infof("Starting syslog server for haproxy using %v as socket", path)
// remove the socket file if exists
os.Remove(path)
server := &syslogServer{syslog.NewServer()}
server.AddHandler(newHandler())
err := server.Listen(path)
if err != nil {
return nil, err
}
return server, nil
} | [
"func",
"newSyslogServer",
"(",
"path",
"string",
")",
"(",
"*",
"syslogServer",
",",
"error",
")",
"{",
"glog",
".",
"Infof",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"// remove the socket file if exists",
"os",
".",
"Remove",
"(",
"path",
")",
"\n\n",
"server",
":=",
"&",
"syslogServer",
"{",
"syslog",
".",
"NewServer",
"(",
")",
"}",
"\n",
"server",
".",
"AddHandler",
"(",
"newHandler",
"(",
")",
")",
"\n",
"err",
":=",
"server",
".",
"Listen",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"server",
",",
"nil",
"\n",
"}"
] | // newSyslogServer start a syslog server using a unix socket to listen for connections | [
"newSyslogServer",
"start",
"a",
"syslog",
"server",
"using",
"a",
"unix",
"socket",
"to",
"listen",
"for",
"connections"
] | 89f6948e24578fed2a90a87871b2263729f90ac3 | https://github.com/kubernetes-retired/contrib/blob/89f6948e24578fed2a90a87871b2263729f90ac3/service-loadbalancer/loadbalancer_log.go#L37-L50 | train |
Subsets and Splits