id int32 0 167k | 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 listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
16,900 | coreos/coreos-cloudinit | config/validate/validate.go | parseCloudConfig | func parseCloudConfig(cfg []byte, report *Report) (node, error) {
yaml.UnmarshalMappingKeyTransform = func(nameIn string) (nameOut string) {
return nameIn
}
// unmarshal the config into an implicitly-typed form. The yaml library
// will implicitly convert types into their normalized form
// (e.g. 0744 -> 484, off -> false).
var weak map[interface{}]interface{}
if err := yaml.Unmarshal(cfg, &weak); err != nil {
matches := yamlLineError.FindStringSubmatch(err.Error())
if len(matches) == 3 {
line, err := strconv.Atoi(matches[1])
if err != nil {
return node{}, err
}
msg := matches[2]
report.Error(line, msg)
return node{}, nil
}
matches = yamlError.FindStringSubmatch(err.Error())
if len(matches) == 2 {
report.Error(1, matches[1])
return node{}, nil
}
return node{}, errors.New("couldn't parse yaml error")
}
w := NewNode(weak, NewContext(cfg))
w = normalizeNodeNames(w, report)
// unmarshal the config into the explicitly-typed form.
yaml.UnmarshalMappingKeyTransform = func(nameIn string) (nameOut string) {
return strings.Replace(nameIn, "-", "_", -1)
}
var strong config.CloudConfig
if err := yaml.Unmarshal([]byte(cfg), &strong); err != nil {
return node{}, err
}
s := NewNode(strong, NewContext(cfg))
// coerceNodes weak nodes and strong nodes. strong nodes replace weak nodes
// if they are compatible types (this happens when the yaml library
// converts the input).
// (e.g. weak 484 is replaced by strong 0744, weak 4 is not replaced by
// strong false)
return coerceNodes(w, s), nil
} | go | func parseCloudConfig(cfg []byte, report *Report) (node, error) {
yaml.UnmarshalMappingKeyTransform = func(nameIn string) (nameOut string) {
return nameIn
}
// unmarshal the config into an implicitly-typed form. The yaml library
// will implicitly convert types into their normalized form
// (e.g. 0744 -> 484, off -> false).
var weak map[interface{}]interface{}
if err := yaml.Unmarshal(cfg, &weak); err != nil {
matches := yamlLineError.FindStringSubmatch(err.Error())
if len(matches) == 3 {
line, err := strconv.Atoi(matches[1])
if err != nil {
return node{}, err
}
msg := matches[2]
report.Error(line, msg)
return node{}, nil
}
matches = yamlError.FindStringSubmatch(err.Error())
if len(matches) == 2 {
report.Error(1, matches[1])
return node{}, nil
}
return node{}, errors.New("couldn't parse yaml error")
}
w := NewNode(weak, NewContext(cfg))
w = normalizeNodeNames(w, report)
// unmarshal the config into the explicitly-typed form.
yaml.UnmarshalMappingKeyTransform = func(nameIn string) (nameOut string) {
return strings.Replace(nameIn, "-", "_", -1)
}
var strong config.CloudConfig
if err := yaml.Unmarshal([]byte(cfg), &strong); err != nil {
return node{}, err
}
s := NewNode(strong, NewContext(cfg))
// coerceNodes weak nodes and strong nodes. strong nodes replace weak nodes
// if they are compatible types (this happens when the yaml library
// converts the input).
// (e.g. weak 484 is replaced by strong 0744, weak 4 is not replaced by
// strong false)
return coerceNodes(w, s), nil
} | [
"func",
"parseCloudConfig",
"(",
"cfg",
"[",
"]",
"byte",
",",
"report",
"*",
"Report",
")",
"(",
"node",
",",
"error",
")",
"{",
"yaml",
".",
"UnmarshalMappingKeyTransform",
"=",
"func",
"(",
"nameIn",
"string",
")",
"(",
"nameOut",
"string",
")",
"{",
... | // parseCloudConfig parses the provided config into a node structure and logs
// any parsing issues into the provided report. Unrecoverable errors are
// returned as an error. | [
"parseCloudConfig",
"parses",
"the",
"provided",
"config",
"into",
"a",
"node",
"structure",
"and",
"logs",
"any",
"parsing",
"issues",
"into",
"the",
"provided",
"report",
".",
"Unrecoverable",
"errors",
"are",
"returned",
"as",
"an",
"error",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/validate.go#L77-L124 |
16,901 | coreos/coreos-cloudinit | config/validate/validate.go | normalizeNodeNames | func normalizeNodeNames(node node, report *Report) node {
if strings.Contains(node.name, "-") {
// TODO(crawford): Enable this message once the new validator hits stable.
//report.Info(node.line, fmt.Sprintf("%q uses '-' instead of '_'", node.name))
node.name = strings.Replace(node.name, "-", "_", -1)
}
for i := range node.children {
node.children[i] = normalizeNodeNames(node.children[i], report)
}
return node
} | go | func normalizeNodeNames(node node, report *Report) node {
if strings.Contains(node.name, "-") {
// TODO(crawford): Enable this message once the new validator hits stable.
//report.Info(node.line, fmt.Sprintf("%q uses '-' instead of '_'", node.name))
node.name = strings.Replace(node.name, "-", "_", -1)
}
for i := range node.children {
node.children[i] = normalizeNodeNames(node.children[i], report)
}
return node
} | [
"func",
"normalizeNodeNames",
"(",
"node",
"node",
",",
"report",
"*",
"Report",
")",
"node",
"{",
"if",
"strings",
".",
"Contains",
"(",
"node",
".",
"name",
",",
"\"",
"\"",
")",
"{",
"// TODO(crawford): Enable this message once the new validator hits stable.",
... | // normalizeNodeNames replaces all occurences of '-' with '_' within key names
// and makes a note of each replacement in the report. | [
"normalizeNodeNames",
"replaces",
"all",
"occurences",
"of",
"-",
"with",
"_",
"within",
"key",
"names",
"and",
"makes",
"a",
"note",
"of",
"each",
"replacement",
"in",
"the",
"report",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/validate.go#L154-L164 |
16,902 | mitchellh/reflectwalk | reflectwalk.go | Walk | func Walk(data, walker interface{}) (err error) {
v := reflect.ValueOf(data)
ew, ok := walker.(EnterExitWalker)
if ok {
err = ew.Enter(WalkLoc)
}
if err == nil {
err = walk(v, walker)
}
if ok && err == nil {
err = ew.Exit(WalkLoc)
}
return
} | go | func Walk(data, walker interface{}) (err error) {
v := reflect.ValueOf(data)
ew, ok := walker.(EnterExitWalker)
if ok {
err = ew.Enter(WalkLoc)
}
if err == nil {
err = walk(v, walker)
}
if ok && err == nil {
err = ew.Exit(WalkLoc)
}
return
} | [
"func",
"Walk",
"(",
"data",
",",
"walker",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"data",
")",
"\n",
"ew",
",",
"ok",
":=",
"walker",
".",
"(",
"EnterExitWalker",
")",
"\n",
"if",
"o... | // Walk takes an arbitrary value and an interface and traverses the
// value, calling callbacks on the interface if they are supported.
// The interface should implement one or more of the walker interfaces
// in this package, such as PrimitiveWalker, StructWalker, etc. | [
"Walk",
"takes",
"an",
"arbitrary",
"value",
"and",
"an",
"interface",
"and",
"traverses",
"the",
"value",
"calling",
"callbacks",
"on",
"the",
"interface",
"if",
"they",
"are",
"supported",
".",
"The",
"interface",
"should",
"implement",
"one",
"or",
"more",
... | 3e2c75dfad4fbf904b58782a80fd595c760ad185 | https://github.com/mitchellh/reflectwalk/blob/3e2c75dfad4fbf904b58782a80fd595c760ad185/reflectwalk.go#L84-L100 |
16,903 | pires/go-proxyproto | header.go | EqualTo | func (header *Header) EqualTo(q *Header) bool {
if header == nil || q == nil {
return false
}
if header.Command.IsLocal() {
return true
}
return header.TransportProtocol == q.TransportProtocol &&
header.SourceAddress.String() == q.SourceAddress.String() &&
header.DestinationAddress.String() == q.DestinationAddress.String() &&
header.SourcePort == q.SourcePort &&
header.DestinationPort == q.DestinationPort
} | go | func (header *Header) EqualTo(q *Header) bool {
if header == nil || q == nil {
return false
}
if header.Command.IsLocal() {
return true
}
return header.TransportProtocol == q.TransportProtocol &&
header.SourceAddress.String() == q.SourceAddress.String() &&
header.DestinationAddress.String() == q.DestinationAddress.String() &&
header.SourcePort == q.SourcePort &&
header.DestinationPort == q.DestinationPort
} | [
"func",
"(",
"header",
"*",
"Header",
")",
"EqualTo",
"(",
"q",
"*",
"Header",
")",
"bool",
"{",
"if",
"header",
"==",
"nil",
"||",
"q",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"header",
".",
"Command",
".",
"IsLocal",
"(",
")... | // EqualTo returns true if headers are equivalent, false otherwise. | [
"EqualTo",
"returns",
"true",
"if",
"headers",
"are",
"equivalent",
"false",
"otherwise",
"."
] | 4d51b51e3bfc23ac5f4384478ff64940f34a5d63 | https://github.com/pires/go-proxyproto/blob/4d51b51e3bfc23ac5f4384478ff64940f34a5d63/header.go#L45-L57 |
16,904 | pires/go-proxyproto | header.go | WriteTo | func (header *Header) WriteTo(w io.Writer) (int64, error) {
switch header.Version {
case 1:
return header.writeVersion1(w)
case 2:
return header.writeVersion2(w)
default:
return 0, ErrUnknownProxyProtocolVersion
}
} | go | func (header *Header) WriteTo(w io.Writer) (int64, error) {
switch header.Version {
case 1:
return header.writeVersion1(w)
case 2:
return header.writeVersion2(w)
default:
return 0, ErrUnknownProxyProtocolVersion
}
} | [
"func",
"(",
"header",
"*",
"Header",
")",
"WriteTo",
"(",
"w",
"io",
".",
"Writer",
")",
"(",
"int64",
",",
"error",
")",
"{",
"switch",
"header",
".",
"Version",
"{",
"case",
"1",
":",
"return",
"header",
".",
"writeVersion1",
"(",
"w",
")",
"\n"... | // WriteTo renders a proxy protocol header in a format to write over the wire. | [
"WriteTo",
"renders",
"a",
"proxy",
"protocol",
"header",
"in",
"a",
"format",
"to",
"write",
"over",
"the",
"wire",
"."
] | 4d51b51e3bfc23ac5f4384478ff64940f34a5d63 | https://github.com/pires/go-proxyproto/blob/4d51b51e3bfc23ac5f4384478ff64940f34a5d63/header.go#L60-L69 |
16,905 | pires/go-proxyproto | header.go | Read | func Read(reader *bufio.Reader) (*Header, error) {
// In order to improve speed for small non-PROXYed packets, take a peek at the first byte alone.
if b1, err := reader.Peek(1); err == nil && (bytes.Equal(b1[:1], SIGV1[:1]) || bytes.Equal(b1[:1], SIGV2[:1])) {
if signature, err := reader.Peek(5); err == nil && bytes.Equal(signature[:5], SIGV1) {
return parseVersion1(reader)
} else if signature, err := reader.Peek(12); err == nil && bytes.Equal(signature[:12], SIGV2) {
return parseVersion2(reader)
}
}
return nil, ErrNoProxyProtocol
} | go | func Read(reader *bufio.Reader) (*Header, error) {
// In order to improve speed for small non-PROXYed packets, take a peek at the first byte alone.
if b1, err := reader.Peek(1); err == nil && (bytes.Equal(b1[:1], SIGV1[:1]) || bytes.Equal(b1[:1], SIGV2[:1])) {
if signature, err := reader.Peek(5); err == nil && bytes.Equal(signature[:5], SIGV1) {
return parseVersion1(reader)
} else if signature, err := reader.Peek(12); err == nil && bytes.Equal(signature[:12], SIGV2) {
return parseVersion2(reader)
}
}
return nil, ErrNoProxyProtocol
} | [
"func",
"Read",
"(",
"reader",
"*",
"bufio",
".",
"Reader",
")",
"(",
"*",
"Header",
",",
"error",
")",
"{",
"// In order to improve speed for small non-PROXYed packets, take a peek at the first byte alone.",
"if",
"b1",
",",
"err",
":=",
"reader",
".",
"Peek",
"(",... | // Read identifies the proxy protocol version and reads the remaining of
// the header, accordingly.
//
// If proxy protocol header signature is not present, the reader buffer remains untouched
// and is safe for reading outside of this code.
//
// If proxy protocol header signature is present but an error is raised while processing
// the remaining header, assume the reader buffer to be in a corrupt state.
// Also, this operation will block until enough bytes are available for peeking. | [
"Read",
"identifies",
"the",
"proxy",
"protocol",
"version",
"and",
"reads",
"the",
"remaining",
"of",
"the",
"header",
"accordingly",
".",
"If",
"proxy",
"protocol",
"header",
"signature",
"is",
"not",
"present",
"the",
"reader",
"buffer",
"remains",
"untouched... | 4d51b51e3bfc23ac5f4384478ff64940f34a5d63 | https://github.com/pires/go-proxyproto/blob/4d51b51e3bfc23ac5f4384478ff64940f34a5d63/header.go#L80-L91 |
16,906 | pires/go-proxyproto | header.go | ReadTimeout | func ReadTimeout(reader *bufio.Reader, timeout time.Duration) (*Header, error) {
type header struct {
h *Header
e error
}
read := make(chan *header, 1)
go func() {
h := &header{}
h.h, h.e = Read(reader)
read <- h
}()
timer := time.NewTimer(timeout)
select {
case result := <-read:
timer.Stop()
return result.h, result.e
case <-timer.C:
return nil, ErrNoProxyProtocol
}
} | go | func ReadTimeout(reader *bufio.Reader, timeout time.Duration) (*Header, error) {
type header struct {
h *Header
e error
}
read := make(chan *header, 1)
go func() {
h := &header{}
h.h, h.e = Read(reader)
read <- h
}()
timer := time.NewTimer(timeout)
select {
case result := <-read:
timer.Stop()
return result.h, result.e
case <-timer.C:
return nil, ErrNoProxyProtocol
}
} | [
"func",
"ReadTimeout",
"(",
"reader",
"*",
"bufio",
".",
"Reader",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"Header",
",",
"error",
")",
"{",
"type",
"header",
"struct",
"{",
"h",
"*",
"Header",
"\n",
"e",
"error",
"\n",
"}",
"\n",
"... | // ReadTimeout acts as Read but takes a timeout. If that timeout is reached, it's assumed
// there's no proxy protocol header. | [
"ReadTimeout",
"acts",
"as",
"Read",
"but",
"takes",
"a",
"timeout",
".",
"If",
"that",
"timeout",
"is",
"reached",
"it",
"s",
"assumed",
"there",
"s",
"no",
"proxy",
"protocol",
"header",
"."
] | 4d51b51e3bfc23ac5f4384478ff64940f34a5d63 | https://github.com/pires/go-proxyproto/blob/4d51b51e3bfc23ac5f4384478ff64940f34a5d63/header.go#L95-L116 |
16,907 | pixiv/go-libjpeg | rgb/rgb.go | NewImage | func NewImage(r image.Rectangle) *Image {
w, h := r.Dx(), r.Dy()
return &Image{Pix: make([]uint8, 3*w*h), Stride: 3 * w, Rect: r}
} | go | func NewImage(r image.Rectangle) *Image {
w, h := r.Dx(), r.Dy()
return &Image{Pix: make([]uint8, 3*w*h), Stride: 3 * w, Rect: r}
} | [
"func",
"NewImage",
"(",
"r",
"image",
".",
"Rectangle",
")",
"*",
"Image",
"{",
"w",
",",
"h",
":=",
"r",
".",
"Dx",
"(",
")",
",",
"r",
".",
"Dy",
"(",
")",
"\n",
"return",
"&",
"Image",
"{",
"Pix",
":",
"make",
"(",
"[",
"]",
"uint8",
",... | // NewImage allocates and returns RGB image | [
"NewImage",
"allocates",
"and",
"returns",
"RGB",
"image"
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/rgb/rgb.go#L21-L24 |
16,908 | pixiv/go-libjpeg | rgb/rgb.go | At | func (p *Image) At(x, y int) color.Color {
return p.RGBAAt(x, y)
} | go | func (p *Image) At(x, y int) color.Color {
return p.RGBAAt(x, y)
} | [
"func",
"(",
"p",
"*",
"Image",
")",
"At",
"(",
"x",
",",
"y",
"int",
")",
"color",
".",
"Color",
"{",
"return",
"p",
".",
"RGBAAt",
"(",
"x",
",",
"y",
")",
"\n",
"}"
] | // At implements image.Image.At | [
"At",
"implements",
"image",
".",
"Image",
".",
"At"
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/rgb/rgb.go#L37-L39 |
16,909 | pixiv/go-libjpeg | rgb/rgb.go | RGBA | func (c RGB) RGBA() (r, g, b, a uint32) {
r = uint32(c.R)
r |= r << 8
g = uint32(c.G)
g |= g << 8
b = uint32(c.B)
b |= b << 8
a = uint32(0xFFFF)
return
} | go | func (c RGB) RGBA() (r, g, b, a uint32) {
r = uint32(c.R)
r |= r << 8
g = uint32(c.G)
g |= g << 8
b = uint32(c.B)
b |= b << 8
a = uint32(0xFFFF)
return
} | [
"func",
"(",
"c",
"RGB",
")",
"RGBA",
"(",
")",
"(",
"r",
",",
"g",
",",
"b",
",",
"a",
"uint32",
")",
"{",
"r",
"=",
"uint32",
"(",
"c",
".",
"R",
")",
"\n",
"r",
"|=",
"r",
"<<",
"8",
"\n",
"g",
"=",
"uint32",
"(",
"c",
".",
"G",
")... | // RGBA implements Color.RGBA | [
"RGBA",
"implements",
"Color",
".",
"RGBA"
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/rgb/rgb.go#L67-L76 |
16,910 | pixiv/go-libjpeg | jpeg/decompress.go | Decode | func Decode(r io.Reader, options *DecoderOptions) (dest image.Image, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
return nil, errors.New("allocation failed")
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
setupDecoderOptions(dinfo, options)
switch dinfo.num_components {
case 1:
if dinfo.jpeg_color_space != C.JCS_GRAYSCALE {
return nil, errors.New("Image has unsupported colorspace")
}
dest, err = decodeGray(dinfo)
case 3:
switch dinfo.jpeg_color_space {
case C.JCS_YCbCr:
dest, err = decodeYCbCr(dinfo)
case C.JCS_RGB:
dest, err = decodeRGB(dinfo)
default:
return nil, errors.New("Image has unsupported colorspace")
}
}
return
} | go | func Decode(r io.Reader, options *DecoderOptions) (dest image.Image, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
return nil, errors.New("allocation failed")
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
setupDecoderOptions(dinfo, options)
switch dinfo.num_components {
case 1:
if dinfo.jpeg_color_space != C.JCS_GRAYSCALE {
return nil, errors.New("Image has unsupported colorspace")
}
dest, err = decodeGray(dinfo)
case 3:
switch dinfo.jpeg_color_space {
case C.JCS_YCbCr:
dest, err = decodeYCbCr(dinfo)
case C.JCS_RGB:
dest, err = decodeRGB(dinfo)
default:
return nil, errors.New("Image has unsupported colorspace")
}
}
return
} | [
"func",
"Decode",
"(",
"r",
"io",
".",
"Reader",
",",
"options",
"*",
"DecoderOptions",
")",
"(",
"dest",
"image",
".",
"Image",
",",
"err",
"error",
")",
"{",
"dinfo",
":=",
"newDecompress",
"(",
"r",
")",
"\n",
"if",
"dinfo",
"==",
"nil",
"{",
"r... | // Decode reads a JPEG data stream from r and returns decoded image as an image.Image.
// Output image has YCbCr colors or 8bit Grayscale. | [
"Decode",
"reads",
"a",
"JPEG",
"data",
"stream",
"from",
"r",
"and",
"returns",
"decoded",
"image",
"as",
"an",
"image",
".",
"Image",
".",
"Output",
"image",
"has",
"YCbCr",
"colors",
"or",
"8bit",
"Grayscale",
"."
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/decompress.go#L140-L176 |
16,911 | pixiv/go-libjpeg | jpeg/decompress.go | DecodeIntoRGB | func DecodeIntoRGB(r io.Reader, options *DecoderOptions) (dest *rgb.Image, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
return nil, errors.New("allocation failed")
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
setupDecoderOptions(dinfo, options)
C.jpeg_calc_output_dimensions(dinfo)
dest = rgb.NewImage(image.Rect(0, 0, int(dinfo.output_width), int(dinfo.output_height)))
dinfo.out_color_space = C.JCS_RGB
readScanLines(dinfo, dest.Pix, dest.Stride)
return
} | go | func DecodeIntoRGB(r io.Reader, options *DecoderOptions) (dest *rgb.Image, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
return nil, errors.New("allocation failed")
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
setupDecoderOptions(dinfo, options)
C.jpeg_calc_output_dimensions(dinfo)
dest = rgb.NewImage(image.Rect(0, 0, int(dinfo.output_width), int(dinfo.output_height)))
dinfo.out_color_space = C.JCS_RGB
readScanLines(dinfo, dest.Pix, dest.Stride)
return
} | [
"func",
"DecodeIntoRGB",
"(",
"r",
"io",
".",
"Reader",
",",
"options",
"*",
"DecoderOptions",
")",
"(",
"dest",
"*",
"rgb",
".",
"Image",
",",
"err",
"error",
")",
"{",
"dinfo",
":=",
"newDecompress",
"(",
"r",
")",
"\n",
"if",
"dinfo",
"==",
"nil",... | // DecodeIntoRGB reads a JPEG data stream from r and returns decoded image as an rgb.Image with RGB colors. | [
"DecodeIntoRGB",
"reads",
"a",
"JPEG",
"data",
"stream",
"from",
"r",
"and",
"returns",
"decoded",
"image",
"as",
"an",
"rgb",
".",
"Image",
"with",
"RGB",
"colors",
"."
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/decompress.go#L269-L294 |
16,912 | pixiv/go-libjpeg | jpeg/decompress.go | DecodeIntoRGBA | func DecodeIntoRGBA(r io.Reader, options *DecoderOptions) (dest *image.RGBA, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
return nil, errors.New("allocation failed")
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
setupDecoderOptions(dinfo, options)
C.jpeg_calc_output_dimensions(dinfo)
dest = image.NewRGBA(image.Rect(0, 0, int(dinfo.output_width), int(dinfo.output_height)))
colorSpace := getJCS_EXT_RGBA()
if colorSpace == C.JCS_UNKNOWN {
return nil, errors.New("JCS_EXT_RGBA is not supported (probably built without libjpeg-turbo)")
}
dinfo.out_color_space = colorSpace
readScanLines(dinfo, dest.Pix, dest.Stride)
return
} | go | func DecodeIntoRGBA(r io.Reader, options *DecoderOptions) (dest *image.RGBA, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
return nil, errors.New("allocation failed")
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
setupDecoderOptions(dinfo, options)
C.jpeg_calc_output_dimensions(dinfo)
dest = image.NewRGBA(image.Rect(0, 0, int(dinfo.output_width), int(dinfo.output_height)))
colorSpace := getJCS_EXT_RGBA()
if colorSpace == C.JCS_UNKNOWN {
return nil, errors.New("JCS_EXT_RGBA is not supported (probably built without libjpeg-turbo)")
}
dinfo.out_color_space = colorSpace
readScanLines(dinfo, dest.Pix, dest.Stride)
return
} | [
"func",
"DecodeIntoRGBA",
"(",
"r",
"io",
".",
"Reader",
",",
"options",
"*",
"DecoderOptions",
")",
"(",
"dest",
"*",
"image",
".",
"RGBA",
",",
"err",
"error",
")",
"{",
"dinfo",
":=",
"newDecompress",
"(",
"r",
")",
"\n",
"if",
"dinfo",
"==",
"nil... | // DecodeIntoRGBA reads a JPEG data stream from r and returns decoded image as an image.RGBA with RGBA colors.
// This function only works with libjpeg-turbo, not libjpeg. | [
"DecodeIntoRGBA",
"reads",
"a",
"JPEG",
"data",
"stream",
"from",
"r",
"and",
"returns",
"decoded",
"image",
"as",
"an",
"image",
".",
"RGBA",
"with",
"RGBA",
"colors",
".",
"This",
"function",
"only",
"works",
"with",
"libjpeg",
"-",
"turbo",
"not",
"libj... | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/decompress.go#L298-L328 |
16,913 | pixiv/go-libjpeg | jpeg/decompress.go | DecodeConfig | func DecodeConfig(r io.Reader) (config image.Config, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
err = errors.New("allocation failed")
return
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
config = image.Config{
ColorModel: color.YCbCrModel,
Width: int(dinfo.image_width),
Height: int(dinfo.image_height),
}
return
} | go | func DecodeConfig(r io.Reader) (config image.Config, err error) {
dinfo := newDecompress(r)
if dinfo == nil {
err = errors.New("allocation failed")
return
}
defer destroyDecompress(dinfo)
// Recover panic
defer func() {
if r := recover(); r != nil {
if _, ok := r.(error); !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
C.jpeg_read_header(dinfo, C.TRUE)
config = image.Config{
ColorModel: color.YCbCrModel,
Width: int(dinfo.image_width),
Height: int(dinfo.image_height),
}
return
} | [
"func",
"DecodeConfig",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"config",
"image",
".",
"Config",
",",
"err",
"error",
")",
"{",
"dinfo",
":=",
"newDecompress",
"(",
"r",
")",
"\n",
"if",
"dinfo",
"==",
"nil",
"{",
"err",
"=",
"errors",
".",
"New"... | // DecodeConfig returns the color model and dimensions of a JPEG image without decoding the entire image. | [
"DecodeConfig",
"returns",
"the",
"color",
"model",
"and",
"dimensions",
"of",
"a",
"JPEG",
"image",
"without",
"decoding",
"the",
"entire",
"image",
"."
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/decompress.go#L340-L365 |
16,914 | pixiv/go-libjpeg | jpeg/decompress.go | NewGrayAligned | func NewGrayAligned(r image.Rectangle) *image.Gray {
w, h := r.Dx(), r.Dy()
// TODO: check the padding size to minimize memory allocation.
stride := pad(w, alignSize) + alignSize
ph := pad(h, alignSize) + alignSize
pix := make([]uint8, stride*ph)
return &image.Gray{
Pix: pix,
Stride: stride,
Rect: r,
}
} | go | func NewGrayAligned(r image.Rectangle) *image.Gray {
w, h := r.Dx(), r.Dy()
// TODO: check the padding size to minimize memory allocation.
stride := pad(w, alignSize) + alignSize
ph := pad(h, alignSize) + alignSize
pix := make([]uint8, stride*ph)
return &image.Gray{
Pix: pix,
Stride: stride,
Rect: r,
}
} | [
"func",
"NewGrayAligned",
"(",
"r",
"image",
".",
"Rectangle",
")",
"*",
"image",
".",
"Gray",
"{",
"w",
",",
"h",
":=",
"r",
".",
"Dx",
"(",
")",
",",
"r",
".",
"Dy",
"(",
")",
"\n\n",
"// TODO: check the padding size to minimize memory allocation.",
"str... | // NewGrayAligned Allocates Grey image with padding.
// This func add an extra padding to cover overflow from decoding image. | [
"NewGrayAligned",
"Allocates",
"Grey",
"image",
"with",
"padding",
".",
"This",
"func",
"add",
"an",
"extra",
"padding",
"to",
"cover",
"overflow",
"from",
"decoding",
"image",
"."
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/decompress.go#L442-L455 |
16,915 | pixiv/go-libjpeg | jpeg/compress.go | Encode | func Encode(w io.Writer, src image.Image, opt *EncoderOptions) (err error) {
// Recover panic
defer func() {
if r := recover(); r != nil {
var ok bool
err, ok = r.(error)
if !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
cinfo := C.new_compress()
defer C.destroy_compress(cinfo)
dstManager := makeDestinationManager(w, cinfo)
defer releaseDestinationManager(dstManager)
switch s := src.(type) {
case *image.YCbCr:
err = encodeYCbCr(cinfo, s, opt)
case *image.Gray:
err = encodeGray(cinfo, s, opt)
case *image.RGBA:
err = encodeRGBA(cinfo, s, opt)
default:
return errors.New("unsupported image type")
}
return
} | go | func Encode(w io.Writer, src image.Image, opt *EncoderOptions) (err error) {
// Recover panic
defer func() {
if r := recover(); r != nil {
var ok bool
err, ok = r.(error)
if !ok {
err = fmt.Errorf("JPEG error: %v", r)
}
}
}()
cinfo := C.new_compress()
defer C.destroy_compress(cinfo)
dstManager := makeDestinationManager(w, cinfo)
defer releaseDestinationManager(dstManager)
switch s := src.(type) {
case *image.YCbCr:
err = encodeYCbCr(cinfo, s, opt)
case *image.Gray:
err = encodeGray(cinfo, s, opt)
case *image.RGBA:
err = encodeRGBA(cinfo, s, opt)
default:
return errors.New("unsupported image type")
}
return
} | [
"func",
"Encode",
"(",
"w",
"io",
".",
"Writer",
",",
"src",
"image",
".",
"Image",
",",
"opt",
"*",
"EncoderOptions",
")",
"(",
"err",
"error",
")",
"{",
"// Recover panic",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";"... | // Encode encodes src image and writes into w as JPEG format data. | [
"Encode",
"encodes",
"src",
"image",
"and",
"writes",
"into",
"w",
"as",
"JPEG",
"format",
"data",
"."
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/compress.go#L103-L133 |
16,916 | pixiv/go-libjpeg | jpeg/compress.go | encodeYCbCr | func encodeYCbCr(cinfo *C.struct_jpeg_compress_struct, src *image.YCbCr, p *EncoderOptions) (err error) {
// Set up compression parameters
cinfo.image_width = C.JDIMENSION(src.Bounds().Dx())
cinfo.image_height = C.JDIMENSION(src.Bounds().Dy())
cinfo.input_components = 3
cinfo.in_color_space = C.JCS_YCbCr
C.jpeg_set_defaults(cinfo)
setupEncoderOptions(cinfo, p)
compInfo := (*[3]C.jpeg_component_info)(unsafe.Pointer(cinfo.comp_info))
colorVDiv := 1
switch src.SubsampleRatio {
case image.YCbCrSubsampleRatio444:
// 1x1,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 1, 1
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
case image.YCbCrSubsampleRatio440:
// 1x2,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 1, 2
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
colorVDiv = 2
case image.YCbCrSubsampleRatio422:
// 2x1,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 2, 1
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
case image.YCbCrSubsampleRatio420:
// 2x2,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 2, 2
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
colorVDiv = 2
}
// libjpeg raw data in is in planar format, which avoids unnecessary
// planar->packed->planar conversions.
cinfo.raw_data_in = C.TRUE
// Start compression
C.jpeg_start_compress(cinfo, C.TRUE)
C.encode_ycbcr(
cinfo,
C.JSAMPROW(unsafe.Pointer(&src.Y[0])),
C.JSAMPROW(unsafe.Pointer(&src.Cb[0])),
C.JSAMPROW(unsafe.Pointer(&src.Cr[0])),
C.int(src.YStride),
C.int(src.CStride),
C.int(colorVDiv),
)
C.jpeg_finish_compress(cinfo)
return
} | go | func encodeYCbCr(cinfo *C.struct_jpeg_compress_struct, src *image.YCbCr, p *EncoderOptions) (err error) {
// Set up compression parameters
cinfo.image_width = C.JDIMENSION(src.Bounds().Dx())
cinfo.image_height = C.JDIMENSION(src.Bounds().Dy())
cinfo.input_components = 3
cinfo.in_color_space = C.JCS_YCbCr
C.jpeg_set_defaults(cinfo)
setupEncoderOptions(cinfo, p)
compInfo := (*[3]C.jpeg_component_info)(unsafe.Pointer(cinfo.comp_info))
colorVDiv := 1
switch src.SubsampleRatio {
case image.YCbCrSubsampleRatio444:
// 1x1,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 1, 1
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
case image.YCbCrSubsampleRatio440:
// 1x2,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 1, 2
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
colorVDiv = 2
case image.YCbCrSubsampleRatio422:
// 2x1,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 2, 1
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
case image.YCbCrSubsampleRatio420:
// 2x2,1x1,1x1
compInfo[Y].h_samp_factor, compInfo[Y].v_samp_factor = 2, 2
compInfo[Cb].h_samp_factor, compInfo[Cb].v_samp_factor = 1, 1
compInfo[Cr].h_samp_factor, compInfo[Cr].v_samp_factor = 1, 1
colorVDiv = 2
}
// libjpeg raw data in is in planar format, which avoids unnecessary
// planar->packed->planar conversions.
cinfo.raw_data_in = C.TRUE
// Start compression
C.jpeg_start_compress(cinfo, C.TRUE)
C.encode_ycbcr(
cinfo,
C.JSAMPROW(unsafe.Pointer(&src.Y[0])),
C.JSAMPROW(unsafe.Pointer(&src.Cb[0])),
C.JSAMPROW(unsafe.Pointer(&src.Cr[0])),
C.int(src.YStride),
C.int(src.CStride),
C.int(colorVDiv),
)
C.jpeg_finish_compress(cinfo)
return
} | [
"func",
"encodeYCbCr",
"(",
"cinfo",
"*",
"C",
".",
"struct_jpeg_compress_struct",
",",
"src",
"*",
"image",
".",
"YCbCr",
",",
"p",
"*",
"EncoderOptions",
")",
"(",
"err",
"error",
")",
"{",
"// Set up compression parameters",
"cinfo",
".",
"image_width",
"="... | // encode image.YCbCr | [
"encode",
"image",
".",
"YCbCr"
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/compress.go#L136-L190 |
16,917 | pixiv/go-libjpeg | jpeg/compress.go | encodeRGBA | func encodeRGBA(cinfo *C.struct_jpeg_compress_struct, src *image.RGBA, p *EncoderOptions) (err error) {
// Set up compression parameters
cinfo.image_width = C.JDIMENSION(src.Bounds().Dx())
cinfo.image_height = C.JDIMENSION(src.Bounds().Dy())
cinfo.input_components = 4
cinfo.in_color_space = getJCS_EXT_RGBA()
if cinfo.in_color_space == C.JCS_UNKNOWN {
return errors.New("JCS_EXT_RGBA is not supported (probably built without libjpeg-turbo)")
}
C.jpeg_set_defaults(cinfo)
setupEncoderOptions(cinfo, p)
// Start compression
C.jpeg_start_compress(cinfo, C.TRUE)
C.encode_rgba(cinfo, C.JSAMPROW(unsafe.Pointer(&src.Pix[0])), C.int(src.Stride))
C.jpeg_finish_compress(cinfo)
return
} | go | func encodeRGBA(cinfo *C.struct_jpeg_compress_struct, src *image.RGBA, p *EncoderOptions) (err error) {
// Set up compression parameters
cinfo.image_width = C.JDIMENSION(src.Bounds().Dx())
cinfo.image_height = C.JDIMENSION(src.Bounds().Dy())
cinfo.input_components = 4
cinfo.in_color_space = getJCS_EXT_RGBA()
if cinfo.in_color_space == C.JCS_UNKNOWN {
return errors.New("JCS_EXT_RGBA is not supported (probably built without libjpeg-turbo)")
}
C.jpeg_set_defaults(cinfo)
setupEncoderOptions(cinfo, p)
// Start compression
C.jpeg_start_compress(cinfo, C.TRUE)
C.encode_rgba(cinfo, C.JSAMPROW(unsafe.Pointer(&src.Pix[0])), C.int(src.Stride))
C.jpeg_finish_compress(cinfo)
return
} | [
"func",
"encodeRGBA",
"(",
"cinfo",
"*",
"C",
".",
"struct_jpeg_compress_struct",
",",
"src",
"*",
"image",
".",
"RGBA",
",",
"p",
"*",
"EncoderOptions",
")",
"(",
"err",
"error",
")",
"{",
"// Set up compression parameters",
"cinfo",
".",
"image_width",
"=",
... | // encode image.RGBA | [
"encode",
"image",
".",
"RGBA"
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/compress.go#L193-L211 |
16,918 | pixiv/go-libjpeg | jpeg/compress.go | encodeGray | func encodeGray(cinfo *C.struct_jpeg_compress_struct, src *image.Gray, p *EncoderOptions) (err error) {
// Set up compression parameters
cinfo.image_width = C.JDIMENSION(src.Bounds().Dx())
cinfo.image_height = C.JDIMENSION(src.Bounds().Dy())
cinfo.input_components = 1
cinfo.in_color_space = C.JCS_GRAYSCALE
C.jpeg_set_defaults(cinfo)
setupEncoderOptions(cinfo, p)
compInfo := (*C.jpeg_component_info)(unsafe.Pointer(cinfo.comp_info))
compInfo.h_samp_factor, compInfo.v_samp_factor = 1, 1
// libjpeg raw data in is in planar format, which avoids unnecessary
// planar->packed->planar conversions.
cinfo.raw_data_in = C.TRUE
// Start compression
C.jpeg_start_compress(cinfo, C.TRUE)
C.encode_gray(cinfo, C.JSAMPROW(unsafe.Pointer(&src.Pix[0])), C.int(src.Stride))
C.jpeg_finish_compress(cinfo)
return
} | go | func encodeGray(cinfo *C.struct_jpeg_compress_struct, src *image.Gray, p *EncoderOptions) (err error) {
// Set up compression parameters
cinfo.image_width = C.JDIMENSION(src.Bounds().Dx())
cinfo.image_height = C.JDIMENSION(src.Bounds().Dy())
cinfo.input_components = 1
cinfo.in_color_space = C.JCS_GRAYSCALE
C.jpeg_set_defaults(cinfo)
setupEncoderOptions(cinfo, p)
compInfo := (*C.jpeg_component_info)(unsafe.Pointer(cinfo.comp_info))
compInfo.h_samp_factor, compInfo.v_samp_factor = 1, 1
// libjpeg raw data in is in planar format, which avoids unnecessary
// planar->packed->planar conversions.
cinfo.raw_data_in = C.TRUE
// Start compression
C.jpeg_start_compress(cinfo, C.TRUE)
C.encode_gray(cinfo, C.JSAMPROW(unsafe.Pointer(&src.Pix[0])), C.int(src.Stride))
C.jpeg_finish_compress(cinfo)
return
} | [
"func",
"encodeGray",
"(",
"cinfo",
"*",
"C",
".",
"struct_jpeg_compress_struct",
",",
"src",
"*",
"image",
".",
"Gray",
",",
"p",
"*",
"EncoderOptions",
")",
"(",
"err",
"error",
")",
"{",
"// Set up compression parameters",
"cinfo",
".",
"image_width",
"=",
... | // encode image.Gray | [
"encode",
"image",
".",
"Gray"
] | 8a5e68b6ebaa424cd3916c4d1309b618318e9367 | https://github.com/pixiv/go-libjpeg/blob/8a5e68b6ebaa424cd3916c4d1309b618318e9367/jpeg/compress.go#L214-L236 |
16,919 | gambol99/go-marathon | residency.go | SetTaskLostBehavior | func (r *Residency) SetTaskLostBehavior(behavior TaskLostBehaviorType) *Residency {
r.TaskLostBehavior = behavior
return r
} | go | func (r *Residency) SetTaskLostBehavior(behavior TaskLostBehaviorType) *Residency {
r.TaskLostBehavior = behavior
return r
} | [
"func",
"(",
"r",
"*",
"Residency",
")",
"SetTaskLostBehavior",
"(",
"behavior",
"TaskLostBehaviorType",
")",
"*",
"Residency",
"{",
"r",
".",
"TaskLostBehavior",
"=",
"behavior",
"\n",
"return",
"r",
"\n",
"}"
] | // SetTaskLostBehavior sets the residency behavior | [
"SetTaskLostBehavior",
"sets",
"the",
"residency",
"behavior"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/residency.go#L39-L42 |
16,920 | gambol99/go-marathon | residency.go | SetRelaunchEscalationTimeout | func (r *Residency) SetRelaunchEscalationTimeout(timeout time.Duration) *Residency {
r.RelaunchEscalationTimeoutSeconds = int(timeout.Seconds())
return r
} | go | func (r *Residency) SetRelaunchEscalationTimeout(timeout time.Duration) *Residency {
r.RelaunchEscalationTimeoutSeconds = int(timeout.Seconds())
return r
} | [
"func",
"(",
"r",
"*",
"Residency",
")",
"SetRelaunchEscalationTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"Residency",
"{",
"r",
".",
"RelaunchEscalationTimeoutSeconds",
"=",
"int",
"(",
"timeout",
".",
"Seconds",
"(",
")",
")",
"\n",
"retu... | // SetRelaunchEscalationTimeout sets the residency relaunch escalation timeout with seconds precision | [
"SetRelaunchEscalationTimeout",
"sets",
"the",
"residency",
"relaunch",
"escalation",
"timeout",
"with",
"seconds",
"precision"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/residency.go#L45-L48 |
16,921 | gambol99/go-marathon | pod_scheduling.go | SetBackoff | func (p *PodBackoff) SetBackoff(backoffSeconds int) *PodBackoff {
p.Backoff = &backoffSeconds
return p
} | go | func (p *PodBackoff) SetBackoff(backoffSeconds int) *PodBackoff {
p.Backoff = &backoffSeconds
return p
} | [
"func",
"(",
"p",
"*",
"PodBackoff",
")",
"SetBackoff",
"(",
"backoffSeconds",
"int",
")",
"*",
"PodBackoff",
"{",
"p",
".",
"Backoff",
"=",
"&",
"backoffSeconds",
"\n",
"return",
"p",
"\n",
"}"
] | // SetBackoff sets the base backoff interval for failed pod launches, in seconds | [
"SetBackoff",
"sets",
"the",
"base",
"backoff",
"interval",
"for",
"failed",
"pod",
"launches",
"in",
"seconds"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L90-L93 |
16,922 | gambol99/go-marathon | pod_scheduling.go | SetBackoffFactor | func (p *PodBackoff) SetBackoffFactor(backoffFactor float64) *PodBackoff {
p.BackoffFactor = &backoffFactor
return p
} | go | func (p *PodBackoff) SetBackoffFactor(backoffFactor float64) *PodBackoff {
p.BackoffFactor = &backoffFactor
return p
} | [
"func",
"(",
"p",
"*",
"PodBackoff",
")",
"SetBackoffFactor",
"(",
"backoffFactor",
"float64",
")",
"*",
"PodBackoff",
"{",
"p",
".",
"BackoffFactor",
"=",
"&",
"backoffFactor",
"\n",
"return",
"p",
"\n",
"}"
] | // SetBackoffFactor sets the backoff interval growth factor for failed pod launches | [
"SetBackoffFactor",
"sets",
"the",
"backoff",
"interval",
"growth",
"factor",
"for",
"failed",
"pod",
"launches"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L96-L99 |
16,923 | gambol99/go-marathon | pod_scheduling.go | SetMaxLaunchDelay | func (p *PodBackoff) SetMaxLaunchDelay(maxLaunchDelaySeconds int) *PodBackoff {
p.MaxLaunchDelay = &maxLaunchDelaySeconds
return p
} | go | func (p *PodBackoff) SetMaxLaunchDelay(maxLaunchDelaySeconds int) *PodBackoff {
p.MaxLaunchDelay = &maxLaunchDelaySeconds
return p
} | [
"func",
"(",
"p",
"*",
"PodBackoff",
")",
"SetMaxLaunchDelay",
"(",
"maxLaunchDelaySeconds",
"int",
")",
"*",
"PodBackoff",
"{",
"p",
".",
"MaxLaunchDelay",
"=",
"&",
"maxLaunchDelaySeconds",
"\n",
"return",
"p",
"\n",
"}"
] | // SetMaxLaunchDelay sets the maximum backoff interval for failed pod launches, in seconds | [
"SetMaxLaunchDelay",
"sets",
"the",
"maximum",
"backoff",
"interval",
"for",
"failed",
"pod",
"launches",
"in",
"seconds"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L102-L105 |
16,924 | gambol99/go-marathon | pod_scheduling.go | SetMinimumHealthCapacity | func (p *PodUpgrade) SetMinimumHealthCapacity(capacity float64) *PodUpgrade {
p.MinimumHealthCapacity = &capacity
return p
} | go | func (p *PodUpgrade) SetMinimumHealthCapacity(capacity float64) *PodUpgrade {
p.MinimumHealthCapacity = &capacity
return p
} | [
"func",
"(",
"p",
"*",
"PodUpgrade",
")",
"SetMinimumHealthCapacity",
"(",
"capacity",
"float64",
")",
"*",
"PodUpgrade",
"{",
"p",
".",
"MinimumHealthCapacity",
"=",
"&",
"capacity",
"\n",
"return",
"p",
"\n",
"}"
] | // SetMinimumHealthCapacity sets the minimum amount of pod instances for healthy operation, expressed as a fraction of instance count | [
"SetMinimumHealthCapacity",
"sets",
"the",
"minimum",
"amount",
"of",
"pod",
"instances",
"for",
"healthy",
"operation",
"expressed",
"as",
"a",
"fraction",
"of",
"instance",
"count"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L108-L111 |
16,925 | gambol99/go-marathon | pod_scheduling.go | SetMaximumOverCapacity | func (p *PodUpgrade) SetMaximumOverCapacity(capacity float64) *PodUpgrade {
p.MaximumOverCapacity = &capacity
return p
} | go | func (p *PodUpgrade) SetMaximumOverCapacity(capacity float64) *PodUpgrade {
p.MaximumOverCapacity = &capacity
return p
} | [
"func",
"(",
"p",
"*",
"PodUpgrade",
")",
"SetMaximumOverCapacity",
"(",
"capacity",
"float64",
")",
"*",
"PodUpgrade",
"{",
"p",
".",
"MaximumOverCapacity",
"=",
"&",
"capacity",
"\n",
"return",
"p",
"\n",
"}"
] | // SetMaximumOverCapacity sets the maximum amount of pod instances above the instance count, expressed as a fraction of instance count | [
"SetMaximumOverCapacity",
"sets",
"the",
"maximum",
"amount",
"of",
"pod",
"instances",
"above",
"the",
"instance",
"count",
"expressed",
"as",
"a",
"fraction",
"of",
"instance",
"count"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L114-L117 |
16,926 | gambol99/go-marathon | pod_scheduling.go | SetBackoff | func (p *PodSchedulingPolicy) SetBackoff(backoff *PodBackoff) *PodSchedulingPolicy {
p.Backoff = backoff
return p
} | go | func (p *PodSchedulingPolicy) SetBackoff(backoff *PodBackoff) *PodSchedulingPolicy {
p.Backoff = backoff
return p
} | [
"func",
"(",
"p",
"*",
"PodSchedulingPolicy",
")",
"SetBackoff",
"(",
"backoff",
"*",
"PodBackoff",
")",
"*",
"PodSchedulingPolicy",
"{",
"p",
".",
"Backoff",
"=",
"backoff",
"\n",
"return",
"p",
"\n",
"}"
] | // SetBackoff sets the pod's backoff settings | [
"SetBackoff",
"sets",
"the",
"pod",
"s",
"backoff",
"settings"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L120-L123 |
16,927 | gambol99/go-marathon | pod_scheduling.go | SetUpgrade | func (p *PodSchedulingPolicy) SetUpgrade(upgrade *PodUpgrade) *PodSchedulingPolicy {
p.Upgrade = upgrade
return p
} | go | func (p *PodSchedulingPolicy) SetUpgrade(upgrade *PodUpgrade) *PodSchedulingPolicy {
p.Upgrade = upgrade
return p
} | [
"func",
"(",
"p",
"*",
"PodSchedulingPolicy",
")",
"SetUpgrade",
"(",
"upgrade",
"*",
"PodUpgrade",
")",
"*",
"PodSchedulingPolicy",
"{",
"p",
".",
"Upgrade",
"=",
"upgrade",
"\n",
"return",
"p",
"\n",
"}"
] | // SetUpgrade sets the pod's upgrade settings | [
"SetUpgrade",
"sets",
"the",
"pod",
"s",
"upgrade",
"settings"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L126-L129 |
16,928 | gambol99/go-marathon | pod_scheduling.go | SetPlacement | func (p *PodSchedulingPolicy) SetPlacement(placement *PodPlacement) *PodSchedulingPolicy {
p.Placement = placement
return p
} | go | func (p *PodSchedulingPolicy) SetPlacement(placement *PodPlacement) *PodSchedulingPolicy {
p.Placement = placement
return p
} | [
"func",
"(",
"p",
"*",
"PodSchedulingPolicy",
")",
"SetPlacement",
"(",
"placement",
"*",
"PodPlacement",
")",
"*",
"PodSchedulingPolicy",
"{",
"p",
".",
"Placement",
"=",
"placement",
"\n",
"return",
"p",
"\n",
"}"
] | // SetPlacement sets the pod's placement settings | [
"SetPlacement",
"sets",
"the",
"pod",
"s",
"placement",
"settings"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L132-L135 |
16,929 | gambol99/go-marathon | pod_scheduling.go | SetKillSelection | func (p *PodSchedulingPolicy) SetKillSelection(killSelection string) *PodSchedulingPolicy {
p.KillSelection = killSelection
return p
} | go | func (p *PodSchedulingPolicy) SetKillSelection(killSelection string) *PodSchedulingPolicy {
p.KillSelection = killSelection
return p
} | [
"func",
"(",
"p",
"*",
"PodSchedulingPolicy",
")",
"SetKillSelection",
"(",
"killSelection",
"string",
")",
"*",
"PodSchedulingPolicy",
"{",
"p",
".",
"KillSelection",
"=",
"killSelection",
"\n",
"return",
"p",
"\n",
"}"
] | // SetKillSelection sets the pod's kill selection criteria when terminating pod instances | [
"SetKillSelection",
"sets",
"the",
"pod",
"s",
"kill",
"selection",
"criteria",
"when",
"terminating",
"pod",
"instances"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L138-L141 |
16,930 | gambol99/go-marathon | pod_scheduling.go | SetUnreachableStrategy | func (p *PodSchedulingPolicy) SetUnreachableStrategy(strategy EnabledUnreachableStrategy) *PodSchedulingPolicy {
p.UnreachableStrategy = &UnreachableStrategy{
EnabledUnreachableStrategy: strategy,
}
return p
} | go | func (p *PodSchedulingPolicy) SetUnreachableStrategy(strategy EnabledUnreachableStrategy) *PodSchedulingPolicy {
p.UnreachableStrategy = &UnreachableStrategy{
EnabledUnreachableStrategy: strategy,
}
return p
} | [
"func",
"(",
"p",
"*",
"PodSchedulingPolicy",
")",
"SetUnreachableStrategy",
"(",
"strategy",
"EnabledUnreachableStrategy",
")",
"*",
"PodSchedulingPolicy",
"{",
"p",
".",
"UnreachableStrategy",
"=",
"&",
"UnreachableStrategy",
"{",
"EnabledUnreachableStrategy",
":",
"s... | // SetUnreachableStrategy sets the pod's unreachable strategy for lost instances | [
"SetUnreachableStrategy",
"sets",
"the",
"pod",
"s",
"unreachable",
"strategy",
"for",
"lost",
"instances"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L144-L149 |
16,931 | gambol99/go-marathon | pod_scheduling.go | SetUnreachableStrategyDisabled | func (p *PodSchedulingPolicy) SetUnreachableStrategyDisabled() *PodSchedulingPolicy {
p.UnreachableStrategy = &UnreachableStrategy{
AbsenceReason: UnreachableStrategyAbsenceReasonDisabled,
}
return p
} | go | func (p *PodSchedulingPolicy) SetUnreachableStrategyDisabled() *PodSchedulingPolicy {
p.UnreachableStrategy = &UnreachableStrategy{
AbsenceReason: UnreachableStrategyAbsenceReasonDisabled,
}
return p
} | [
"func",
"(",
"p",
"*",
"PodSchedulingPolicy",
")",
"SetUnreachableStrategyDisabled",
"(",
")",
"*",
"PodSchedulingPolicy",
"{",
"p",
".",
"UnreachableStrategy",
"=",
"&",
"UnreachableStrategy",
"{",
"AbsenceReason",
":",
"UnreachableStrategyAbsenceReasonDisabled",
",",
... | // SetUnreachableStrategyDisabled disables the pod's unreachable strategy | [
"SetUnreachableStrategyDisabled",
"disables",
"the",
"pod",
"s",
"unreachable",
"strategy"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_scheduling.go#L152-L157 |
16,932 | gambol99/go-marathon | unreachable_strategy.go | UnmarshalJSON | func (us *UnreachableStrategy) UnmarshalJSON(b []byte) error {
var u unreachableStrategy
var errEnabledUS, errNonEnabledUS error
if errEnabledUS = json.Unmarshal(b, &u); errEnabledUS == nil {
*us = UnreachableStrategy(u)
return nil
}
if errNonEnabledUS = json.Unmarshal(b, &us.AbsenceReason); errNonEnabledUS == nil {
return nil
}
return fmt.Errorf("failed to unmarshal unreachable strategy: unmarshaling into enabled returned error '%s'; unmarshaling into non-enabled returned error '%s'", errEnabledUS, errNonEnabledUS)
} | go | func (us *UnreachableStrategy) UnmarshalJSON(b []byte) error {
var u unreachableStrategy
var errEnabledUS, errNonEnabledUS error
if errEnabledUS = json.Unmarshal(b, &u); errEnabledUS == nil {
*us = UnreachableStrategy(u)
return nil
}
if errNonEnabledUS = json.Unmarshal(b, &us.AbsenceReason); errNonEnabledUS == nil {
return nil
}
return fmt.Errorf("failed to unmarshal unreachable strategy: unmarshaling into enabled returned error '%s'; unmarshaling into non-enabled returned error '%s'", errEnabledUS, errNonEnabledUS)
} | [
"func",
"(",
"us",
"*",
"UnreachableStrategy",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"u",
"unreachableStrategy",
"\n",
"var",
"errEnabledUS",
",",
"errNonEnabledUS",
"error",
"\n",
"if",
"errEnabledUS",
"=",
"json",
".",... | // UnmarshalJSON unmarshals the given JSON into an UnreachableStrategy. It
// populates parameters for present strategies, and otherwise only sets the
// absence reason. | [
"UnmarshalJSON",
"unmarshals",
"the",
"given",
"JSON",
"into",
"an",
"UnreachableStrategy",
".",
"It",
"populates",
"parameters",
"for",
"present",
"strategies",
"and",
"otherwise",
"only",
"sets",
"the",
"absence",
"reason",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/unreachable_strategy.go#L44-L57 |
16,933 | gambol99/go-marathon | unreachable_strategy.go | MarshalJSON | func (us *UnreachableStrategy) MarshalJSON() ([]byte, error) {
if us.AbsenceReason == "" {
return json.Marshal(us.EnabledUnreachableStrategy)
}
return json.Marshal(us.AbsenceReason)
} | go | func (us *UnreachableStrategy) MarshalJSON() ([]byte, error) {
if us.AbsenceReason == "" {
return json.Marshal(us.EnabledUnreachableStrategy)
}
return json.Marshal(us.AbsenceReason)
} | [
"func",
"(",
"us",
"*",
"UnreachableStrategy",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"us",
".",
"AbsenceReason",
"==",
"\"",
"\"",
"{",
"return",
"json",
".",
"Marshal",
"(",
"us",
".",
"EnabledUnreachableSt... | // MarshalJSON marshals the unreachable strategy. | [
"MarshalJSON",
"marshals",
"the",
"unreachable",
"strategy",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/unreachable_strategy.go#L60-L66 |
16,934 | gambol99/go-marathon | unreachable_strategy.go | SetInactiveAfterSeconds | func (us *UnreachableStrategy) SetInactiveAfterSeconds(cap float64) *UnreachableStrategy {
us.InactiveAfterSeconds = &cap
return us
} | go | func (us *UnreachableStrategy) SetInactiveAfterSeconds(cap float64) *UnreachableStrategy {
us.InactiveAfterSeconds = &cap
return us
} | [
"func",
"(",
"us",
"*",
"UnreachableStrategy",
")",
"SetInactiveAfterSeconds",
"(",
"cap",
"float64",
")",
"*",
"UnreachableStrategy",
"{",
"us",
".",
"InactiveAfterSeconds",
"=",
"&",
"cap",
"\n",
"return",
"us",
"\n",
"}"
] | // SetInactiveAfterSeconds sets the period after which instance will be marked as inactive. | [
"SetInactiveAfterSeconds",
"sets",
"the",
"period",
"after",
"which",
"instance",
"will",
"be",
"marked",
"as",
"inactive",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/unreachable_strategy.go#L69-L72 |
16,935 | gambol99/go-marathon | unreachable_strategy.go | SetExpungeAfterSeconds | func (us *UnreachableStrategy) SetExpungeAfterSeconds(cap float64) *UnreachableStrategy {
us.ExpungeAfterSeconds = &cap
return us
} | go | func (us *UnreachableStrategy) SetExpungeAfterSeconds(cap float64) *UnreachableStrategy {
us.ExpungeAfterSeconds = &cap
return us
} | [
"func",
"(",
"us",
"*",
"UnreachableStrategy",
")",
"SetExpungeAfterSeconds",
"(",
"cap",
"float64",
")",
"*",
"UnreachableStrategy",
"{",
"us",
".",
"ExpungeAfterSeconds",
"=",
"&",
"cap",
"\n",
"return",
"us",
"\n",
"}"
] | // SetExpungeAfterSeconds sets the period after which instance will be expunged. | [
"SetExpungeAfterSeconds",
"sets",
"the",
"period",
"after",
"which",
"instance",
"will",
"be",
"expunged",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/unreachable_strategy.go#L75-L78 |
16,936 | gambol99/go-marathon | health.go | SetCommand | func (h *HealthCheck) SetCommand(c Command) *HealthCheck {
h.Command = &c
return h
} | go | func (h *HealthCheck) SetCommand(c Command) *HealthCheck {
h.Command = &c
return h
} | [
"func",
"(",
"h",
"*",
"HealthCheck",
")",
"SetCommand",
"(",
"c",
"Command",
")",
"*",
"HealthCheck",
"{",
"h",
".",
"Command",
"=",
"&",
"c",
"\n",
"return",
"h",
"\n",
"}"
] | // SetCommand sets the given command on the health check. | [
"SetCommand",
"sets",
"the",
"given",
"command",
"on",
"the",
"health",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L83-L86 |
16,937 | gambol99/go-marathon | health.go | SetPortIndex | func (h *HealthCheck) SetPortIndex(i int) *HealthCheck {
h.PortIndex = &i
return h
} | go | func (h *HealthCheck) SetPortIndex(i int) *HealthCheck {
h.PortIndex = &i
return h
} | [
"func",
"(",
"h",
"*",
"HealthCheck",
")",
"SetPortIndex",
"(",
"i",
"int",
")",
"*",
"HealthCheck",
"{",
"h",
".",
"PortIndex",
"=",
"&",
"i",
"\n",
"return",
"h",
"\n",
"}"
] | // SetPortIndex sets the given port index on the health check. | [
"SetPortIndex",
"sets",
"the",
"given",
"port",
"index",
"on",
"the",
"health",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L89-L92 |
16,938 | gambol99/go-marathon | health.go | SetPort | func (h *HealthCheck) SetPort(i int) *HealthCheck {
h.Port = &i
return h
} | go | func (h *HealthCheck) SetPort(i int) *HealthCheck {
h.Port = &i
return h
} | [
"func",
"(",
"h",
"*",
"HealthCheck",
")",
"SetPort",
"(",
"i",
"int",
")",
"*",
"HealthCheck",
"{",
"h",
".",
"Port",
"=",
"&",
"i",
"\n",
"return",
"h",
"\n",
"}"
] | // SetPort sets the given port on the health check. | [
"SetPort",
"sets",
"the",
"given",
"port",
"on",
"the",
"health",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L95-L98 |
16,939 | gambol99/go-marathon | health.go | SetPath | func (h *HealthCheck) SetPath(p string) *HealthCheck {
h.Path = &p
return h
} | go | func (h *HealthCheck) SetPath(p string) *HealthCheck {
h.Path = &p
return h
} | [
"func",
"(",
"h",
"*",
"HealthCheck",
")",
"SetPath",
"(",
"p",
"string",
")",
"*",
"HealthCheck",
"{",
"h",
".",
"Path",
"=",
"&",
"p",
"\n",
"return",
"h",
"\n",
"}"
] | // SetPath sets the given path on the health check. | [
"SetPath",
"sets",
"the",
"given",
"path",
"on",
"the",
"health",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L101-L104 |
16,940 | gambol99/go-marathon | health.go | SetMaxConsecutiveFailures | func (h *HealthCheck) SetMaxConsecutiveFailures(i int) *HealthCheck {
h.MaxConsecutiveFailures = &i
return h
} | go | func (h *HealthCheck) SetMaxConsecutiveFailures(i int) *HealthCheck {
h.MaxConsecutiveFailures = &i
return h
} | [
"func",
"(",
"h",
"*",
"HealthCheck",
")",
"SetMaxConsecutiveFailures",
"(",
"i",
"int",
")",
"*",
"HealthCheck",
"{",
"h",
".",
"MaxConsecutiveFailures",
"=",
"&",
"i",
"\n",
"return",
"h",
"\n",
"}"
] | // SetMaxConsecutiveFailures sets the maximum consecutive failures on the health check. | [
"SetMaxConsecutiveFailures",
"sets",
"the",
"maximum",
"consecutive",
"failures",
"on",
"the",
"health",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L107-L110 |
16,941 | gambol99/go-marathon | health.go | SetIgnoreHTTP1xx | func (h *HealthCheck) SetIgnoreHTTP1xx(ignore bool) *HealthCheck {
h.IgnoreHTTP1xx = &ignore
return h
} | go | func (h *HealthCheck) SetIgnoreHTTP1xx(ignore bool) *HealthCheck {
h.IgnoreHTTP1xx = &ignore
return h
} | [
"func",
"(",
"h",
"*",
"HealthCheck",
")",
"SetIgnoreHTTP1xx",
"(",
"ignore",
"bool",
")",
"*",
"HealthCheck",
"{",
"h",
".",
"IgnoreHTTP1xx",
"=",
"&",
"ignore",
"\n",
"return",
"h",
"\n",
"}"
] | // SetIgnoreHTTP1xx sets ignore http 1xx on the health check. | [
"SetIgnoreHTTP1xx",
"sets",
"ignore",
"http",
"1xx",
"on",
"the",
"health",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L113-L116 |
16,942 | gambol99/go-marathon | health.go | NewDefaultHealthCheck | func NewDefaultHealthCheck() *HealthCheck {
portIndex := 0
path := ""
maxConsecutiveFailures := 3
return &HealthCheck{
Protocol: "HTTP",
Path: &path,
PortIndex: &portIndex,
MaxConsecutiveFailures: &maxConsecutiveFailures,
GracePeriodSeconds: 30,
IntervalSeconds: 10,
TimeoutSeconds: 5,
}
} | go | func NewDefaultHealthCheck() *HealthCheck {
portIndex := 0
path := ""
maxConsecutiveFailures := 3
return &HealthCheck{
Protocol: "HTTP",
Path: &path,
PortIndex: &portIndex,
MaxConsecutiveFailures: &maxConsecutiveFailures,
GracePeriodSeconds: 30,
IntervalSeconds: 10,
TimeoutSeconds: 5,
}
} | [
"func",
"NewDefaultHealthCheck",
"(",
")",
"*",
"HealthCheck",
"{",
"portIndex",
":=",
"0",
"\n",
"path",
":=",
"\"",
"\"",
"\n",
"maxConsecutiveFailures",
":=",
"3",
"\n\n",
"return",
"&",
"HealthCheck",
"{",
"Protocol",
":",
"\"",
"\"",
",",
"Path",
":",... | // NewDefaultHealthCheck creates a default application health check | [
"NewDefaultHealthCheck",
"creates",
"a",
"default",
"application",
"health",
"check"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L119-L133 |
16,943 | gambol99/go-marathon | health.go | SetGracePeriod | func (p *PodHealthCheck) SetGracePeriod(gracePeriodSeconds int) *PodHealthCheck {
p.GracePeriodSeconds = &gracePeriodSeconds
return p
} | go | func (p *PodHealthCheck) SetGracePeriod(gracePeriodSeconds int) *PodHealthCheck {
p.GracePeriodSeconds = &gracePeriodSeconds
return p
} | [
"func",
"(",
"p",
"*",
"PodHealthCheck",
")",
"SetGracePeriod",
"(",
"gracePeriodSeconds",
"int",
")",
"*",
"PodHealthCheck",
"{",
"p",
".",
"GracePeriodSeconds",
"=",
"&",
"gracePeriodSeconds",
"\n",
"return",
"p",
"\n",
"}"
] | // SetGracePeriod sets the health check initial grace period, in seconds | [
"SetGracePeriod",
"sets",
"the",
"health",
"check",
"initial",
"grace",
"period",
"in",
"seconds"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L179-L182 |
16,944 | gambol99/go-marathon | health.go | SetInterval | func (p *PodHealthCheck) SetInterval(intervalSeconds int) *PodHealthCheck {
p.IntervalSeconds = &intervalSeconds
return p
} | go | func (p *PodHealthCheck) SetInterval(intervalSeconds int) *PodHealthCheck {
p.IntervalSeconds = &intervalSeconds
return p
} | [
"func",
"(",
"p",
"*",
"PodHealthCheck",
")",
"SetInterval",
"(",
"intervalSeconds",
"int",
")",
"*",
"PodHealthCheck",
"{",
"p",
".",
"IntervalSeconds",
"=",
"&",
"intervalSeconds",
"\n",
"return",
"p",
"\n",
"}"
] | // SetInterval sets the health check polling interval, in seconds | [
"SetInterval",
"sets",
"the",
"health",
"check",
"polling",
"interval",
"in",
"seconds"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L185-L188 |
16,945 | gambol99/go-marathon | health.go | SetMaxConsecutiveFailures | func (p *PodHealthCheck) SetMaxConsecutiveFailures(maxFailures int) *PodHealthCheck {
p.MaxConsecutiveFailures = &maxFailures
return p
} | go | func (p *PodHealthCheck) SetMaxConsecutiveFailures(maxFailures int) *PodHealthCheck {
p.MaxConsecutiveFailures = &maxFailures
return p
} | [
"func",
"(",
"p",
"*",
"PodHealthCheck",
")",
"SetMaxConsecutiveFailures",
"(",
"maxFailures",
"int",
")",
"*",
"PodHealthCheck",
"{",
"p",
".",
"MaxConsecutiveFailures",
"=",
"&",
"maxFailures",
"\n",
"return",
"p",
"\n",
"}"
] | // SetMaxConsecutiveFailures sets the maximum consecutive failures on the health check | [
"SetMaxConsecutiveFailures",
"sets",
"the",
"maximum",
"consecutive",
"failures",
"on",
"the",
"health",
"check"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L191-L194 |
16,946 | gambol99/go-marathon | health.go | SetTimeout | func (p *PodHealthCheck) SetTimeout(timeoutSeconds int) *PodHealthCheck {
p.TimeoutSeconds = &timeoutSeconds
return p
} | go | func (p *PodHealthCheck) SetTimeout(timeoutSeconds int) *PodHealthCheck {
p.TimeoutSeconds = &timeoutSeconds
return p
} | [
"func",
"(",
"p",
"*",
"PodHealthCheck",
")",
"SetTimeout",
"(",
"timeoutSeconds",
"int",
")",
"*",
"PodHealthCheck",
"{",
"p",
".",
"TimeoutSeconds",
"=",
"&",
"timeoutSeconds",
"\n",
"return",
"p",
"\n",
"}"
] | // SetTimeout sets the length of time the health check will await a result, in seconds | [
"SetTimeout",
"sets",
"the",
"length",
"of",
"time",
"the",
"health",
"check",
"will",
"await",
"a",
"result",
"in",
"seconds"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L197-L200 |
16,947 | gambol99/go-marathon | health.go | SetDelay | func (p *PodHealthCheck) SetDelay(delaySeconds int) *PodHealthCheck {
p.DelaySeconds = &delaySeconds
return p
} | go | func (p *PodHealthCheck) SetDelay(delaySeconds int) *PodHealthCheck {
p.DelaySeconds = &delaySeconds
return p
} | [
"func",
"(",
"p",
"*",
"PodHealthCheck",
")",
"SetDelay",
"(",
"delaySeconds",
"int",
")",
"*",
"PodHealthCheck",
"{",
"p",
".",
"DelaySeconds",
"=",
"&",
"delaySeconds",
"\n",
"return",
"p",
"\n",
"}"
] | // SetDelay sets the length of time a pod will delay running health checks on initial launch, in seconds | [
"SetDelay",
"sets",
"the",
"length",
"of",
"time",
"a",
"pod",
"will",
"delay",
"running",
"health",
"checks",
"on",
"initial",
"launch",
"in",
"seconds"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L203-L206 |
16,948 | gambol99/go-marathon | health.go | SetPath | func (h *HTTPHealthCheck) SetPath(path string) *HTTPHealthCheck {
h.Path = path
return h
} | go | func (h *HTTPHealthCheck) SetPath(path string) *HTTPHealthCheck {
h.Path = path
return h
} | [
"func",
"(",
"h",
"*",
"HTTPHealthCheck",
")",
"SetPath",
"(",
"path",
"string",
")",
"*",
"HTTPHealthCheck",
"{",
"h",
".",
"Path",
"=",
"path",
"\n",
"return",
"h",
"\n",
"}"
] | // SetPath sets the HTTP path of the pod health check endpoint | [
"SetPath",
"sets",
"the",
"HTTP",
"path",
"of",
"the",
"pod",
"health",
"check",
"endpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L215-L218 |
16,949 | gambol99/go-marathon | health.go | SetScheme | func (h *HTTPHealthCheck) SetScheme(scheme string) *HTTPHealthCheck {
h.Scheme = scheme
return h
} | go | func (h *HTTPHealthCheck) SetScheme(scheme string) *HTTPHealthCheck {
h.Scheme = scheme
return h
} | [
"func",
"(",
"h",
"*",
"HTTPHealthCheck",
")",
"SetScheme",
"(",
"scheme",
"string",
")",
"*",
"HTTPHealthCheck",
"{",
"h",
".",
"Scheme",
"=",
"scheme",
"\n",
"return",
"h",
"\n",
"}"
] | // SetScheme sets the HTTP scheme of the pod health check endpoint | [
"SetScheme",
"sets",
"the",
"HTTP",
"scheme",
"of",
"the",
"pod",
"health",
"check",
"endpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L221-L224 |
16,950 | gambol99/go-marathon | health.go | SetCommand | func (c *CommandHealthCheck) SetCommand(p PodCommand) *CommandHealthCheck {
c.Command = p
return c
} | go | func (c *CommandHealthCheck) SetCommand(p PodCommand) *CommandHealthCheck {
c.Command = p
return c
} | [
"func",
"(",
"c",
"*",
"CommandHealthCheck",
")",
"SetCommand",
"(",
"p",
"PodCommand",
")",
"*",
"CommandHealthCheck",
"{",
"c",
".",
"Command",
"=",
"p",
"\n",
"return",
"c",
"\n",
"}"
] | // SetCommand sets a CommandHealthCheck's underlying PodCommand | [
"SetCommand",
"sets",
"a",
"CommandHealthCheck",
"s",
"underlying",
"PodCommand"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/health.go#L233-L236 |
16,951 | gambol99/go-marathon | pod.go | NewPod | func NewPod() *Pod {
return &Pod{
Labels: map[string]string{},
Env: map[string]string{},
Containers: []*PodContainer{},
Secrets: map[string]Secret{},
Volumes: []*PodVolume{},
Networks: []*PodNetwork{},
}
} | go | func NewPod() *Pod {
return &Pod{
Labels: map[string]string{},
Env: map[string]string{},
Containers: []*PodContainer{},
Secrets: map[string]Secret{},
Volumes: []*PodVolume{},
Networks: []*PodNetwork{},
}
} | [
"func",
"NewPod",
"(",
")",
"*",
"Pod",
"{",
"return",
"&",
"Pod",
"{",
"Labels",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"Env",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"Containers",
":",
"[",
"]",
"*",
"PodCon... | // NewPod create an empty pod | [
"NewPod",
"create",
"an",
"empty",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L49-L58 |
16,952 | gambol99/go-marathon | pod.go | EmptyLabels | func (p *Pod) EmptyLabels() *Pod {
p.Labels = make(map[string]string)
return p
} | go | func (p *Pod) EmptyLabels() *Pod {
p.Labels = make(map[string]string)
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"EmptyLabels",
"(",
")",
"*",
"Pod",
"{",
"p",
".",
"Labels",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // EmptyLabels empties the labels in a pod | [
"EmptyLabels",
"empties",
"the",
"labels",
"in",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L73-L76 |
16,953 | gambol99/go-marathon | pod.go | AddLabel | func (p *Pod) AddLabel(key, value string) *Pod {
p.Labels[key] = value
return p
} | go | func (p *Pod) AddLabel(key, value string) *Pod {
p.Labels[key] = value
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"AddLabel",
"(",
"key",
",",
"value",
"string",
")",
"*",
"Pod",
"{",
"p",
".",
"Labels",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"p",
"\n",
"}"
] | // AddLabel adds a label to a pod | [
"AddLabel",
"adds",
"a",
"label",
"to",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L79-L82 |
16,954 | gambol99/go-marathon | pod.go | SetLabels | func (p *Pod) SetLabels(labels map[string]string) *Pod {
p.Labels = labels
return p
} | go | func (p *Pod) SetLabels(labels map[string]string) *Pod {
p.Labels = labels
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"SetLabels",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"Pod",
"{",
"p",
".",
"Labels",
"=",
"labels",
"\n",
"return",
"p",
"\n",
"}"
] | // SetLabels sets the labels for a pod | [
"SetLabels",
"sets",
"the",
"labels",
"for",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L85-L88 |
16,955 | gambol99/go-marathon | pod.go | EmptyEnvs | func (p *Pod) EmptyEnvs() *Pod {
p.Env = make(map[string]string)
return p
} | go | func (p *Pod) EmptyEnvs() *Pod {
p.Env = make(map[string]string)
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"EmptyEnvs",
"(",
")",
"*",
"Pod",
"{",
"p",
".",
"Env",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // EmptyEnvs empties the environment variables for a pod | [
"EmptyEnvs",
"empties",
"the",
"environment",
"variables",
"for",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L91-L94 |
16,956 | gambol99/go-marathon | pod.go | AddContainer | func (p *Pod) AddContainer(container *PodContainer) *Pod {
p.Containers = append(p.Containers, container)
return p
} | go | func (p *Pod) AddContainer(container *PodContainer) *Pod {
p.Containers = append(p.Containers, container)
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"AddContainer",
"(",
"container",
"*",
"PodContainer",
")",
"*",
"Pod",
"{",
"p",
".",
"Containers",
"=",
"append",
"(",
"p",
".",
"Containers",
",",
"container",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // AddContainer adds a container to a pod | [
"AddContainer",
"adds",
"a",
"container",
"to",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L118-L121 |
16,957 | gambol99/go-marathon | pod.go | EmptySecrets | func (p *Pod) EmptySecrets() *Pod {
p.Secrets = make(map[string]Secret)
return p
} | go | func (p *Pod) EmptySecrets() *Pod {
p.Secrets = make(map[string]Secret)
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"EmptySecrets",
"(",
")",
"*",
"Pod",
"{",
"p",
".",
"Secrets",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"Secret",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // EmptySecrets empties the secret sources in a pod | [
"EmptySecrets",
"empties",
"the",
"secret",
"sources",
"in",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L124-L127 |
16,958 | gambol99/go-marathon | pod.go | GetSecretSource | func (p *Pod) GetSecretSource(name string) (string, error) {
if val, ok := p.Secrets[name]; ok {
return val.Source, nil
}
return "", fmt.Errorf("secret does not exist")
} | go | func (p *Pod) GetSecretSource(name string) (string, error) {
if val, ok := p.Secrets[name]; ok {
return val.Source, nil
}
return "", fmt.Errorf("secret does not exist")
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"GetSecretSource",
"(",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"val",
",",
"ok",
":=",
"p",
".",
"Secrets",
"[",
"name",
"]",
";",
"ok",
"{",
"return",
"val",
".",
"Source",
",",
"... | // GetSecretSource gets the source of the named secret | [
"GetSecretSource",
"gets",
"the",
"source",
"of",
"the",
"named",
"secret"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L130-L135 |
16,959 | gambol99/go-marathon | pod.go | AddSecret | func (p *Pod) AddSecret(envVar, secretName, sourceName string) *Pod {
if p.Secrets == nil {
p = p.EmptySecrets()
}
p.Secrets[secretName] = Secret{EnvVar: envVar, Source: sourceName}
return p
} | go | func (p *Pod) AddSecret(envVar, secretName, sourceName string) *Pod {
if p.Secrets == nil {
p = p.EmptySecrets()
}
p.Secrets[secretName] = Secret{EnvVar: envVar, Source: sourceName}
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"AddSecret",
"(",
"envVar",
",",
"secretName",
",",
"sourceName",
"string",
")",
"*",
"Pod",
"{",
"if",
"p",
".",
"Secrets",
"==",
"nil",
"{",
"p",
"=",
"p",
".",
"EmptySecrets",
"(",
")",
"\n",
"}",
"\n",
"p",
... | // AddSecret adds the secret to the pod | [
"AddSecret",
"adds",
"the",
"secret",
"to",
"the",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L138-L144 |
16,960 | gambol99/go-marathon | pod.go | AddVolume | func (p *Pod) AddVolume(vol *PodVolume) *Pod {
p.Volumes = append(p.Volumes, vol)
return p
} | go | func (p *Pod) AddVolume(vol *PodVolume) *Pod {
p.Volumes = append(p.Volumes, vol)
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"AddVolume",
"(",
"vol",
"*",
"PodVolume",
")",
"*",
"Pod",
"{",
"p",
".",
"Volumes",
"=",
"append",
"(",
"p",
".",
"Volumes",
",",
"vol",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // AddVolume adds a volume to a pod | [
"AddVolume",
"adds",
"a",
"volume",
"to",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L147-L150 |
16,961 | gambol99/go-marathon | pod.go | AddNetwork | func (p *Pod) AddNetwork(net *PodNetwork) *Pod {
p.Networks = append(p.Networks, net)
return p
} | go | func (p *Pod) AddNetwork(net *PodNetwork) *Pod {
p.Networks = append(p.Networks, net)
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"AddNetwork",
"(",
"net",
"*",
"PodNetwork",
")",
"*",
"Pod",
"{",
"p",
".",
"Networks",
"=",
"append",
"(",
"p",
".",
"Networks",
",",
"net",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // AddNetwork adds a PodNetwork to a pod | [
"AddNetwork",
"adds",
"a",
"PodNetwork",
"to",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L153-L156 |
16,962 | gambol99/go-marathon | pod.go | Count | func (p *Pod) Count(count int) *Pod {
p.Scaling = &PodScalingPolicy{
Kind: "fixed",
Instances: count,
}
return p
} | go | func (p *Pod) Count(count int) *Pod {
p.Scaling = &PodScalingPolicy{
Kind: "fixed",
Instances: count,
}
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"Count",
"(",
"count",
"int",
")",
"*",
"Pod",
"{",
"p",
".",
"Scaling",
"=",
"&",
"PodScalingPolicy",
"{",
"Kind",
":",
"\"",
"\"",
",",
"Instances",
":",
"count",
",",
"}",
"\n",
"return",
"p",
"\n",
"}"
] | // Count sets the count of the pod | [
"Count",
"sets",
"the",
"count",
"of",
"the",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L159-L165 |
16,963 | gambol99/go-marathon | pod.go | SetPodSchedulingPolicy | func (p *Pod) SetPodSchedulingPolicy(policy *PodSchedulingPolicy) *Pod {
p.Scheduling = policy
return p
} | go | func (p *Pod) SetPodSchedulingPolicy(policy *PodSchedulingPolicy) *Pod {
p.Scheduling = policy
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"SetPodSchedulingPolicy",
"(",
"policy",
"*",
"PodSchedulingPolicy",
")",
"*",
"Pod",
"{",
"p",
".",
"Scheduling",
"=",
"policy",
"\n",
"return",
"p",
"\n",
"}"
] | // SetPodSchedulingPolicy sets the PodSchedulingPolicy of a pod | [
"SetPodSchedulingPolicy",
"sets",
"the",
"PodSchedulingPolicy",
"of",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L168-L171 |
16,964 | gambol99/go-marathon | pod.go | SetExecutorResources | func (p *Pod) SetExecutorResources(resources *ExecutorResources) *Pod {
p.ExecutorResources = resources
return p
} | go | func (p *Pod) SetExecutorResources(resources *ExecutorResources) *Pod {
p.ExecutorResources = resources
return p
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"SetExecutorResources",
"(",
"resources",
"*",
"ExecutorResources",
")",
"*",
"Pod",
"{",
"p",
".",
"ExecutorResources",
"=",
"resources",
"\n",
"return",
"p",
"\n",
"}"
] | // SetExecutorResources sets the resources for the pod executor | [
"SetExecutorResources",
"sets",
"the",
"resources",
"for",
"the",
"pod",
"executor"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L174-L177 |
16,965 | gambol99/go-marathon | pod.go | SupportsPods | func (r *marathonClient) SupportsPods() (bool, error) {
if err := r.apiHead(marathonAPIPods, nil); err != nil {
// If we get a 404 we can return a strict false, otherwise it could be
// a valid error
if apiErr, ok := err.(*APIError); ok && apiErr.ErrCode == ErrCodeNotFound {
return false, nil
}
return false, err
}
return true, nil
} | go | func (r *marathonClient) SupportsPods() (bool, error) {
if err := r.apiHead(marathonAPIPods, nil); err != nil {
// If we get a 404 we can return a strict false, otherwise it could be
// a valid error
if apiErr, ok := err.(*APIError); ok && apiErr.ErrCode == ErrCodeNotFound {
return false, nil
}
return false, err
}
return true, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"SupportsPods",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"err",
":=",
"r",
".",
"apiHead",
"(",
"marathonAPIPods",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"// If we get a 404 we can return ... | // SupportsPods determines if this version of marathon supports pods
// If HEAD returns 200 it does | [
"SupportsPods",
"determines",
"if",
"this",
"version",
"of",
"marathon",
"supports",
"pods",
"If",
"HEAD",
"returns",
"200",
"it",
"does"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L181-L192 |
16,966 | gambol99/go-marathon | pod.go | Pod | func (r *marathonClient) Pod(name string) (*Pod, error) {
uri := buildPodURI(name)
result := new(Pod)
if err := r.apiGet(uri, nil, result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) Pod(name string) (*Pod, error) {
uri := buildPodURI(name)
result := new(Pod)
if err := r.apiGet(uri, nil, result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Pod",
"(",
"name",
"string",
")",
"(",
"*",
"Pod",
",",
"error",
")",
"{",
"uri",
":=",
"buildPodURI",
"(",
"name",
")",
"\n",
"result",
":=",
"new",
"(",
"Pod",
")",
"\n",
"if",
"err",
":=",
"r",
... | // Pod gets a pod object from marathon by name | [
"Pod",
"gets",
"a",
"pod",
"object",
"from",
"marathon",
"by",
"name"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L195-L203 |
16,967 | gambol99/go-marathon | pod.go | Pods | func (r *marathonClient) Pods() ([]Pod, error) {
var result []Pod
if err := r.apiGet(marathonAPIPods, nil, &result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) Pods() ([]Pod, error) {
var result []Pod
if err := r.apiGet(marathonAPIPods, nil, &result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Pods",
"(",
")",
"(",
"[",
"]",
"Pod",
",",
"error",
")",
"{",
"var",
"result",
"[",
"]",
"Pod",
"\n",
"if",
"err",
":=",
"r",
".",
"apiGet",
"(",
"marathonAPIPods",
",",
"nil",
",",
"&",
"result",
... | // Pods gets all pods from marathon | [
"Pods",
"gets",
"all",
"pods",
"from",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L206-L213 |
16,968 | gambol99/go-marathon | pod.go | CreatePod | func (r *marathonClient) CreatePod(pod *Pod) (*Pod, error) {
result := new(Pod)
if err := r.apiPost(marathonAPIPods, &pod, result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) CreatePod(pod *Pod) (*Pod, error) {
result := new(Pod)
if err := r.apiPost(marathonAPIPods, &pod, result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"CreatePod",
"(",
"pod",
"*",
"Pod",
")",
"(",
"*",
"Pod",
",",
"error",
")",
"{",
"result",
":=",
"new",
"(",
"Pod",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"apiPost",
"(",
"marathonAPIPods",
",",
"&... | // CreatePod creates a new pod in Marathon | [
"CreatePod",
"creates",
"a",
"new",
"pod",
"in",
"Marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L216-L223 |
16,969 | gambol99/go-marathon | pod.go | DeletePod | func (r *marathonClient) DeletePod(name string, force bool) (*DeploymentID, error) {
uri := fmt.Sprintf("%s?force=%v", buildPodURI(name), force)
deployID := new(DeploymentID)
if err := r.apiDelete(uri, nil, deployID); err != nil {
return nil, err
}
return deployID, nil
} | go | func (r *marathonClient) DeletePod(name string, force bool) (*DeploymentID, error) {
uri := fmt.Sprintf("%s?force=%v", buildPodURI(name), force)
deployID := new(DeploymentID)
if err := r.apiDelete(uri, nil, deployID); err != nil {
return nil, err
}
return deployID, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"DeletePod",
"(",
"name",
"string",
",",
"force",
"bool",
")",
"(",
"*",
"DeploymentID",
",",
"error",
")",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"buildPodURI",
"(",
"name",
")",
... | // DeletePod deletes a pod from marathon | [
"DeletePod",
"deletes",
"a",
"pod",
"from",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L226-L235 |
16,970 | gambol99/go-marathon | pod.go | UpdatePod | func (r *marathonClient) UpdatePod(pod *Pod, force bool) (*Pod, error) {
uri := fmt.Sprintf("%s?force=%v", buildPodURI(pod.ID), force)
result := new(Pod)
if err := r.apiPut(uri, pod, result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) UpdatePod(pod *Pod, force bool) (*Pod, error) {
uri := fmt.Sprintf("%s?force=%v", buildPodURI(pod.ID), force)
result := new(Pod)
if err := r.apiPut(uri, pod, result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"UpdatePod",
"(",
"pod",
"*",
"Pod",
",",
"force",
"bool",
")",
"(",
"*",
"Pod",
",",
"error",
")",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"buildPodURI",
"(",
"pod",
".",
"ID",... | // UpdatePod creates a new pod in Marathon | [
"UpdatePod",
"creates",
"a",
"new",
"pod",
"in",
"Marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L238-L247 |
16,971 | gambol99/go-marathon | pod.go | PodVersions | func (r *marathonClient) PodVersions(name string) ([]string, error) {
uri := buildPodVersionURI(name)
var result []string
if err := r.apiGet(uri, nil, &result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) PodVersions(name string) ([]string, error) {
uri := buildPodVersionURI(name)
var result []string
if err := r.apiGet(uri, nil, &result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"PodVersions",
"(",
"name",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"uri",
":=",
"buildPodVersionURI",
"(",
"name",
")",
"\n",
"var",
"result",
"[",
"]",
"string",
"\n",
"if",
"err... | // PodVersions gets all the deployed versions of a pod | [
"PodVersions",
"gets",
"all",
"the",
"deployed",
"versions",
"of",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L250-L258 |
16,972 | gambol99/go-marathon | pod.go | PodByVersion | func (r *marathonClient) PodByVersion(name, version string) (*Pod, error) {
uri := fmt.Sprintf("%s/%s", buildPodVersionURI(name), version)
result := new(Pod)
if err := r.apiGet(uri, nil, result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) PodByVersion(name, version string) (*Pod, error) {
uri := fmt.Sprintf("%s/%s", buildPodVersionURI(name), version)
result := new(Pod)
if err := r.apiGet(uri, nil, result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"PodByVersion",
"(",
"name",
",",
"version",
"string",
")",
"(",
"*",
"Pod",
",",
"error",
")",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"buildPodVersionURI",
"(",
"name",
")",
",",
... | // PodByVersion gets a pod by a version identifier | [
"PodByVersion",
"gets",
"a",
"pod",
"by",
"a",
"version",
"identifier"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod.go#L261-L269 |
16,973 | gambol99/go-marathon | docker.go | SetPersistentVolume | func (v *Volume) SetPersistentVolume() *PersistentVolume {
ev := &PersistentVolume{}
v.Persistent = ev
return ev
} | go | func (v *Volume) SetPersistentVolume() *PersistentVolume {
ev := &PersistentVolume{}
v.Persistent = ev
return ev
} | [
"func",
"(",
"v",
"*",
"Volume",
")",
"SetPersistentVolume",
"(",
")",
"*",
"PersistentVolume",
"{",
"ev",
":=",
"&",
"PersistentVolume",
"{",
"}",
"\n",
"v",
".",
"Persistent",
"=",
"ev",
"\n",
"return",
"ev",
"\n",
"}"
] | // SetPersistentVolume defines persistent properties for volume | [
"SetPersistentVolume",
"defines",
"persistent",
"properties",
"for",
"volume"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/docker.go#L169-L173 |
16,974 | gambol99/go-marathon | docker.go | NewDockerContainer | func NewDockerContainer() *Container {
container := &Container{}
container.Type = "DOCKER"
container.Docker = &Docker{}
return container
} | go | func NewDockerContainer() *Container {
container := &Container{}
container.Type = "DOCKER"
container.Docker = &Docker{}
return container
} | [
"func",
"NewDockerContainer",
"(",
")",
"*",
"Container",
"{",
"container",
":=",
"&",
"Container",
"{",
"}",
"\n",
"container",
".",
"Type",
"=",
"\"",
"\"",
"\n",
"container",
".",
"Docker",
"=",
"&",
"Docker",
"{",
"}",
"\n\n",
"return",
"container",
... | // NewDockerContainer creates a default docker container for you | [
"NewDockerContainer",
"creates",
"a",
"default",
"docker",
"container",
"for",
"you"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/docker.go#L219-L225 |
16,975 | gambol99/go-marathon | upgrade_strategy.go | SetMinimumHealthCapacity | func (us *UpgradeStrategy) SetMinimumHealthCapacity(cap float64) *UpgradeStrategy {
us.MinimumHealthCapacity = &cap
return us
} | go | func (us *UpgradeStrategy) SetMinimumHealthCapacity(cap float64) *UpgradeStrategy {
us.MinimumHealthCapacity = &cap
return us
} | [
"func",
"(",
"us",
"*",
"UpgradeStrategy",
")",
"SetMinimumHealthCapacity",
"(",
"cap",
"float64",
")",
"*",
"UpgradeStrategy",
"{",
"us",
".",
"MinimumHealthCapacity",
"=",
"&",
"cap",
"\n",
"return",
"us",
"\n",
"}"
] | // SetMinimumHealthCapacity sets the minimum health capacity. | [
"SetMinimumHealthCapacity",
"sets",
"the",
"minimum",
"health",
"capacity",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/upgrade_strategy.go#L26-L29 |
16,976 | gambol99/go-marathon | upgrade_strategy.go | SetMaximumOverCapacity | func (us *UpgradeStrategy) SetMaximumOverCapacity(cap float64) *UpgradeStrategy {
us.MaximumOverCapacity = &cap
return us
} | go | func (us *UpgradeStrategy) SetMaximumOverCapacity(cap float64) *UpgradeStrategy {
us.MaximumOverCapacity = &cap
return us
} | [
"func",
"(",
"us",
"*",
"UpgradeStrategy",
")",
"SetMaximumOverCapacity",
"(",
"cap",
"float64",
")",
"*",
"UpgradeStrategy",
"{",
"us",
".",
"MaximumOverCapacity",
"=",
"&",
"cap",
"\n",
"return",
"us",
"\n",
"}"
] | // SetMaximumOverCapacity sets the maximum over capacity. | [
"SetMaximumOverCapacity",
"sets",
"the",
"maximum",
"over",
"capacity",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/upgrade_strategy.go#L32-L35 |
16,977 | gambol99/go-marathon | subscription.go | Subscriptions | func (r *marathonClient) Subscriptions() (*Subscriptions, error) {
subscriptions := new(Subscriptions)
if err := r.apiGet(marathonAPISubscription, nil, subscriptions); err != nil {
return nil, err
}
return subscriptions, nil
} | go | func (r *marathonClient) Subscriptions() (*Subscriptions, error) {
subscriptions := new(Subscriptions)
if err := r.apiGet(marathonAPISubscription, nil, subscriptions); err != nil {
return nil, err
}
return subscriptions, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Subscriptions",
"(",
")",
"(",
"*",
"Subscriptions",
",",
"error",
")",
"{",
"subscriptions",
":=",
"new",
"(",
"Subscriptions",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"apiGet",
"(",
"marathonAPISubscription"... | // Subscriptions retrieves a list of registered subscriptions | [
"Subscriptions",
"retrieves",
"a",
"list",
"of",
"registered",
"subscriptions"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/subscription.go#L38-L45 |
16,978 | gambol99/go-marathon | subscription.go | SubscriptionURL | func (r *marathonClient) SubscriptionURL() string {
if r.config.CallbackURL != "" {
return fmt.Sprintf("%s%s", r.config.CallbackURL, defaultEventsURL)
}
return fmt.Sprintf("http://%s:%d%s", r.ipAddress, r.config.EventsPort, defaultEventsURL)
} | go | func (r *marathonClient) SubscriptionURL() string {
if r.config.CallbackURL != "" {
return fmt.Sprintf("%s%s", r.config.CallbackURL, defaultEventsURL)
}
return fmt.Sprintf("http://%s:%d%s", r.ipAddress, r.config.EventsPort, defaultEventsURL)
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"SubscriptionURL",
"(",
")",
"string",
"{",
"if",
"r",
".",
"config",
".",
"CallbackURL",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"config",
".",
"CallbackUR... | // SubscriptionURL retrieves the subscription callback URL used when registering | [
"SubscriptionURL",
"retrieves",
"the",
"subscription",
"callback",
"URL",
"used",
"when",
"registering"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/subscription.go#L92-L98 |
16,979 | gambol99/go-marathon | subscription.go | registerSubscription | func (r *marathonClient) registerSubscription() error {
switch r.config.EventsTransport {
case EventsTransportCallback:
return r.registerCallbackSubscription()
case EventsTransportSSE:
return r.registerSSESubscription()
default:
return fmt.Errorf("the events transport: %d is not supported", r.config.EventsTransport)
}
} | go | func (r *marathonClient) registerSubscription() error {
switch r.config.EventsTransport {
case EventsTransportCallback:
return r.registerCallbackSubscription()
case EventsTransportSSE:
return r.registerSSESubscription()
default:
return fmt.Errorf("the events transport: %d is not supported", r.config.EventsTransport)
}
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"registerSubscription",
"(",
")",
"error",
"{",
"switch",
"r",
".",
"config",
".",
"EventsTransport",
"{",
"case",
"EventsTransportCallback",
":",
"return",
"r",
".",
"registerCallbackSubscription",
"(",
")",
"\n",
... | // registerSubscription registers ourselves with Marathon to receive events from configured transport facility | [
"registerSubscription",
"registers",
"ourselves",
"with",
"Marathon",
"to",
"receive",
"events",
"from",
"configured",
"transport",
"facility"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/subscription.go#L101-L110 |
16,980 | gambol99/go-marathon | subscription.go | registerSSESubscription | func (r *marathonClient) registerSSESubscription() error {
if r.subscribedToSSE {
return nil
}
if r.config.HTTPSSEClient.Timeout != 0 {
return fmt.Errorf(
"global timeout must not be set for SSE connections (found %s) -- remove global timeout from HTTP client or provide separate SSE HTTP client without global timeout",
r.config.HTTPSSEClient.Timeout,
)
}
go func() {
for {
stream, err := r.connectToSSE()
if err != nil {
r.debugLog("Error connecting SSE subscription: %s", err)
<-time.After(5 * time.Second)
continue
}
err = r.listenToSSE(stream)
stream.Close()
r.debugLog("Error on SSE subscription: %s", err)
}
}()
r.subscribedToSSE = true
return nil
} | go | func (r *marathonClient) registerSSESubscription() error {
if r.subscribedToSSE {
return nil
}
if r.config.HTTPSSEClient.Timeout != 0 {
return fmt.Errorf(
"global timeout must not be set for SSE connections (found %s) -- remove global timeout from HTTP client or provide separate SSE HTTP client without global timeout",
r.config.HTTPSSEClient.Timeout,
)
}
go func() {
for {
stream, err := r.connectToSSE()
if err != nil {
r.debugLog("Error connecting SSE subscription: %s", err)
<-time.After(5 * time.Second)
continue
}
err = r.listenToSSE(stream)
stream.Close()
r.debugLog("Error on SSE subscription: %s", err)
}
}()
r.subscribedToSSE = true
return nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"registerSSESubscription",
"(",
")",
"error",
"{",
"if",
"r",
".",
"subscribedToSSE",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"config",
".",
"HTTPSSEClient",
".",
"Timeout",
"!=",
"0",
"{",
... | // registerSSESubscription starts a go routine that continuously tries to
// connect to the SSE stream and to process the received events. To establish
// the connection it tries the active cluster members until no more member is
// active. When this happens it will retry to get a connection every 5 seconds. | [
"registerSSESubscription",
"starts",
"a",
"go",
"routine",
"that",
"continuously",
"tries",
"to",
"connect",
"to",
"the",
"SSE",
"stream",
"and",
"to",
"process",
"the",
"received",
"events",
".",
"To",
"establish",
"the",
"connection",
"it",
"tries",
"the",
"... | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/subscription.go#L169-L197 |
16,981 | gambol99/go-marathon | queue.go | Queue | func (r *marathonClient) Queue() (*Queue, error) {
var queue *Queue
err := r.apiGet(marathonAPIQueue, nil, &queue)
if err != nil {
return nil, err
}
return queue, nil
} | go | func (r *marathonClient) Queue() (*Queue, error) {
var queue *Queue
err := r.apiGet(marathonAPIQueue, nil, &queue)
if err != nil {
return nil, err
}
return queue, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Queue",
"(",
")",
"(",
"*",
"Queue",
",",
"error",
")",
"{",
"var",
"queue",
"*",
"Queue",
"\n",
"err",
":=",
"r",
".",
"apiGet",
"(",
"marathonAPIQueue",
",",
"nil",
",",
"&",
"queue",
")",
"\n",
"i... | // Queue retrieves content of the marathon launch queue | [
"Queue",
"retrieves",
"content",
"of",
"the",
"marathon",
"launch",
"queue"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/queue.go#L42-L49 |
16,982 | gambol99/go-marathon | cluster.go | newCluster | func newCluster(client *httpClient, marathonURL string, isDCOS bool) (*cluster, error) {
// step: extract and basic validate the endpoints
var members []*member
var defaultProto string
for _, endpoint := range strings.Split(marathonURL, ",") {
// step: check for nothing
if endpoint == "" {
return nil, newInvalidEndpointError("endpoint is blank")
}
// step: prepend scheme if missing on (non-initial) endpoint.
if !strings.HasPrefix(endpoint, "http://") && !strings.HasPrefix(endpoint, "https://") {
if defaultProto == "" {
return nil, newInvalidEndpointError("missing scheme on (first) endpoint")
}
endpoint = fmt.Sprintf("%s://%s", defaultProto, endpoint)
}
// step: parse the url
u, err := url.Parse(endpoint)
if err != nil {
return nil, newInvalidEndpointError("invalid endpoint '%s': %s", endpoint, err)
}
if defaultProto == "" {
defaultProto = u.Scheme
}
// step: check for empty hosts
if u.Host == "" {
return nil, newInvalidEndpointError("endpoint: %s must have a host", endpoint)
}
// step: if DCOS is set and no path is given, set the default DCOS path.
// done in order to maintain compatibility with automatic addition of the
// default DCOS path.
if isDCOS && strings.TrimLeft(u.Path, "/") == "" {
u.Path = defaultDCOSPath
}
// step: create a new node for this endpoint
members = append(members, &member{endpoint: u.String()})
}
return &cluster{
client: client,
members: members,
healthCheckInterval: 5 * time.Second,
}, nil
} | go | func newCluster(client *httpClient, marathonURL string, isDCOS bool) (*cluster, error) {
// step: extract and basic validate the endpoints
var members []*member
var defaultProto string
for _, endpoint := range strings.Split(marathonURL, ",") {
// step: check for nothing
if endpoint == "" {
return nil, newInvalidEndpointError("endpoint is blank")
}
// step: prepend scheme if missing on (non-initial) endpoint.
if !strings.HasPrefix(endpoint, "http://") && !strings.HasPrefix(endpoint, "https://") {
if defaultProto == "" {
return nil, newInvalidEndpointError("missing scheme on (first) endpoint")
}
endpoint = fmt.Sprintf("%s://%s", defaultProto, endpoint)
}
// step: parse the url
u, err := url.Parse(endpoint)
if err != nil {
return nil, newInvalidEndpointError("invalid endpoint '%s': %s", endpoint, err)
}
if defaultProto == "" {
defaultProto = u.Scheme
}
// step: check for empty hosts
if u.Host == "" {
return nil, newInvalidEndpointError("endpoint: %s must have a host", endpoint)
}
// step: if DCOS is set and no path is given, set the default DCOS path.
// done in order to maintain compatibility with automatic addition of the
// default DCOS path.
if isDCOS && strings.TrimLeft(u.Path, "/") == "" {
u.Path = defaultDCOSPath
}
// step: create a new node for this endpoint
members = append(members, &member{endpoint: u.String()})
}
return &cluster{
client: client,
members: members,
healthCheckInterval: 5 * time.Second,
}, nil
} | [
"func",
"newCluster",
"(",
"client",
"*",
"httpClient",
",",
"marathonURL",
"string",
",",
"isDCOS",
"bool",
")",
"(",
"*",
"cluster",
",",
"error",
")",
"{",
"// step: extract and basic validate the endpoints",
"var",
"members",
"[",
"]",
"*",
"member",
"\n",
... | // newCluster returns a new marathon cluster | [
"newCluster",
"returns",
"a",
"new",
"marathon",
"cluster"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/cluster.go#L56-L104 |
16,983 | gambol99/go-marathon | cluster.go | getMember | func (c *cluster) getMember() (string, error) {
c.RLock()
defer c.RUnlock()
for _, n := range c.members {
if n.status == memberStatusUp {
return n.endpoint, nil
}
}
return "", ErrMarathonDown
} | go | func (c *cluster) getMember() (string, error) {
c.RLock()
defer c.RUnlock()
for _, n := range c.members {
if n.status == memberStatusUp {
return n.endpoint, nil
}
}
return "", ErrMarathonDown
} | [
"func",
"(",
"c",
"*",
"cluster",
")",
"getMember",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"c",
".",
"members",
"{... | // retrieve the current member, i.e. the current endpoint in use | [
"retrieve",
"the",
"current",
"member",
"i",
".",
"e",
".",
"the",
"current",
"endpoint",
"in",
"use"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/cluster.go#L107-L117 |
16,984 | gambol99/go-marathon | cluster.go | markDown | func (c *cluster) markDown(endpoint string) {
c.Lock()
defer c.Unlock()
for _, n := range c.members {
// step: check if this is the node and it's marked as up - The double checking on the
// nodes status ensures the multiple calls don't create multiple checks
if n.status == memberStatusUp && n.endpoint == endpoint {
n.status = memberStatusDown
go c.healthCheckNode(n)
break
}
}
} | go | func (c *cluster) markDown(endpoint string) {
c.Lock()
defer c.Unlock()
for _, n := range c.members {
// step: check if this is the node and it's marked as up - The double checking on the
// nodes status ensures the multiple calls don't create multiple checks
if n.status == memberStatusUp && n.endpoint == endpoint {
n.status = memberStatusDown
go c.healthCheckNode(n)
break
}
}
} | [
"func",
"(",
"c",
"*",
"cluster",
")",
"markDown",
"(",
"endpoint",
"string",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"c",
".",
"members",
"{",
"// step: check ... | // markDown marks down the current endpoint | [
"markDown",
"marks",
"down",
"the",
"current",
"endpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/cluster.go#L120-L132 |
16,985 | gambol99/go-marathon | cluster.go | healthCheckNode | func (c *cluster) healthCheckNode(node *member) {
// step: wait for the node to become active ... we are assuming a /ping is enough here
ticker := time.NewTicker(c.healthCheckInterval)
defer ticker.Stop()
for range ticker.C {
req, err := c.client.buildMarathonRequest("GET", node.endpoint, "ping", nil)
if err == nil {
res, err := c.client.Do(req)
if err == nil && res.StatusCode == 200 {
// step: mark the node as active again
c.Lock()
node.status = memberStatusUp
c.Unlock()
break
}
}
}
} | go | func (c *cluster) healthCheckNode(node *member) {
// step: wait for the node to become active ... we are assuming a /ping is enough here
ticker := time.NewTicker(c.healthCheckInterval)
defer ticker.Stop()
for range ticker.C {
req, err := c.client.buildMarathonRequest("GET", node.endpoint, "ping", nil)
if err == nil {
res, err := c.client.Do(req)
if err == nil && res.StatusCode == 200 {
// step: mark the node as active again
c.Lock()
node.status = memberStatusUp
c.Unlock()
break
}
}
}
} | [
"func",
"(",
"c",
"*",
"cluster",
")",
"healthCheckNode",
"(",
"node",
"*",
"member",
")",
"{",
"// step: wait for the node to become active ... we are assuming a /ping is enough here",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"c",
".",
"healthCheckInterval",
")",... | // healthCheckNode performs a health check on the node and when active updates the status | [
"healthCheckNode",
"performs",
"a",
"health",
"check",
"on",
"the",
"node",
"and",
"when",
"active",
"updates",
"the",
"status"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/cluster.go#L135-L152 |
16,986 | gambol99/go-marathon | cluster.go | membersList | func (c *cluster) membersList(status memberStatus) []string {
c.RLock()
defer c.RUnlock()
var list []string
for _, m := range c.members {
if m.status == status {
list = append(list, m.endpoint)
}
}
return list
} | go | func (c *cluster) membersList(status memberStatus) []string {
c.RLock()
defer c.RUnlock()
var list []string
for _, m := range c.members {
if m.status == status {
list = append(list, m.endpoint)
}
}
return list
} | [
"func",
"(",
"c",
"*",
"cluster",
")",
"membersList",
"(",
"status",
"memberStatus",
")",
"[",
"]",
"string",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n",
"var",
"list",
"[",
"]",
"string",
"\n",
"for",
"_... | // memberList returns a list of members of a specified status | [
"memberList",
"returns",
"a",
"list",
"of",
"members",
"of",
"a",
"specified",
"status"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/cluster.go#L165-L176 |
16,987 | gambol99/go-marathon | cluster.go | String | func (m member) String() string {
status := "UP"
if m.status == memberStatusDown {
status = "DOWN"
}
return fmt.Sprintf("member: %s:%s", m.endpoint, status)
} | go | func (m member) String() string {
status := "UP"
if m.status == memberStatusDown {
status = "DOWN"
}
return fmt.Sprintf("member: %s:%s", m.endpoint, status)
} | [
"func",
"(",
"m",
"member",
")",
"String",
"(",
")",
"string",
"{",
"status",
":=",
"\"",
"\"",
"\n",
"if",
"m",
".",
"status",
"==",
"memberStatusDown",
"{",
"status",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",... | // String returns a string representation | [
"String",
"returns",
"a",
"string",
"representation"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/cluster.go#L184-L191 |
16,988 | gambol99/go-marathon | network.go | NewPodNetwork | func NewPodNetwork(name string) *PodNetwork {
return &PodNetwork{
Name: name,
Labels: map[string]string{},
}
} | go | func NewPodNetwork(name string) *PodNetwork {
return &PodNetwork{
Name: name,
Labels: map[string]string{},
}
} | [
"func",
"NewPodNetwork",
"(",
"name",
"string",
")",
"*",
"PodNetwork",
"{",
"return",
"&",
"PodNetwork",
"{",
"Name",
":",
"name",
",",
"Labels",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewPodNetwork creates an empty PodNetwork | [
"NewPodNetwork",
"creates",
"an",
"empty",
"PodNetwork"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L45-L50 |
16,989 | gambol99/go-marathon | network.go | NewContainerPodNetwork | func NewContainerPodNetwork(name string) *PodNetwork {
pn := NewPodNetwork(name)
return pn.SetMode(ContainerNetworkMode)
} | go | func NewContainerPodNetwork(name string) *PodNetwork {
pn := NewPodNetwork(name)
return pn.SetMode(ContainerNetworkMode)
} | [
"func",
"NewContainerPodNetwork",
"(",
"name",
"string",
")",
"*",
"PodNetwork",
"{",
"pn",
":=",
"NewPodNetwork",
"(",
"name",
")",
"\n",
"return",
"pn",
".",
"SetMode",
"(",
"ContainerNetworkMode",
")",
"\n",
"}"
] | // NewContainerPodNetwork creates a PodNetwork for a container | [
"NewContainerPodNetwork",
"creates",
"a",
"PodNetwork",
"for",
"a",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L67-L70 |
16,990 | gambol99/go-marathon | network.go | SetName | func (n *PodNetwork) SetName(name string) *PodNetwork {
n.Name = name
return n
} | go | func (n *PodNetwork) SetName(name string) *PodNetwork {
n.Name = name
return n
} | [
"func",
"(",
"n",
"*",
"PodNetwork",
")",
"SetName",
"(",
"name",
"string",
")",
"*",
"PodNetwork",
"{",
"n",
".",
"Name",
"=",
"name",
"\n",
"return",
"n",
"\n",
"}"
] | // SetName sets the name of a PodNetwork | [
"SetName",
"sets",
"the",
"name",
"of",
"a",
"PodNetwork"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L79-L82 |
16,991 | gambol99/go-marathon | network.go | SetMode | func (n *PodNetwork) SetMode(mode PodNetworkMode) *PodNetwork {
n.Mode = mode
return n
} | go | func (n *PodNetwork) SetMode(mode PodNetworkMode) *PodNetwork {
n.Mode = mode
return n
} | [
"func",
"(",
"n",
"*",
"PodNetwork",
")",
"SetMode",
"(",
"mode",
"PodNetworkMode",
")",
"*",
"PodNetwork",
"{",
"n",
".",
"Mode",
"=",
"mode",
"\n",
"return",
"n",
"\n",
"}"
] | // SetMode sets the mode of a PodNetwork | [
"SetMode",
"sets",
"the",
"mode",
"of",
"a",
"PodNetwork"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L85-L88 |
16,992 | gambol99/go-marathon | network.go | Label | func (n *PodNetwork) Label(key, value string) *PodNetwork {
n.Labels[key] = value
return n
} | go | func (n *PodNetwork) Label(key, value string) *PodNetwork {
n.Labels[key] = value
return n
} | [
"func",
"(",
"n",
"*",
"PodNetwork",
")",
"Label",
"(",
"key",
",",
"value",
"string",
")",
"*",
"PodNetwork",
"{",
"n",
".",
"Labels",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"n",
"\n",
"}"
] | // Label sets a label of a PodNetwork | [
"Label",
"sets",
"a",
"label",
"of",
"a",
"PodNetwork"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L91-L94 |
16,993 | gambol99/go-marathon | network.go | SetName | func (e *PodEndpoint) SetName(name string) *PodEndpoint {
e.Name = name
return e
} | go | func (e *PodEndpoint) SetName(name string) *PodEndpoint {
e.Name = name
return e
} | [
"func",
"(",
"e",
"*",
"PodEndpoint",
")",
"SetName",
"(",
"name",
"string",
")",
"*",
"PodEndpoint",
"{",
"e",
".",
"Name",
"=",
"name",
"\n",
"return",
"e",
"\n",
"}"
] | // SetName sets the name for a PodEndpoint | [
"SetName",
"sets",
"the",
"name",
"for",
"a",
"PodEndpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L97-L100 |
16,994 | gambol99/go-marathon | network.go | SetContainerPort | func (e *PodEndpoint) SetContainerPort(port int) *PodEndpoint {
e.ContainerPort = port
return e
} | go | func (e *PodEndpoint) SetContainerPort(port int) *PodEndpoint {
e.ContainerPort = port
return e
} | [
"func",
"(",
"e",
"*",
"PodEndpoint",
")",
"SetContainerPort",
"(",
"port",
"int",
")",
"*",
"PodEndpoint",
"{",
"e",
".",
"ContainerPort",
"=",
"port",
"\n",
"return",
"e",
"\n",
"}"
] | // SetContainerPort sets the container port for a PodEndpoint | [
"SetContainerPort",
"sets",
"the",
"container",
"port",
"for",
"a",
"PodEndpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L103-L106 |
16,995 | gambol99/go-marathon | network.go | SetHostPort | func (e *PodEndpoint) SetHostPort(port int) *PodEndpoint {
e.HostPort = port
return e
} | go | func (e *PodEndpoint) SetHostPort(port int) *PodEndpoint {
e.HostPort = port
return e
} | [
"func",
"(",
"e",
"*",
"PodEndpoint",
")",
"SetHostPort",
"(",
"port",
"int",
")",
"*",
"PodEndpoint",
"{",
"e",
".",
"HostPort",
"=",
"port",
"\n",
"return",
"e",
"\n",
"}"
] | // SetHostPort sets the host port for a PodEndpoint | [
"SetHostPort",
"sets",
"the",
"host",
"port",
"for",
"a",
"PodEndpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L109-L112 |
16,996 | gambol99/go-marathon | network.go | AddProtocol | func (e *PodEndpoint) AddProtocol(protocol string) *PodEndpoint {
e.Protocol = append(e.Protocol, protocol)
return e
} | go | func (e *PodEndpoint) AddProtocol(protocol string) *PodEndpoint {
e.Protocol = append(e.Protocol, protocol)
return e
} | [
"func",
"(",
"e",
"*",
"PodEndpoint",
")",
"AddProtocol",
"(",
"protocol",
"string",
")",
"*",
"PodEndpoint",
"{",
"e",
".",
"Protocol",
"=",
"append",
"(",
"e",
".",
"Protocol",
",",
"protocol",
")",
"\n",
"return",
"e",
"\n",
"}"
] | // AddProtocol appends a protocol for a PodEndpoint | [
"AddProtocol",
"appends",
"a",
"protocol",
"for",
"a",
"PodEndpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L115-L118 |
16,997 | gambol99/go-marathon | network.go | Label | func (e *PodEndpoint) Label(key, value string) *PodEndpoint {
e.Labels[key] = value
return e
} | go | func (e *PodEndpoint) Label(key, value string) *PodEndpoint {
e.Labels[key] = value
return e
} | [
"func",
"(",
"e",
"*",
"PodEndpoint",
")",
"Label",
"(",
"key",
",",
"value",
"string",
")",
"*",
"PodEndpoint",
"{",
"e",
".",
"Labels",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"e",
"\n",
"}"
] | // Label sets a label for a PodEndpoint | [
"Label",
"sets",
"a",
"label",
"for",
"a",
"PodEndpoint"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/network.go#L121-L124 |
16,998 | gambol99/go-marathon | pod_instance.go | DeletePodInstances | func (r *marathonClient) DeletePodInstances(name string, instances []string) ([]*PodInstance, error) {
uri := buildPodInstancesURI(name)
var result []*PodInstance
if err := r.apiDelete(uri, instances, &result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) DeletePodInstances(name string, instances []string) ([]*PodInstance, error) {
uri := buildPodInstancesURI(name)
var result []*PodInstance
if err := r.apiDelete(uri, instances, &result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"DeletePodInstances",
"(",
"name",
"string",
",",
"instances",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"PodInstance",
",",
"error",
")",
"{",
"uri",
":=",
"buildPodInstancesURI",
"(",
"name",
")",
"\n",
... | // DeletePodInstances deletes all instances of the named pod | [
"DeletePodInstances",
"deletes",
"all",
"instances",
"of",
"the",
"named",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_instance.go#L82-L90 |
16,999 | gambol99/go-marathon | pod_instance.go | DeletePodInstance | func (r *marathonClient) DeletePodInstance(name, instance string) (*PodInstance, error) {
uri := fmt.Sprintf("%s/%s", buildPodInstancesURI(name), instance)
result := new(PodInstance)
if err := r.apiDelete(uri, nil, result); err != nil {
return nil, err
}
return result, nil
} | go | func (r *marathonClient) DeletePodInstance(name, instance string) (*PodInstance, error) {
uri := fmt.Sprintf("%s/%s", buildPodInstancesURI(name), instance)
result := new(PodInstance)
if err := r.apiDelete(uri, nil, result); err != nil {
return nil, err
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"DeletePodInstance",
"(",
"name",
",",
"instance",
"string",
")",
"(",
"*",
"PodInstance",
",",
"error",
")",
"{",
"uri",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"buildPodInstancesURI",
"(",
"name"... | // DeletePodInstance deletes a specific instance of a pod | [
"DeletePodInstance",
"deletes",
"a",
"specific",
"instance",
"of",
"a",
"pod"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_instance.go#L93-L101 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.