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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
17,000 | gambol99/go-marathon | pod_status.go | PodStatus | func (r *marathonClient) PodStatus(name string) (*PodStatus, error) {
var podStatus PodStatus
if err := r.apiGet(buildPodStatusURI(name), nil, &podStatus); err != nil {
return nil, err
}
return &podStatus, nil
} | go | func (r *marathonClient) PodStatus(name string) (*PodStatus, error) {
var podStatus PodStatus
if err := r.apiGet(buildPodStatusURI(name), nil, &podStatus); err != nil {
return nil, err
}
return &podStatus, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"PodStatus",
"(",
"name",
"string",
")",
"(",
"*",
"PodStatus",
",",
"error",
")",
"{",
"var",
"podStatus",
"PodStatus",
"\n\n",
"if",
"err",
":=",
"r",
".",
"apiGet",
"(",
"buildPodStatusURI",
"(",
"name",
... | // PodStatus retrieves the pod configuration from marathon | [
"PodStatus",
"retrieves",
"the",
"pod",
"configuration",
"from",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_status.go#L68-L76 |
17,001 | gambol99/go-marathon | pod_status.go | PodStatuses | func (r *marathonClient) PodStatuses() ([]*PodStatus, error) {
var podStatuses []*PodStatus
if err := r.apiGet(buildPodStatusURI(""), nil, &podStatuses); err != nil {
return nil, err
}
return podStatuses, nil
} | go | func (r *marathonClient) PodStatuses() ([]*PodStatus, error) {
var podStatuses []*PodStatus
if err := r.apiGet(buildPodStatusURI(""), nil, &podStatuses); err != nil {
return nil, err
}
return podStatuses, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"PodStatuses",
"(",
")",
"(",
"[",
"]",
"*",
"PodStatus",
",",
"error",
")",
"{",
"var",
"podStatuses",
"[",
"]",
"*",
"PodStatus",
"\n\n",
"if",
"err",
":=",
"r",
".",
"apiGet",
"(",
"buildPodStatusURI",
... | // PodStatuses retrieves all pod configuration from marathon | [
"PodStatuses",
"retrieves",
"all",
"pod",
"configuration",
"from",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_status.go#L79-L87 |
17,002 | gambol99/go-marathon | pod_status.go | WaitOnPod | func (r *marathonClient) WaitOnPod(name string, timeout time.Duration) error {
return r.wait(name, timeout, r.PodIsRunning)
} | go | func (r *marathonClient) WaitOnPod(name string, timeout time.Duration) error {
return r.wait(name, timeout, r.PodIsRunning)
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"WaitOnPod",
"(",
"name",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"error",
"{",
"return",
"r",
".",
"wait",
"(",
"name",
",",
"timeout",
",",
"r",
".",
"PodIsRunning",
")",
"\n",
"}"
] | // WaitOnPod blocks until a pod to be deployed | [
"WaitOnPod",
"blocks",
"until",
"a",
"pod",
"to",
"be",
"deployed"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_status.go#L90-L92 |
17,003 | gambol99/go-marathon | pod_status.go | PodIsRunning | func (r *marathonClient) PodIsRunning(name string) bool {
podStatus, err := r.PodStatus(name)
if apiErr, ok := err.(*APIError); ok && apiErr.ErrCode == ErrCodeNotFound {
return false
}
if err == nil && podStatus.Status == PodStateStable {
return true
}
return false
} | go | func (r *marathonClient) PodIsRunning(name string) bool {
podStatus, err := r.PodStatus(name)
if apiErr, ok := err.(*APIError); ok && apiErr.ErrCode == ErrCodeNotFound {
return false
}
if err == nil && podStatus.Status == PodStateStable {
return true
}
return false
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"PodIsRunning",
"(",
"name",
"string",
")",
"bool",
"{",
"podStatus",
",",
"err",
":=",
"r",
".",
"PodStatus",
"(",
"name",
")",
"\n",
"if",
"apiErr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"APIError",
... | // PodIsRunning returns whether the pod is stably running | [
"PodIsRunning",
"returns",
"whether",
"the",
"pod",
"is",
"stably",
"running"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_status.go#L95-L104 |
17,004 | gambol99/go-marathon | readiness.go | SetName | func (rc *ReadinessCheck) SetName(name string) *ReadinessCheck {
rc.Name = &name
return rc
} | go | func (rc *ReadinessCheck) SetName(name string) *ReadinessCheck {
rc.Name = &name
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetName",
"(",
"name",
"string",
")",
"*",
"ReadinessCheck",
"{",
"rc",
".",
"Name",
"=",
"&",
"name",
"\n",
"return",
"rc",
"\n",
"}"
] | // SetName sets the name on the readiness check. | [
"SetName",
"sets",
"the",
"name",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L34-L37 |
17,005 | gambol99/go-marathon | readiness.go | SetProtocol | func (rc *ReadinessCheck) SetProtocol(proto string) *ReadinessCheck {
rc.Protocol = proto
return rc
} | go | func (rc *ReadinessCheck) SetProtocol(proto string) *ReadinessCheck {
rc.Protocol = proto
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetProtocol",
"(",
"proto",
"string",
")",
"*",
"ReadinessCheck",
"{",
"rc",
".",
"Protocol",
"=",
"proto",
"\n",
"return",
"rc",
"\n",
"}"
] | // SetProtocol sets the protocol on the readiness check. | [
"SetProtocol",
"sets",
"the",
"protocol",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L40-L43 |
17,006 | gambol99/go-marathon | readiness.go | SetPath | func (rc *ReadinessCheck) SetPath(p string) *ReadinessCheck {
rc.Path = p
return rc
} | go | func (rc *ReadinessCheck) SetPath(p string) *ReadinessCheck {
rc.Path = p
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetPath",
"(",
"p",
"string",
")",
"*",
"ReadinessCheck",
"{",
"rc",
".",
"Path",
"=",
"p",
"\n",
"return",
"rc",
"\n",
"}"
] | // SetPath sets the path on the readiness check. | [
"SetPath",
"sets",
"the",
"path",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L46-L49 |
17,007 | gambol99/go-marathon | readiness.go | SetPortName | func (rc *ReadinessCheck) SetPortName(name string) *ReadinessCheck {
rc.PortName = name
return rc
} | go | func (rc *ReadinessCheck) SetPortName(name string) *ReadinessCheck {
rc.PortName = name
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetPortName",
"(",
"name",
"string",
")",
"*",
"ReadinessCheck",
"{",
"rc",
".",
"PortName",
"=",
"name",
"\n",
"return",
"rc",
"\n",
"}"
] | // SetPortName sets the port name on the readiness check. | [
"SetPortName",
"sets",
"the",
"port",
"name",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L52-L55 |
17,008 | gambol99/go-marathon | readiness.go | SetInterval | func (rc *ReadinessCheck) SetInterval(interval time.Duration) *ReadinessCheck {
secs := int(interval.Seconds())
rc.IntervalSeconds = secs
return rc
} | go | func (rc *ReadinessCheck) SetInterval(interval time.Duration) *ReadinessCheck {
secs := int(interval.Seconds())
rc.IntervalSeconds = secs
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetInterval",
"(",
"interval",
"time",
".",
"Duration",
")",
"*",
"ReadinessCheck",
"{",
"secs",
":=",
"int",
"(",
"interval",
".",
"Seconds",
"(",
")",
")",
"\n",
"rc",
".",
"IntervalSeconds",
"=",
"secs",... | // SetInterval sets the interval on the readiness check. | [
"SetInterval",
"sets",
"the",
"interval",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L58-L62 |
17,009 | gambol99/go-marathon | readiness.go | SetTimeout | func (rc *ReadinessCheck) SetTimeout(timeout time.Duration) *ReadinessCheck {
secs := int(timeout.Seconds())
rc.TimeoutSeconds = secs
return rc
} | go | func (rc *ReadinessCheck) SetTimeout(timeout time.Duration) *ReadinessCheck {
secs := int(timeout.Seconds())
rc.TimeoutSeconds = secs
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"ReadinessCheck",
"{",
"secs",
":=",
"int",
"(",
"timeout",
".",
"Seconds",
"(",
")",
")",
"\n",
"rc",
".",
"TimeoutSeconds",
"=",
"secs",
"... | // SetTimeout sets the timeout on the readiness check. | [
"SetTimeout",
"sets",
"the",
"timeout",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L65-L69 |
17,010 | gambol99/go-marathon | readiness.go | SetHTTPStatusCodesForReady | func (rc *ReadinessCheck) SetHTTPStatusCodesForReady(codes []int) *ReadinessCheck {
rc.HTTPStatusCodesForReady = &codes
return rc
} | go | func (rc *ReadinessCheck) SetHTTPStatusCodesForReady(codes []int) *ReadinessCheck {
rc.HTTPStatusCodesForReady = &codes
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetHTTPStatusCodesForReady",
"(",
"codes",
"[",
"]",
"int",
")",
"*",
"ReadinessCheck",
"{",
"rc",
".",
"HTTPStatusCodesForReady",
"=",
"&",
"codes",
"\n",
"return",
"rc",
"\n",
"}"
] | // SetHTTPStatusCodesForReady sets the HTTP status codes for ready on the
// readiness check. | [
"SetHTTPStatusCodesForReady",
"sets",
"the",
"HTTP",
"status",
"codes",
"for",
"ready",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L73-L76 |
17,011 | gambol99/go-marathon | readiness.go | SetPreserveLastResponse | func (rc *ReadinessCheck) SetPreserveLastResponse(preserve bool) *ReadinessCheck {
rc.PreserveLastResponse = &preserve
return rc
} | go | func (rc *ReadinessCheck) SetPreserveLastResponse(preserve bool) *ReadinessCheck {
rc.PreserveLastResponse = &preserve
return rc
} | [
"func",
"(",
"rc",
"*",
"ReadinessCheck",
")",
"SetPreserveLastResponse",
"(",
"preserve",
"bool",
")",
"*",
"ReadinessCheck",
"{",
"rc",
".",
"PreserveLastResponse",
"=",
"&",
"preserve",
"\n",
"return",
"rc",
"\n",
"}"
] | // SetPreserveLastResponse sets the preserve last response flag on the
// readiness check. | [
"SetPreserveLastResponse",
"sets",
"the",
"preserve",
"last",
"response",
"flag",
"on",
"the",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/readiness.go#L80-L83 |
17,012 | gambol99/go-marathon | deployment.go | Deployments | func (r *marathonClient) Deployments() ([]*Deployment, error) {
var deployments []*Deployment
err := r.apiGet(marathonAPIDeployments, nil, &deployments)
if err != nil {
return nil, err
}
// Allows loading of deployment steps from the Marathon v1.X API
// Implements a fix for issue https://github.com/gambol99/go-marathon/issues/153
for _, deployment := range deployments {
// Unmarshal pre-v1.X step
if err := json.Unmarshal(deployment.XXStepsRaw, &deployment.Steps); err != nil {
deployment.Steps = make([][]*DeploymentStep, 0)
var steps []*StepActions
// Unmarshal v1.X Marathon step
if err := json.Unmarshal(deployment.XXStepsRaw, &steps); err != nil {
return nil, err
}
for stepIndex, step := range steps {
deployment.Steps = append(deployment.Steps, make([]*DeploymentStep, len(step.Actions)))
for actionIndex, action := range step.Actions {
var stepAction string
if action.Type != "" {
stepAction = action.Type
} else {
stepAction = action.Action
}
deployment.Steps[stepIndex][actionIndex] = &DeploymentStep{
Action: stepAction,
App: action.App,
}
}
}
}
}
return deployments, nil
} | go | func (r *marathonClient) Deployments() ([]*Deployment, error) {
var deployments []*Deployment
err := r.apiGet(marathonAPIDeployments, nil, &deployments)
if err != nil {
return nil, err
}
// Allows loading of deployment steps from the Marathon v1.X API
// Implements a fix for issue https://github.com/gambol99/go-marathon/issues/153
for _, deployment := range deployments {
// Unmarshal pre-v1.X step
if err := json.Unmarshal(deployment.XXStepsRaw, &deployment.Steps); err != nil {
deployment.Steps = make([][]*DeploymentStep, 0)
var steps []*StepActions
// Unmarshal v1.X Marathon step
if err := json.Unmarshal(deployment.XXStepsRaw, &steps); err != nil {
return nil, err
}
for stepIndex, step := range steps {
deployment.Steps = append(deployment.Steps, make([]*DeploymentStep, len(step.Actions)))
for actionIndex, action := range step.Actions {
var stepAction string
if action.Type != "" {
stepAction = action.Type
} else {
stepAction = action.Action
}
deployment.Steps[stepIndex][actionIndex] = &DeploymentStep{
Action: stepAction,
App: action.App,
}
}
}
}
}
return deployments, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Deployments",
"(",
")",
"(",
"[",
"]",
"*",
"Deployment",
",",
"error",
")",
"{",
"var",
"deployments",
"[",
"]",
"*",
"Deployment",
"\n",
"err",
":=",
"r",
".",
"apiGet",
"(",
"marathonAPIDeployments",
",... | // Deployments retrieves a list of current deployments | [
"Deployments",
"retrieves",
"a",
"list",
"of",
"current",
"deployments"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/deployment.go#L70-L105 |
17,013 | gambol99/go-marathon | volume.go | NewPodVolume | func NewPodVolume(name, path string) *PodVolume {
return &PodVolume{
Name: name,
Host: path,
}
} | go | func NewPodVolume(name, path string) *PodVolume {
return &PodVolume{
Name: name,
Host: path,
}
} | [
"func",
"NewPodVolume",
"(",
"name",
",",
"path",
"string",
")",
"*",
"PodVolume",
"{",
"return",
"&",
"PodVolume",
"{",
"Name",
":",
"name",
",",
"Host",
":",
"path",
",",
"}",
"\n",
"}"
] | // NewPodVolume creates a new PodVolume | [
"NewPodVolume",
"creates",
"a",
"new",
"PodVolume"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/volume.go#L34-L39 |
17,014 | gambol99/go-marathon | volume.go | NewPodVolumeMount | func NewPodVolumeMount(name, mount string) *PodVolumeMount {
return &PodVolumeMount{
Name: name,
MountPath: mount,
}
} | go | func NewPodVolumeMount(name, mount string) *PodVolumeMount {
return &PodVolumeMount{
Name: name,
MountPath: mount,
}
} | [
"func",
"NewPodVolumeMount",
"(",
"name",
",",
"mount",
"string",
")",
"*",
"PodVolumeMount",
"{",
"return",
"&",
"PodVolumeMount",
"{",
"Name",
":",
"name",
",",
"MountPath",
":",
"mount",
",",
"}",
"\n",
"}"
] | // NewPodVolumeMount creates a new PodVolumeMount | [
"NewPodVolumeMount",
"creates",
"a",
"new",
"PodVolumeMount"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/volume.go#L42-L47 |
17,015 | gambol99/go-marathon | volume.go | SetPersistentVolume | func (pv *PodVolume) SetPersistentVolume(p *PersistentVolume) *PodVolume {
pv.Persistent = p
return pv
} | go | func (pv *PodVolume) SetPersistentVolume(p *PersistentVolume) *PodVolume {
pv.Persistent = p
return pv
} | [
"func",
"(",
"pv",
"*",
"PodVolume",
")",
"SetPersistentVolume",
"(",
"p",
"*",
"PersistentVolume",
")",
"*",
"PodVolume",
"{",
"pv",
".",
"Persistent",
"=",
"p",
"\n",
"return",
"pv",
"\n",
"}"
] | // SetPersistentVolume sets the persistence settings of a PodVolume | [
"SetPersistentVolume",
"sets",
"the",
"persistence",
"settings",
"of",
"a",
"PodVolume"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/volume.go#L50-L53 |
17,016 | gambol99/go-marathon | info.go | Info | func (r *marathonClient) Info() (*Info, error) {
info := new(Info)
if err := r.apiGet(marathonAPIInfo, nil, info); err != nil {
return nil, err
}
return info, nil
} | go | func (r *marathonClient) Info() (*Info, error) {
info := new(Info)
if err := r.apiGet(marathonAPIInfo, nil, info); err != nil {
return nil, err
}
return info, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Info",
"(",
")",
"(",
"*",
"Info",
",",
"error",
")",
"{",
"info",
":=",
"new",
"(",
"Info",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"apiGet",
"(",
"marathonAPIInfo",
",",
"nil",
",",
"info",
")",
... | // Info retrieves the info stats from marathon | [
"Info",
"retrieves",
"the",
"info",
"stats",
"from",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/info.go#L68-L75 |
17,017 | gambol99/go-marathon | info.go | Leader | func (r *marathonClient) Leader() (string, error) {
var leader struct {
Leader string `json:"leader"`
}
if err := r.apiGet(marathonAPILeader, nil, &leader); err != nil {
return "", err
}
return leader.Leader, nil
} | go | func (r *marathonClient) Leader() (string, error) {
var leader struct {
Leader string `json:"leader"`
}
if err := r.apiGet(marathonAPILeader, nil, &leader); err != nil {
return "", err
}
return leader.Leader, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Leader",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"leader",
"struct",
"{",
"Leader",
"string",
"`json:\"leader\"`",
"\n",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"apiGet",
"(",
"marathonAPIL... | // Leader retrieves the current marathon leader node | [
"Leader",
"retrieves",
"the",
"current",
"marathon",
"leader",
"node"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/info.go#L78-L87 |
17,018 | gambol99/go-marathon | info.go | AbdicateLeader | func (r *marathonClient) AbdicateLeader() (string, error) {
var message struct {
Message string `json:"message"`
}
if err := r.apiDelete(marathonAPILeader, nil, &message); err != nil {
return "", err
}
return message.Message, nil
} | go | func (r *marathonClient) AbdicateLeader() (string, error) {
var message struct {
Message string `json:"message"`
}
if err := r.apiDelete(marathonAPILeader, nil, &message); err != nil {
return "", err
}
return message.Message, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"AbdicateLeader",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"message",
"struct",
"{",
"Message",
"string",
"`json:\"message\"`",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"r",
".",
"apiDelete",
"(",... | // AbdicateLeader abdicates the marathon leadership | [
"AbdicateLeader",
"abdicates",
"the",
"marathon",
"leadership"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/info.go#L90-L100 |
17,019 | gambol99/go-marathon | pod_container_image.go | SetKind | func (i *PodContainerImage) SetKind(typ ImageType) *PodContainerImage {
i.Kind = typ
return i
} | go | func (i *PodContainerImage) SetKind(typ ImageType) *PodContainerImage {
i.Kind = typ
return i
} | [
"func",
"(",
"i",
"*",
"PodContainerImage",
")",
"SetKind",
"(",
"typ",
"ImageType",
")",
"*",
"PodContainerImage",
"{",
"i",
".",
"Kind",
"=",
"typ",
"\n",
"return",
"i",
"\n",
"}"
] | // SetKind sets the Kind of the image | [
"SetKind",
"sets",
"the",
"Kind",
"of",
"the",
"image"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container_image.go#L43-L46 |
17,020 | gambol99/go-marathon | pod_container_image.go | SetID | func (i *PodContainerImage) SetID(id string) *PodContainerImage {
i.ID = id
return i
} | go | func (i *PodContainerImage) SetID(id string) *PodContainerImage {
i.ID = id
return i
} | [
"func",
"(",
"i",
"*",
"PodContainerImage",
")",
"SetID",
"(",
"id",
"string",
")",
"*",
"PodContainerImage",
"{",
"i",
".",
"ID",
"=",
"id",
"\n",
"return",
"i",
"\n",
"}"
] | // SetID sets the ID of the image | [
"SetID",
"sets",
"the",
"ID",
"of",
"the",
"image"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container_image.go#L49-L52 |
17,021 | gambol99/go-marathon | group.go | Groups | func (r *marathonClient) Groups() (*Groups, error) {
groups := new(Groups)
if err := r.apiGet(marathonAPIGroups, "", groups); err != nil {
return nil, err
}
return groups, nil
} | go | func (r *marathonClient) Groups() (*Groups, error) {
groups := new(Groups)
if err := r.apiGet(marathonAPIGroups, "", groups); err != nil {
return nil, err
}
return groups, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Groups",
"(",
")",
"(",
"*",
"Groups",
",",
"error",
")",
"{",
"groups",
":=",
"new",
"(",
"Groups",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"apiGet",
"(",
"marathonAPIGroups",
",",
"\"",
"\"",
",",
... | // Groups retrieves a list of all the groups from marathon | [
"Groups",
"retrieves",
"a",
"list",
"of",
"all",
"the",
"groups",
"from",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/group.go#L88-L94 |
17,022 | gambol99/go-marathon | client.go | buildAPIRequest | func (r *marathonClient) buildAPIRequest(method, path string, reader io.Reader) (request *http.Request, member string, err error) {
// Grab a member from the cluster
member, err = r.hosts.getMember()
if err != nil {
return nil, "", ErrMarathonDown
}
// Build the HTTP request to Marathon
request, err = r.client.buildMarathonJSONRequest(method, member, path, reader)
if err != nil {
return nil, member, newRequestError{err}
}
return request, member, nil
} | go | func (r *marathonClient) buildAPIRequest(method, path string, reader io.Reader) (request *http.Request, member string, err error) {
// Grab a member from the cluster
member, err = r.hosts.getMember()
if err != nil {
return nil, "", ErrMarathonDown
}
// Build the HTTP request to Marathon
request, err = r.client.buildMarathonJSONRequest(method, member, path, reader)
if err != nil {
return nil, member, newRequestError{err}
}
return request, member, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"buildAPIRequest",
"(",
"method",
",",
"path",
"string",
",",
"reader",
"io",
".",
"Reader",
")",
"(",
"request",
"*",
"http",
".",
"Request",
",",
"member",
"string",
",",
"err",
"error",
")",
"{",
"// Gra... | // buildAPIRequest creates a default API request.
// It fails when there is no available member in the cluster anymore or when the request can not be built. | [
"buildAPIRequest",
"creates",
"a",
"default",
"API",
"request",
".",
"It",
"fails",
"when",
"there",
"is",
"no",
"available",
"member",
"in",
"the",
"cluster",
"anymore",
"or",
"when",
"the",
"request",
"can",
"not",
"be",
"built",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/client.go#L429-L442 |
17,023 | gambol99/go-marathon | client.go | oneLogLine | func oneLogLine(in []byte) []byte {
return bytes.Replace(oneLogLineRegex.ReplaceAll(in, nil), []byte("\n"), []byte("\\n "), -1)
} | go | func oneLogLine(in []byte) []byte {
return bytes.Replace(oneLogLineRegex.ReplaceAll(in, nil), []byte("\n"), []byte("\\n "), -1)
} | [
"func",
"oneLogLine",
"(",
"in",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"return",
"bytes",
".",
"Replace",
"(",
"oneLogLineRegex",
".",
"ReplaceAll",
"(",
"in",
",",
"nil",
")",
",",
"[",
"]",
"byte",
"(",
"\"",
"\\n",
"\"",
")",
",",
"[",... | // oneLogLine removes indentation at the beginning of each line and
// escapes new line characters. | [
"oneLogLine",
"removes",
"indentation",
"at",
"the",
"beginning",
"of",
"each",
"line",
"and",
"escapes",
"new",
"line",
"characters",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/client.go#L492-L494 |
17,024 | gambol99/go-marathon | application.go | SetIPAddressPerTask | func (r *Application) SetIPAddressPerTask(ipAddressPerTask IPAddressPerTask) *Application {
r.Ports = make([]int, 0)
r.EmptyPortDefinitions()
r.IPAddressPerTask = &ipAddressPerTask
return r
} | go | func (r *Application) SetIPAddressPerTask(ipAddressPerTask IPAddressPerTask) *Application {
r.Ports = make([]int, 0)
r.EmptyPortDefinitions()
r.IPAddressPerTask = &ipAddressPerTask
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"SetIPAddressPerTask",
"(",
"ipAddressPerTask",
"IPAddressPerTask",
")",
"*",
"Application",
"{",
"r",
".",
"Ports",
"=",
"make",
"(",
"[",
"]",
"int",
",",
"0",
")",
"\n",
"r",
".",
"EmptyPortDefinitions",
"(",
... | // SetIPAddressPerTask defines that the application will have a IP address defines by a external agent.
// This configuration is not allowed to be used with Port or PortDefinitions. Thus, the implementation
// clears both. | [
"SetIPAddressPerTask",
"defines",
"that",
"the",
"application",
"will",
"have",
"a",
"IP",
"address",
"defines",
"by",
"a",
"external",
"agent",
".",
"This",
"configuration",
"is",
"not",
"allowed",
"to",
"be",
"used",
"with",
"Port",
"or",
"PortDefinitions",
... | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L168-L174 |
17,025 | gambol99/go-marathon | application.go | Command | func (r *Application) Command(cmd string) *Application {
r.Cmd = &cmd
return r
} | go | func (r *Application) Command(cmd string) *Application {
r.Cmd = &cmd
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"Command",
"(",
"cmd",
"string",
")",
"*",
"Application",
"{",
"r",
".",
"Cmd",
"=",
"&",
"cmd",
"\n",
"return",
"r",
"\n",
"}"
] | // Command sets the cmd of the application | [
"Command",
"sets",
"the",
"cmd",
"of",
"the",
"application"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L190-L193 |
17,026 | gambol99/go-marathon | application.go | AllTaskRunning | func (r *Application) AllTaskRunning() bool {
if r.Instances == nil || *r.Instances == 0 {
return true
}
if r.Tasks == nil {
return false
}
if r.TasksRunning == *r.Instances {
return true
}
return false
} | go | func (r *Application) AllTaskRunning() bool {
if r.Instances == nil || *r.Instances == 0 {
return true
}
if r.Tasks == nil {
return false
}
if r.TasksRunning == *r.Instances {
return true
}
return false
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"AllTaskRunning",
"(",
")",
"bool",
"{",
"if",
"r",
".",
"Instances",
"==",
"nil",
"||",
"*",
"r",
".",
"Instances",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"r",
".",
"Tasks",
"==",
"nil... | // AllTaskRunning checks to see if all the application tasks are running, i.e. the instances is equal
// to the number of running tasks | [
"AllTaskRunning",
"checks",
"to",
"see",
"if",
"all",
"the",
"application",
"tasks",
"are",
"running",
"i",
".",
"e",
".",
"the",
"instances",
"is",
"equal",
"to",
"the",
"number",
"of",
"running",
"tasks"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L228-L239 |
17,027 | gambol99/go-marathon | application.go | AddPortDefinition | func (r *Application) AddPortDefinition(portDefinition PortDefinition) *Application {
if r.PortDefinitions == nil {
r.EmptyPortDefinitions()
}
portDefinitions := *r.PortDefinitions
portDefinitions = append(portDefinitions, portDefinition)
r.PortDefinitions = &portDefinitions
return r
} | go | func (r *Application) AddPortDefinition(portDefinition PortDefinition) *Application {
if r.PortDefinitions == nil {
r.EmptyPortDefinitions()
}
portDefinitions := *r.PortDefinitions
portDefinitions = append(portDefinitions, portDefinition)
r.PortDefinitions = &portDefinitions
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"AddPortDefinition",
"(",
"portDefinition",
"PortDefinition",
")",
"*",
"Application",
"{",
"if",
"r",
".",
"PortDefinitions",
"==",
"nil",
"{",
"r",
".",
"EmptyPortDefinitions",
"(",
")",
"\n",
"}",
"\n\n",
"portDe... | // AddPortDefinition adds a port definition. Port definitions are used to define ports that
// should be considered part of a resource. They are necessary when you are using HOST
// networking and no port mappings are specified. | [
"AddPortDefinition",
"adds",
"a",
"port",
"definition",
".",
"Port",
"definitions",
"are",
"used",
"to",
"define",
"ports",
"that",
"should",
"be",
"considered",
"part",
"of",
"a",
"resource",
".",
"They",
"are",
"necessary",
"when",
"you",
"are",
"using",
"... | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L265-L274 |
17,028 | gambol99/go-marathon | application.go | SetExecutor | func (r *Application) SetExecutor(executor string) *Application {
r.Executor = &executor
return r
} | go | func (r *Application) SetExecutor(executor string) *Application {
r.Executor = &executor
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"SetExecutor",
"(",
"executor",
"string",
")",
"*",
"Application",
"{",
"r",
".",
"Executor",
"=",
"&",
"executor",
"\n\n",
"return",
"r",
"\n",
"}"
] | // SetExecutor sets the executor | [
"SetExecutor",
"sets",
"the",
"executor"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L414-L418 |
17,029 | gambol99/go-marathon | application.go | AddHealthCheck | func (r *Application) AddHealthCheck(healthCheck HealthCheck) *Application {
if r.HealthChecks == nil {
r.EmptyHealthChecks()
}
healthChecks := *r.HealthChecks
healthChecks = append(healthChecks, healthCheck)
r.HealthChecks = &healthChecks
return r
} | go | func (r *Application) AddHealthCheck(healthCheck HealthCheck) *Application {
if r.HealthChecks == nil {
r.EmptyHealthChecks()
}
healthChecks := *r.HealthChecks
healthChecks = append(healthChecks, healthCheck)
r.HealthChecks = &healthChecks
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"AddHealthCheck",
"(",
"healthCheck",
"HealthCheck",
")",
"*",
"Application",
"{",
"if",
"r",
".",
"HealthChecks",
"==",
"nil",
"{",
"r",
".",
"EmptyHealthChecks",
"(",
")",
"\n",
"}",
"\n\n",
"healthChecks",
":="... | // AddHealthCheck adds a health check
// healthCheck the health check that should be added | [
"AddHealthCheck",
"adds",
"a",
"health",
"check",
"healthCheck",
"the",
"health",
"check",
"that",
"should",
"be",
"added"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L422-L432 |
17,030 | gambol99/go-marathon | application.go | HasHealthChecks | func (r *Application) HasHealthChecks() bool {
return r.HealthChecks != nil && len(*r.HealthChecks) > 0
} | go | func (r *Application) HasHealthChecks() bool {
return r.HealthChecks != nil && len(*r.HealthChecks) > 0
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"HasHealthChecks",
"(",
")",
"bool",
"{",
"return",
"r",
".",
"HealthChecks",
"!=",
"nil",
"&&",
"len",
"(",
"*",
"r",
".",
"HealthChecks",
")",
">",
"0",
"\n",
"}"
] | // HasHealthChecks is a helper method, used to check if an application has health checks | [
"HasHealthChecks",
"is",
"a",
"helper",
"method",
"used",
"to",
"check",
"if",
"an",
"application",
"has",
"health",
"checks"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L444-L446 |
17,031 | gambol99/go-marathon | application.go | AddReadinessCheck | func (r *Application) AddReadinessCheck(readinessCheck ReadinessCheck) *Application {
if r.ReadinessChecks == nil {
r.EmptyReadinessChecks()
}
readinessChecks := *r.ReadinessChecks
readinessChecks = append(readinessChecks, readinessCheck)
r.ReadinessChecks = &readinessChecks
return r
} | go | func (r *Application) AddReadinessCheck(readinessCheck ReadinessCheck) *Application {
if r.ReadinessChecks == nil {
r.EmptyReadinessChecks()
}
readinessChecks := *r.ReadinessChecks
readinessChecks = append(readinessChecks, readinessCheck)
r.ReadinessChecks = &readinessChecks
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"AddReadinessCheck",
"(",
"readinessCheck",
"ReadinessCheck",
")",
"*",
"Application",
"{",
"if",
"r",
".",
"ReadinessChecks",
"==",
"nil",
"{",
"r",
".",
"EmptyReadinessChecks",
"(",
")",
"\n",
"}",
"\n\n",
"readin... | // AddReadinessCheck adds a readiness check. | [
"AddReadinessCheck",
"adds",
"a",
"readiness",
"check",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L449-L459 |
17,032 | gambol99/go-marathon | application.go | DeploymentIDs | func (r *Application) DeploymentIDs() []*DeploymentID {
var deployments []*DeploymentID
if r.Deployments == nil {
return deployments
}
// step: extract the deployment id from the result
for _, deploy := range r.Deployments {
if id, found := deploy["id"]; found {
deployment := &DeploymentID{
Version: r.Version,
DeploymentID: id,
}
deployments = append(deployments, deployment)
}
}
return deployments
} | go | func (r *Application) DeploymentIDs() []*DeploymentID {
var deployments []*DeploymentID
if r.Deployments == nil {
return deployments
}
// step: extract the deployment id from the result
for _, deploy := range r.Deployments {
if id, found := deploy["id"]; found {
deployment := &DeploymentID{
Version: r.Version,
DeploymentID: id,
}
deployments = append(deployments, deployment)
}
}
return deployments
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"DeploymentIDs",
"(",
")",
"[",
"]",
"*",
"DeploymentID",
"{",
"var",
"deployments",
"[",
"]",
"*",
"DeploymentID",
"\n\n",
"if",
"r",
".",
"Deployments",
"==",
"nil",
"{",
"return",
"deployments",
"\n",
"}",
... | // DeploymentIDs retrieves the application deployments IDs | [
"DeploymentIDs",
"retrieves",
"the",
"application",
"deployments",
"IDs"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L469-L488 |
17,033 | gambol99/go-marathon | application.go | SetUpgradeStrategy | func (r *Application) SetUpgradeStrategy(us UpgradeStrategy) *Application {
r.UpgradeStrategy = &us
return r
} | go | func (r *Application) SetUpgradeStrategy(us UpgradeStrategy) *Application {
r.UpgradeStrategy = &us
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"SetUpgradeStrategy",
"(",
"us",
"UpgradeStrategy",
")",
"*",
"Application",
"{",
"r",
".",
"UpgradeStrategy",
"=",
"&",
"us",
"\n",
"return",
"r",
"\n",
"}"
] | // SetUpgradeStrategy sets the upgrade strategy. | [
"SetUpgradeStrategy",
"sets",
"the",
"upgrade",
"strategy",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L588-L591 |
17,034 | gambol99/go-marathon | application.go | SetUnreachableStrategy | func (r *Application) SetUnreachableStrategy(us UnreachableStrategy) *Application {
r.UnreachableStrategy = &us
return r
} | go | func (r *Application) SetUnreachableStrategy(us UnreachableStrategy) *Application {
r.UnreachableStrategy = &us
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"SetUnreachableStrategy",
"(",
"us",
"UnreachableStrategy",
")",
"*",
"Application",
"{",
"r",
".",
"UnreachableStrategy",
"=",
"&",
"us",
"\n",
"return",
"r",
"\n",
"}"
] | // SetUnreachableStrategy sets the unreachable strategy. | [
"SetUnreachableStrategy",
"sets",
"the",
"unreachable",
"strategy",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L602-L605 |
17,035 | gambol99/go-marathon | application.go | SetResidency | func (r *Application) SetResidency(whenLost TaskLostBehaviorType) *Application {
r.Residency = &Residency{
TaskLostBehavior: whenLost,
}
return r
} | go | func (r *Application) SetResidency(whenLost TaskLostBehaviorType) *Application {
r.Residency = &Residency{
TaskLostBehavior: whenLost,
}
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"SetResidency",
"(",
"whenLost",
"TaskLostBehaviorType",
")",
"*",
"Application",
"{",
"r",
".",
"Residency",
"=",
"&",
"Residency",
"{",
"TaskLostBehavior",
":",
"whenLost",
",",
"}",
"\n",
"return",
"r",
"\n",
"... | // SetResidency sets behavior for resident applications, an application is resident when
// it has local persistent volumes set | [
"SetResidency",
"sets",
"behavior",
"for",
"resident",
"applications",
"an",
"application",
"is",
"resident",
"when",
"it",
"has",
"local",
"persistent",
"volumes",
"set"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L617-L622 |
17,036 | gambol99/go-marathon | application.go | String | func (r *Application) String() string {
s, err := json.MarshalIndent(r, "", " ")
if err != nil {
return fmt.Sprintf(`{"error": "error decoding type into json: %s"}`, err)
}
return string(s)
} | go | func (r *Application) String() string {
s, err := json.MarshalIndent(r, "", " ")
if err != nil {
return fmt.Sprintf(`{"error": "error decoding type into json: %s"}`, err)
}
return string(s)
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"String",
"(",
")",
"string",
"{",
"s",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"r",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Spri... | // String returns the json representation of this application | [
"String",
"returns",
"the",
"json",
"representation",
"of",
"this",
"application"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L633-L640 |
17,037 | gambol99/go-marathon | application.go | Applications | func (r *marathonClient) Applications(v url.Values) (*Applications, error) {
query := v.Encode()
if query != "" {
query = "?" + query
}
applications := new(Applications)
err := r.apiGet(marathonAPIApps+query, nil, applications)
if err != nil {
return nil, err
}
return applications, nil
} | go | func (r *marathonClient) Applications(v url.Values) (*Applications, error) {
query := v.Encode()
if query != "" {
query = "?" + query
}
applications := new(Applications)
err := r.apiGet(marathonAPIApps+query, nil, applications)
if err != nil {
return nil, err
}
return applications, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"Applications",
"(",
"v",
"url",
".",
"Values",
")",
"(",
"*",
"Applications",
",",
"error",
")",
"{",
"query",
":=",
"v",
".",
"Encode",
"(",
")",
"\n",
"if",
"query",
"!=",
"\"",
"\"",
"{",
"query",
... | // Applications retrieves an array of all the applications which are running in marathon | [
"Applications",
"retrieves",
"an",
"array",
"of",
"all",
"the",
"applications",
"which",
"are",
"running",
"in",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L643-L656 |
17,038 | gambol99/go-marathon | application.go | ListApplications | func (r *marathonClient) ListApplications(v url.Values) ([]string, error) {
applications, err := r.Applications(v)
if err != nil {
return nil, err
}
var list []string
for _, application := range applications.Apps {
list = append(list, application.ID)
}
return list, nil
} | go | func (r *marathonClient) ListApplications(v url.Values) ([]string, error) {
applications, err := r.Applications(v)
if err != nil {
return nil, err
}
var list []string
for _, application := range applications.Apps {
list = append(list, application.ID)
}
return list, nil
} | [
"func",
"(",
"r",
"*",
"marathonClient",
")",
"ListApplications",
"(",
"v",
"url",
".",
"Values",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"applications",
",",
"err",
":=",
"r",
".",
"Applications",
"(",
"v",
")",
"\n",
"if",
"err",
"!... | // ListApplications retrieves an array of the application names currently running in marathon | [
"ListApplications",
"retrieves",
"an",
"array",
"of",
"the",
"application",
"names",
"currently",
"running",
"in",
"marathon"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L659-L670 |
17,039 | gambol99/go-marathon | application.go | SetNetwork | func (r *Application) SetNetwork(name string, mode PodNetworkMode) *Application {
if r.Networks == nil {
r.EmptyNetworks()
}
network := PodNetwork{Name: name, Mode: mode}
networks := *r.Networks
networks = append(networks, network)
r.Networks = &networks
return r
} | go | func (r *Application) SetNetwork(name string, mode PodNetworkMode) *Application {
if r.Networks == nil {
r.EmptyNetworks()
}
network := PodNetwork{Name: name, Mode: mode}
networks := *r.Networks
networks = append(networks, network)
r.Networks = &networks
return r
} | [
"func",
"(",
"r",
"*",
"Application",
")",
"SetNetwork",
"(",
"name",
"string",
",",
"mode",
"PodNetworkMode",
")",
"*",
"Application",
"{",
"if",
"r",
".",
"Networks",
"==",
"nil",
"{",
"r",
".",
"EmptyNetworks",
"(",
")",
"\n",
"}",
"\n\n",
"network"... | // SetNetwork sets the networking mode | [
"SetNetwork",
"sets",
"the",
"networking",
"mode"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application.go#L975-L985 |
17,040 | gambol99/go-marathon | task.go | HasHealthCheckResults | func (r *Task) HasHealthCheckResults() bool {
return r.HealthCheckResults != nil && len(r.HealthCheckResults) > 0
} | go | func (r *Task) HasHealthCheckResults() bool {
return r.HealthCheckResults != nil && len(r.HealthCheckResults) > 0
} | [
"func",
"(",
"r",
"*",
"Task",
")",
"HasHealthCheckResults",
"(",
")",
"bool",
"{",
"return",
"r",
".",
"HealthCheckResults",
"!=",
"nil",
"&&",
"len",
"(",
"r",
".",
"HealthCheckResults",
")",
">",
"0",
"\n",
"}"
] | // HasHealthCheckResults checks if the task has any health checks | [
"HasHealthCheckResults",
"checks",
"if",
"the",
"task",
"has",
"any",
"health",
"checks"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/task.go#L76-L78 |
17,041 | gambol99/go-marathon | port_definition.go | SetPort | func (p *PortDefinition) SetPort(port int) *PortDefinition {
if p.Port == nil {
p.EmptyPort()
}
p.Port = &port
return p
} | go | func (p *PortDefinition) SetPort(port int) *PortDefinition {
if p.Port == nil {
p.EmptyPort()
}
p.Port = &port
return p
} | [
"func",
"(",
"p",
"*",
"PortDefinition",
")",
"SetPort",
"(",
"port",
"int",
")",
"*",
"PortDefinition",
"{",
"if",
"p",
".",
"Port",
"==",
"nil",
"{",
"p",
".",
"EmptyPort",
"(",
")",
"\n",
"}",
"\n",
"p",
".",
"Port",
"=",
"&",
"port",
"\n",
... | // SetPort sets the given port for the PortDefinition | [
"SetPort",
"sets",
"the",
"given",
"port",
"for",
"the",
"PortDefinition"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/port_definition.go#L30-L36 |
17,042 | gambol99/go-marathon | pod_marshalling.go | UnmarshalJSON | func (p *Pod) UnmarshalJSON(b []byte) error {
aux := &struct {
*PodAlias
Env map[string]interface{} `json:"environment"`
Secrets map[string]TmpSecret `json:"secrets"`
}{
PodAlias: (*PodAlias)(p),
}
if err := json.Unmarshal(b, aux); err != nil {
return fmt.Errorf("malformed pod definition %v", err)
}
env := map[string]string{}
secrets := map[string]Secret{}
for envName, genericEnvValue := range aux.Env {
switch envValOrSecret := genericEnvValue.(type) {
case string:
env[envName] = envValOrSecret
case map[string]interface{}:
for secret, secretStore := range envValOrSecret {
if secStore, ok := secretStore.(string); ok && secret == "secret" {
secrets[secStore] = Secret{EnvVar: envName}
break
}
return fmt.Errorf("unexpected secret field %v of value type %T", secret, envValOrSecret[secret])
}
default:
return fmt.Errorf("unexpected environment variable type %T", envValOrSecret)
}
}
p.Env = env
for k, v := range aux.Secrets {
tmp := secrets[k]
tmp.Source = v.Source
secrets[k] = tmp
}
p.Secrets = secrets
return nil
} | go | func (p *Pod) UnmarshalJSON(b []byte) error {
aux := &struct {
*PodAlias
Env map[string]interface{} `json:"environment"`
Secrets map[string]TmpSecret `json:"secrets"`
}{
PodAlias: (*PodAlias)(p),
}
if err := json.Unmarshal(b, aux); err != nil {
return fmt.Errorf("malformed pod definition %v", err)
}
env := map[string]string{}
secrets := map[string]Secret{}
for envName, genericEnvValue := range aux.Env {
switch envValOrSecret := genericEnvValue.(type) {
case string:
env[envName] = envValOrSecret
case map[string]interface{}:
for secret, secretStore := range envValOrSecret {
if secStore, ok := secretStore.(string); ok && secret == "secret" {
secrets[secStore] = Secret{EnvVar: envName}
break
}
return fmt.Errorf("unexpected secret field %v of value type %T", secret, envValOrSecret[secret])
}
default:
return fmt.Errorf("unexpected environment variable type %T", envValOrSecret)
}
}
p.Env = env
for k, v := range aux.Secrets {
tmp := secrets[k]
tmp.Source = v.Source
secrets[k] = tmp
}
p.Secrets = secrets
return nil
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"aux",
":=",
"&",
"struct",
"{",
"*",
"PodAlias",
"\n",
"Env",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"`json:\"environment\"`",
"\n",
"Secre... | // UnmarshalJSON unmarshals the given Pod JSON as expected except for environment variables and secrets.
// Environment variables are stored in the Env field. Secrets, including the environment variable part,
// are stored in the Secrets field. | [
"UnmarshalJSON",
"unmarshals",
"the",
"given",
"Pod",
"JSON",
"as",
"expected",
"except",
"for",
"environment",
"variables",
"and",
"secrets",
".",
"Environment",
"variables",
"are",
"stored",
"in",
"the",
"Env",
"field",
".",
"Secrets",
"including",
"the",
"env... | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_marshalling.go#L30-L68 |
17,043 | gambol99/go-marathon | pod_marshalling.go | MarshalJSON | func (p *Pod) MarshalJSON() ([]byte, error) {
env := make(map[string]interface{})
secrets := make(map[string]TmpSecret)
if p.Env != nil {
for k, v := range p.Env {
env[string(k)] = string(v)
}
}
if p.Secrets != nil {
for k, v := range p.Secrets {
// Only add it to the root level pod environment if it's used
// Otherwise it's likely in one of the container environments
if v.EnvVar != "" {
env[v.EnvVar] = TmpEnvSecret{Secret: k}
}
secrets[k] = TmpSecret{v.Source}
}
}
aux := &struct {
*PodAlias
Env map[string]interface{} `json:"environment,omitempty"`
Secrets map[string]TmpSecret `json:"secrets,omitempty"`
}{PodAlias: (*PodAlias)(p), Env: env, Secrets: secrets}
return json.Marshal(aux)
} | go | func (p *Pod) MarshalJSON() ([]byte, error) {
env := make(map[string]interface{})
secrets := make(map[string]TmpSecret)
if p.Env != nil {
for k, v := range p.Env {
env[string(k)] = string(v)
}
}
if p.Secrets != nil {
for k, v := range p.Secrets {
// Only add it to the root level pod environment if it's used
// Otherwise it's likely in one of the container environments
if v.EnvVar != "" {
env[v.EnvVar] = TmpEnvSecret{Secret: k}
}
secrets[k] = TmpSecret{v.Source}
}
}
aux := &struct {
*PodAlias
Env map[string]interface{} `json:"environment,omitempty"`
Secrets map[string]TmpSecret `json:"secrets,omitempty"`
}{PodAlias: (*PodAlias)(p), Env: env, Secrets: secrets}
return json.Marshal(aux)
} | [
"func",
"(",
"p",
"*",
"Pod",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"env",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"secrets",
":=",
"make",
"(",
"map",
"[",
"string"... | // MarshalJSON marshals the given Pod as expected except for environment variables and secrets,
// which are marshaled from specialized structs. The environment variable piece of the secrets and other
// normal environment variables are combined and marshaled to the env field. The secrets and the related
// source are marshaled into the secrets field. | [
"MarshalJSON",
"marshals",
"the",
"given",
"Pod",
"as",
"expected",
"except",
"for",
"environment",
"variables",
"and",
"secrets",
"which",
"are",
"marshaled",
"from",
"specialized",
"structs",
".",
"The",
"environment",
"variable",
"piece",
"of",
"the",
"secrets"... | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_marshalling.go#L74-L100 |
17,044 | gambol99/go-marathon | config.go | NewDefaultConfig | func NewDefaultConfig() Config {
return Config{
URL: "http://127.0.0.1:8080",
EventsTransport: EventsTransportCallback,
EventsPort: 10001,
EventsInterface: "eth0",
LogOutput: ioutil.Discard,
PollingWaitTime: defaultPollingWaitTime,
}
} | go | func NewDefaultConfig() Config {
return Config{
URL: "http://127.0.0.1:8080",
EventsTransport: EventsTransportCallback,
EventsPort: 10001,
EventsInterface: "eth0",
LogOutput: ioutil.Discard,
PollingWaitTime: defaultPollingWaitTime,
}
} | [
"func",
"NewDefaultConfig",
"(",
")",
"Config",
"{",
"return",
"Config",
"{",
"URL",
":",
"\"",
"\"",
",",
"EventsTransport",
":",
"EventsTransportCallback",
",",
"EventsPort",
":",
"10001",
",",
"EventsInterface",
":",
"\"",
"\"",
",",
"LogOutput",
":",
"io... | // NewDefaultConfig create a default client config | [
"NewDefaultConfig",
"create",
"a",
"default",
"client",
"config"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/config.go#L62-L71 |
17,045 | gambol99/go-marathon | error.go | newInvalidEndpointError | func newInvalidEndpointError(message string, args ...interface{}) error {
return &InvalidEndpointError{message: fmt.Sprintf(message, args...)}
} | go | func newInvalidEndpointError(message string, args ...interface{}) error {
return &InvalidEndpointError{message: fmt.Sprintf(message, args...)}
} | [
"func",
"newInvalidEndpointError",
"(",
"message",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"&",
"InvalidEndpointError",
"{",
"message",
":",
"fmt",
".",
"Sprintf",
"(",
"message",
",",
"args",
"...",
")",
"}",
"\n"... | // newInvalidEndpointError creates a new error | [
"newInvalidEndpointError",
"creates",
"a",
"new",
"error"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/error.go#L60-L62 |
17,046 | gambol99/go-marathon | error.go | NewAPIError | func NewAPIError(code int, content []byte) error {
var errDef errorDefinition
switch {
case code == http.StatusBadRequest:
errDef = &badRequestDef{}
case code == http.StatusUnauthorized:
errDef = &simpleErrDef{code: ErrCodeUnauthorized}
case code == http.StatusForbidden:
errDef = &simpleErrDef{code: ErrCodeForbidden}
case code == http.StatusNotFound:
errDef = &simpleErrDef{code: ErrCodeNotFound}
case code == http.StatusMethodNotAllowed:
errDef = &simpleErrDef{code: ErrCodeMethodNotAllowed}
case code == http.StatusConflict:
errDef = &conflictDef{}
case code == 422:
errDef = &unprocessableEntityDef{}
case code >= http.StatusInternalServerError:
errDef = &simpleErrDef{code: ErrCodeServer}
default:
errDef = &simpleErrDef{code: ErrCodeUnknown}
}
return parseContent(errDef, content)
} | go | func NewAPIError(code int, content []byte) error {
var errDef errorDefinition
switch {
case code == http.StatusBadRequest:
errDef = &badRequestDef{}
case code == http.StatusUnauthorized:
errDef = &simpleErrDef{code: ErrCodeUnauthorized}
case code == http.StatusForbidden:
errDef = &simpleErrDef{code: ErrCodeForbidden}
case code == http.StatusNotFound:
errDef = &simpleErrDef{code: ErrCodeNotFound}
case code == http.StatusMethodNotAllowed:
errDef = &simpleErrDef{code: ErrCodeMethodNotAllowed}
case code == http.StatusConflict:
errDef = &conflictDef{}
case code == 422:
errDef = &unprocessableEntityDef{}
case code >= http.StatusInternalServerError:
errDef = &simpleErrDef{code: ErrCodeServer}
default:
errDef = &simpleErrDef{code: ErrCodeUnknown}
}
return parseContent(errDef, content)
} | [
"func",
"NewAPIError",
"(",
"code",
"int",
",",
"content",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"errDef",
"errorDefinition",
"\n",
"switch",
"{",
"case",
"code",
"==",
"http",
".",
"StatusBadRequest",
":",
"errDef",
"=",
"&",
"badRequestDef",
"{",
... | // NewAPIError creates a new APIError instance from the given response code and content. | [
"NewAPIError",
"creates",
"a",
"new",
"APIError",
"instance",
"from",
"the",
"given",
"response",
"code",
"and",
"content",
"."
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/error.go#L76-L100 |
17,047 | gambol99/go-marathon | pod_container.go | NewPodContainer | func NewPodContainer() *PodContainer {
return &PodContainer{
Endpoints: []*PodEndpoint{},
Env: map[string]string{},
VolumeMounts: []*PodVolumeMount{},
Artifacts: []*PodArtifact{},
Labels: map[string]string{},
Resources: NewResources(),
}
} | go | func NewPodContainer() *PodContainer {
return &PodContainer{
Endpoints: []*PodEndpoint{},
Env: map[string]string{},
VolumeMounts: []*PodVolumeMount{},
Artifacts: []*PodArtifact{},
Labels: map[string]string{},
Resources: NewResources(),
}
} | [
"func",
"NewPodContainer",
"(",
")",
"*",
"PodContainer",
"{",
"return",
"&",
"PodContainer",
"{",
"Endpoints",
":",
"[",
"]",
"*",
"PodEndpoint",
"{",
"}",
",",
"Env",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"VolumeMounts",
":",
"[",
... | // NewPodContainer creates an empty PodContainer | [
"NewPodContainer",
"creates",
"an",
"empty",
"PodContainer"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L61-L70 |
17,048 | gambol99/go-marathon | pod_container.go | SetName | func (p *PodContainer) SetName(name string) *PodContainer {
p.Name = name
return p
} | go | func (p *PodContainer) SetName(name string) *PodContainer {
p.Name = name
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"SetName",
"(",
"name",
"string",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Name",
"=",
"name",
"\n",
"return",
"p",
"\n",
"}"
] | // SetName sets the name of a pod container | [
"SetName",
"sets",
"the",
"name",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L73-L76 |
17,049 | gambol99/go-marathon | pod_container.go | SetCommand | func (p *PodContainer) SetCommand(name string) *PodContainer {
p.Exec = &PodExec{
Command: PodCommand{
Shell: name,
},
}
return p
} | go | func (p *PodContainer) SetCommand(name string) *PodContainer {
p.Exec = &PodExec{
Command: PodCommand{
Shell: name,
},
}
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"SetCommand",
"(",
"name",
"string",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Exec",
"=",
"&",
"PodExec",
"{",
"Command",
":",
"PodCommand",
"{",
"Shell",
":",
"name",
",",
"}",
",",
"}",
"\n",
"return",
... | // SetCommand sets the shell command of a pod container | [
"SetCommand",
"sets",
"the",
"shell",
"command",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L79-L86 |
17,050 | gambol99/go-marathon | pod_container.go | CPUs | func (p *PodContainer) CPUs(cpu float64) *PodContainer {
p.Resources.Cpus = cpu
return p
} | go | func (p *PodContainer) CPUs(cpu float64) *PodContainer {
p.Resources.Cpus = cpu
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"CPUs",
"(",
"cpu",
"float64",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Resources",
".",
"Cpus",
"=",
"cpu",
"\n",
"return",
"p",
"\n",
"}"
] | // CPUs sets the CPUs of a pod container | [
"CPUs",
"sets",
"the",
"CPUs",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L89-L92 |
17,051 | gambol99/go-marathon | pod_container.go | Memory | func (p *PodContainer) Memory(memory float64) *PodContainer {
p.Resources.Mem = memory
return p
} | go | func (p *PodContainer) Memory(memory float64) *PodContainer {
p.Resources.Mem = memory
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"Memory",
"(",
"memory",
"float64",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Resources",
".",
"Mem",
"=",
"memory",
"\n",
"return",
"p",
"\n",
"}"
] | // Memory sets the memory of a pod container | [
"Memory",
"sets",
"the",
"memory",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L95-L98 |
17,052 | gambol99/go-marathon | pod_container.go | Storage | func (p *PodContainer) Storage(disk float64) *PodContainer {
p.Resources.Disk = disk
return p
} | go | func (p *PodContainer) Storage(disk float64) *PodContainer {
p.Resources.Disk = disk
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"Storage",
"(",
"disk",
"float64",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Resources",
".",
"Disk",
"=",
"disk",
"\n",
"return",
"p",
"\n",
"}"
] | // Storage sets the storage capacity of a pod container | [
"Storage",
"sets",
"the",
"storage",
"capacity",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L101-L104 |
17,053 | gambol99/go-marathon | pod_container.go | GPUs | func (p *PodContainer) GPUs(gpu int32) *PodContainer {
p.Resources.Gpus = gpu
return p
} | go | func (p *PodContainer) GPUs(gpu int32) *PodContainer {
p.Resources.Gpus = gpu
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"GPUs",
"(",
"gpu",
"int32",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Resources",
".",
"Gpus",
"=",
"gpu",
"\n",
"return",
"p",
"\n",
"}"
] | // GPUs sets the GPU requirements of a pod container | [
"GPUs",
"sets",
"the",
"GPU",
"requirements",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L107-L110 |
17,054 | gambol99/go-marathon | pod_container.go | AddEndpoint | func (p *PodContainer) AddEndpoint(endpoint *PodEndpoint) *PodContainer {
p.Endpoints = append(p.Endpoints, endpoint)
return p
} | go | func (p *PodContainer) AddEndpoint(endpoint *PodEndpoint) *PodContainer {
p.Endpoints = append(p.Endpoints, endpoint)
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"AddEndpoint",
"(",
"endpoint",
"*",
"PodEndpoint",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Endpoints",
"=",
"append",
"(",
"p",
".",
"Endpoints",
",",
"endpoint",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // AddEndpoint appends an endpoint for a pod container | [
"AddEndpoint",
"appends",
"an",
"endpoint",
"for",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L113-L116 |
17,055 | gambol99/go-marathon | pod_container.go | SetImage | func (p *PodContainer) SetImage(image *PodContainerImage) *PodContainer {
p.Image = image
return p
} | go | func (p *PodContainer) SetImage(image *PodContainerImage) *PodContainer {
p.Image = image
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"SetImage",
"(",
"image",
"*",
"PodContainerImage",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Image",
"=",
"image",
"\n",
"return",
"p",
"\n",
"}"
] | // SetImage sets the image of a pod container | [
"SetImage",
"sets",
"the",
"image",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L119-L122 |
17,056 | gambol99/go-marathon | pod_container.go | EmptyEnvs | func (p *PodContainer) EmptyEnvs() *PodContainer {
p.Env = make(map[string]string)
return p
} | go | func (p *PodContainer) EmptyEnvs() *PodContainer {
p.Env = make(map[string]string)
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"EmptyEnvs",
"(",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Env",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // EmptyEnvs initialized env to empty | [
"EmptyEnvs",
"initialized",
"env",
"to",
"empty"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L125-L128 |
17,057 | gambol99/go-marathon | pod_container.go | AddEnv | func (p *PodContainer) AddEnv(name, value string) *PodContainer {
if p.Env == nil {
p = p.EmptyEnvs()
}
p.Env[name] = value
return p
} | go | func (p *PodContainer) AddEnv(name, value string) *PodContainer {
if p.Env == nil {
p = p.EmptyEnvs()
}
p.Env[name] = value
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"AddEnv",
"(",
"name",
",",
"value",
"string",
")",
"*",
"PodContainer",
"{",
"if",
"p",
".",
"Env",
"==",
"nil",
"{",
"p",
"=",
"p",
".",
"EmptyEnvs",
"(",
")",
"\n",
"}",
"\n",
"p",
".",
"Env",
"[",... | // AddEnv adds an environment variable for a pod container | [
"AddEnv",
"adds",
"an",
"environment",
"variable",
"for",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L131-L137 |
17,058 | gambol99/go-marathon | pod_container.go | ExtendEnv | func (p *PodContainer) ExtendEnv(env map[string]string) *PodContainer {
if p.Env == nil {
p = p.EmptyEnvs()
}
for k, v := range env {
p.AddEnv(k, v)
}
return p
} | go | func (p *PodContainer) ExtendEnv(env map[string]string) *PodContainer {
if p.Env == nil {
p = p.EmptyEnvs()
}
for k, v := range env {
p.AddEnv(k, v)
}
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"ExtendEnv",
"(",
"env",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"PodContainer",
"{",
"if",
"p",
".",
"Env",
"==",
"nil",
"{",
"p",
"=",
"p",
".",
"EmptyEnvs",
"(",
")",
"\n",
"}",
"\n",
"for",
... | // ExtendEnv extends the environment for a pod container | [
"ExtendEnv",
"extends",
"the",
"environment",
"for",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L140-L148 |
17,059 | gambol99/go-marathon | pod_container.go | AddSecret | func (p *PodContainer) AddSecret(name, secretName string) *PodContainer {
if p.Env == nil {
p = p.EmptyEnvs()
}
p.Env[name] = secretName
return p
} | go | func (p *PodContainer) AddSecret(name, secretName string) *PodContainer {
if p.Env == nil {
p = p.EmptyEnvs()
}
p.Env[name] = secretName
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"AddSecret",
"(",
"name",
",",
"secretName",
"string",
")",
"*",
"PodContainer",
"{",
"if",
"p",
".",
"Env",
"==",
"nil",
"{",
"p",
"=",
"p",
".",
"EmptyEnvs",
"(",
")",
"\n",
"}",
"\n",
"p",
".",
"Env"... | // AddSecret adds a secret to the environment for a pod container | [
"AddSecret",
"adds",
"a",
"secret",
"to",
"the",
"environment",
"for",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L151-L157 |
17,060 | gambol99/go-marathon | pod_container.go | SetHealthCheck | func (p *PodContainer) SetHealthCheck(healthcheck *PodHealthCheck) *PodContainer {
p.HealthCheck = healthcheck
return p
} | go | func (p *PodContainer) SetHealthCheck(healthcheck *PodHealthCheck) *PodContainer {
p.HealthCheck = healthcheck
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"SetHealthCheck",
"(",
"healthcheck",
"*",
"PodHealthCheck",
")",
"*",
"PodContainer",
"{",
"p",
".",
"HealthCheck",
"=",
"healthcheck",
"\n",
"return",
"p",
"\n",
"}"
] | // SetHealthCheck sets the health check of a pod container | [
"SetHealthCheck",
"sets",
"the",
"health",
"check",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L166-L169 |
17,061 | gambol99/go-marathon | pod_container.go | AddVolumeMount | func (p *PodContainer) AddVolumeMount(mount *PodVolumeMount) *PodContainer {
p.VolumeMounts = append(p.VolumeMounts, mount)
return p
} | go | func (p *PodContainer) AddVolumeMount(mount *PodVolumeMount) *PodContainer {
p.VolumeMounts = append(p.VolumeMounts, mount)
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"AddVolumeMount",
"(",
"mount",
"*",
"PodVolumeMount",
")",
"*",
"PodContainer",
"{",
"p",
".",
"VolumeMounts",
"=",
"append",
"(",
"p",
".",
"VolumeMounts",
",",
"mount",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // AddVolumeMount appends a volume mount to a pod container | [
"AddVolumeMount",
"appends",
"a",
"volume",
"mount",
"to",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L172-L175 |
17,062 | gambol99/go-marathon | pod_container.go | AddArtifact | func (p *PodContainer) AddArtifact(artifact *PodArtifact) *PodContainer {
p.Artifacts = append(p.Artifacts, artifact)
return p
} | go | func (p *PodContainer) AddArtifact(artifact *PodArtifact) *PodContainer {
p.Artifacts = append(p.Artifacts, artifact)
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"AddArtifact",
"(",
"artifact",
"*",
"PodArtifact",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Artifacts",
"=",
"append",
"(",
"p",
".",
"Artifacts",
",",
"artifact",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // AddArtifact appends an artifact to a pod container | [
"AddArtifact",
"appends",
"an",
"artifact",
"to",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L178-L181 |
17,063 | gambol99/go-marathon | pod_container.go | AddLabel | func (p *PodContainer) AddLabel(key, value string) *PodContainer {
p.Labels[key] = value
return p
} | go | func (p *PodContainer) AddLabel(key, value string) *PodContainer {
p.Labels[key] = value
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"AddLabel",
"(",
"key",
",",
"value",
"string",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Labels",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"p",
"\n",
"}"
] | // AddLabel adds a label to a pod container | [
"AddLabel",
"adds",
"a",
"label",
"to",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L184-L187 |
17,064 | gambol99/go-marathon | pod_container.go | SetLifecycle | func (p *PodContainer) SetLifecycle(lifecycle PodLifecycle) *PodContainer {
p.Lifecycle = lifecycle
return p
} | go | func (p *PodContainer) SetLifecycle(lifecycle PodLifecycle) *PodContainer {
p.Lifecycle = lifecycle
return p
} | [
"func",
"(",
"p",
"*",
"PodContainer",
")",
"SetLifecycle",
"(",
"lifecycle",
"PodLifecycle",
")",
"*",
"PodContainer",
"{",
"p",
".",
"Lifecycle",
"=",
"lifecycle",
"\n",
"return",
"p",
"\n",
"}"
] | // SetLifecycle sets the lifecycle of a pod container | [
"SetLifecycle",
"sets",
"the",
"lifecycle",
"of",
"a",
"pod",
"container"
] | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/pod_container.go#L190-L193 |
17,065 | gambol99/go-marathon | application_marshalling.go | MarshalJSON | func (app *Application) MarshalJSON() ([]byte, error) {
env := make(map[string]interface{})
secrets := make(map[string]TmpSecret)
if app.Env != nil {
for k, v := range *app.Env {
env[string(k)] = string(v)
}
}
if app.Secrets != nil {
for k, v := range *app.Secrets {
env[v.EnvVar] = TmpEnvSecret{Secret: k}
secrets[k] = TmpSecret{v.Source}
}
}
aux := &struct {
*Alias
Env map[string]interface{} `json:"env,omitempty"`
Secrets map[string]TmpSecret `json:"secrets,omitempty"`
}{Alias: (*Alias)(app), Env: env, Secrets: secrets}
return json.Marshal(aux)
} | go | func (app *Application) MarshalJSON() ([]byte, error) {
env := make(map[string]interface{})
secrets := make(map[string]TmpSecret)
if app.Env != nil {
for k, v := range *app.Env {
env[string(k)] = string(v)
}
}
if app.Secrets != nil {
for k, v := range *app.Secrets {
env[v.EnvVar] = TmpEnvSecret{Secret: k}
secrets[k] = TmpSecret{v.Source}
}
}
aux := &struct {
*Alias
Env map[string]interface{} `json:"env,omitempty"`
Secrets map[string]TmpSecret `json:"secrets,omitempty"`
}{Alias: (*Alias)(app), Env: env, Secrets: secrets}
return json.Marshal(aux)
} | [
"func",
"(",
"app",
"*",
"Application",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"env",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"secrets",
":=",
"make",
"(",
"map",
"[",
... | // MarshalJSON marshals the given Application as expected except for environment variables and secrets,
// which are marshaled from specialized structs. The environment variable piece of the secrets and other
// normal environment variables are combined and marshaled to the env field. The secrets and the related
// source are marshaled into the secrets field. | [
"MarshalJSON",
"marshals",
"the",
"given",
"Application",
"as",
"expected",
"except",
"for",
"environment",
"variables",
"and",
"secrets",
"which",
"are",
"marshaled",
"from",
"specialized",
"structs",
".",
"The",
"environment",
"variable",
"piece",
"of",
"the",
"... | 80365667fd5354cd063520a8ca8f53dfad6e6c81 | https://github.com/gambol99/go-marathon/blob/80365667fd5354cd063520a8ca8f53dfad6e6c81/application_marshalling.go#L84-L106 |
17,066 | intel-go/fastjson | scanner.go | pushRecord | func (s *scanner) pushRecord(state, pos int) {
s.stateRecord = append(s.stateRecord, Record{state:state, pos:pos}) //state are at even positions, pos are at odd positions in stateRecord array
} | go | func (s *scanner) pushRecord(state, pos int) {
s.stateRecord = append(s.stateRecord, Record{state:state, pos:pos}) //state are at even positions, pos are at odd positions in stateRecord array
} | [
"func",
"(",
"s",
"*",
"scanner",
")",
"pushRecord",
"(",
"state",
",",
"pos",
"int",
")",
"{",
"s",
".",
"stateRecord",
"=",
"append",
"(",
"s",
".",
"stateRecord",
",",
"Record",
"{",
"state",
":",
"state",
",",
"pos",
":",
"pos",
"}",
")",
"//... | //pushes Record into array | [
"pushes",
"Record",
"into",
"array"
] | f846ae58a1ab4a99d9480ce565601aebd84e333a | https://github.com/intel-go/fastjson/blob/f846ae58a1ab4a99d9480ce565601aebd84e333a/scanner.go#L220-L222 |
17,067 | intel-go/fastjson | scanner.go | peekPos | func (s *scanner) peekPos() int {
if s.readPos >= len(s.stateRecord){
return s.cacheRecord.pos// peek can be called when the array is over , only if unmarshal error occured, so return last read position
}
if !s.cached {
s.cached = true
s.cacheRecord = s.stateRecord[s.readPos]
}
return s.cacheRecord.pos
} | go | func (s *scanner) peekPos() int {
if s.readPos >= len(s.stateRecord){
return s.cacheRecord.pos// peek can be called when the array is over , only if unmarshal error occured, so return last read position
}
if !s.cached {
s.cached = true
s.cacheRecord = s.stateRecord[s.readPos]
}
return s.cacheRecord.pos
} | [
"func",
"(",
"s",
"*",
"scanner",
")",
"peekPos",
"(",
")",
"int",
"{",
"if",
"s",
".",
"readPos",
">=",
"len",
"(",
"s",
".",
"stateRecord",
")",
"{",
"return",
"s",
".",
"cacheRecord",
".",
"pos",
"// peek can be called when the array is over , only if unm... | //peeks current state for filling object. Doesn't change position. Returns state, pos | [
"peeks",
"current",
"state",
"for",
"filling",
"object",
".",
"Doesn",
"t",
"change",
"position",
".",
"Returns",
"state",
"pos"
] | f846ae58a1ab4a99d9480ce565601aebd84e333a | https://github.com/intel-go/fastjson/blob/f846ae58a1ab4a99d9480ce565601aebd84e333a/scanner.go#L225-L234 |
17,068 | intel-go/fastjson | scanner.go | takeState | func (s *scanner) takeState() int {
if s.cached {
s.cached = false
}else{
s.peekState()
}
s.readPos += 1
return s.cacheRecord.state
} | go | func (s *scanner) takeState() int {
if s.cached {
s.cached = false
}else{
s.peekState()
}
s.readPos += 1
return s.cacheRecord.state
} | [
"func",
"(",
"s",
"*",
"scanner",
")",
"takeState",
"(",
")",
"int",
"{",
"if",
"s",
".",
"cached",
"{",
"s",
".",
"cached",
"=",
"false",
"\n",
"}",
"else",
"{",
"s",
".",
"peekState",
"(",
")",
"\n",
"}",
"\n",
"s",
".",
"readPos",
"+=",
"1... | //takes current state and increments reading position. | [
"takes",
"current",
"state",
"and",
"increments",
"reading",
"position",
"."
] | f846ae58a1ab4a99d9480ce565601aebd84e333a | https://github.com/intel-go/fastjson/blob/f846ae58a1ab4a99d9480ce565601aebd84e333a/scanner.go#L248-L256 |
17,069 | intel-go/fastjson | scanner.go | isNeededState | func (s *scanner) isNeededState(state int) bool {
if s.endLiteral {
return true
}
if state > scanEndArray || state < scanBeginLiteral {
return false
}
return true
} | go | func (s *scanner) isNeededState(state int) bool {
if s.endLiteral {
return true
}
if state > scanEndArray || state < scanBeginLiteral {
return false
}
return true
} | [
"func",
"(",
"s",
"*",
"scanner",
")",
"isNeededState",
"(",
"state",
"int",
")",
"bool",
"{",
"if",
"s",
".",
"endLiteral",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"state",
">",
"scanEndArray",
"||",
"state",
"<",
"scanBeginLiteral",
"{",
"retur... | //checks if we need this state to be recorded | [
"checks",
"if",
"we",
"need",
"this",
"state",
"to",
"be",
"recorded"
] | f846ae58a1ab4a99d9480ce565601aebd84e333a | https://github.com/intel-go/fastjson/blob/f846ae58a1ab4a99d9480ce565601aebd84e333a/scanner.go#L274-L282 |
17,070 | intel-go/fastjson | scanner.go | stateTru | func stateTru(s *scanner, c byte) int {
if c == 'e' {
s.step = stateEndValue
s.endLiteral = true
return scanContinue
}
return s.error(c, "in literal true (expecting 'e')")
} | go | func stateTru(s *scanner, c byte) int {
if c == 'e' {
s.step = stateEndValue
s.endLiteral = true
return scanContinue
}
return s.error(c, "in literal true (expecting 'e')")
} | [
"func",
"stateTru",
"(",
"s",
"*",
"scanner",
",",
"c",
"byte",
")",
"int",
"{",
"if",
"c",
"==",
"'e'",
"{",
"s",
".",
"step",
"=",
"stateEndValue",
"\n",
"s",
".",
"endLiteral",
"=",
"true",
"\n",
"return",
"scanContinue",
"\n",
"}",
"\n",
"retur... | // stateTru is the state after reading `tru`. | [
"stateTru",
"is",
"the",
"state",
"after",
"reading",
"tru",
"."
] | f846ae58a1ab4a99d9480ce565601aebd84e333a | https://github.com/intel-go/fastjson/blob/f846ae58a1ab4a99d9480ce565601aebd84e333a/scanner.go#L629-L636 |
17,071 | intel-go/fastjson | decode.go | next | func (d *decodeState) next() []byte {
startop, start := d.peekRecord()
var endop int
switch startop {
case scanBeginArray:
endop = scanEndArray
case scanBeginObject:
endop = scanEndObject
case scanBeginLiteral:
endop = scanEndLiteral
default:
panic(errPhase)
}
count := 1 //counts number of open and not closed brackets.
d.skipRecord()
end := 0 //end of value
op := startop
for count != 0 { //we need here cycle because of nested objects and slices
op, end = d.takeRecord()
if op == startop {
count++
}
if op == endop {
count--
}
}
return d.data[start : end+1]
} | go | func (d *decodeState) next() []byte {
startop, start := d.peekRecord()
var endop int
switch startop {
case scanBeginArray:
endop = scanEndArray
case scanBeginObject:
endop = scanEndObject
case scanBeginLiteral:
endop = scanEndLiteral
default:
panic(errPhase)
}
count := 1 //counts number of open and not closed brackets.
d.skipRecord()
end := 0 //end of value
op := startop
for count != 0 { //we need here cycle because of nested objects and slices
op, end = d.takeRecord()
if op == startop {
count++
}
if op == endop {
count--
}
}
return d.data[start : end+1]
} | [
"func",
"(",
"d",
"*",
"decodeState",
")",
"next",
"(",
")",
"[",
"]",
"byte",
"{",
"startop",
",",
"start",
":=",
"d",
".",
"peekRecord",
"(",
")",
"\n\n",
"var",
"endop",
"int",
"\n\n",
"switch",
"startop",
"{",
"case",
"scanBeginArray",
":",
"endo... | // next cuts off and returns the next full JSON value
// The next value is known to be an object or array or a literal | [
"next",
"cuts",
"off",
"and",
"returns",
"the",
"next",
"full",
"JSON",
"value",
"The",
"next",
"value",
"is",
"known",
"to",
"be",
"an",
"object",
"or",
"array",
"or",
"a",
"literal"
] | f846ae58a1ab4a99d9480ce565601aebd84e333a | https://github.com/intel-go/fastjson/blob/f846ae58a1ab4a99d9480ce565601aebd84e333a/decode.go#L283-L316 |
17,072 | intel-go/fastjson | decode.go | takeRecord | func (d *decodeState) takeRecord() (int, int) {
return d.scan.peekState(), d.scan.takePos()
} | go | func (d *decodeState) takeRecord() (int, int) {
return d.scan.peekState(), d.scan.takePos()
} | [
"func",
"(",
"d",
"*",
"decodeState",
")",
"takeRecord",
"(",
")",
"(",
"int",
",",
"int",
")",
"{",
"return",
"d",
".",
"scan",
".",
"peekState",
"(",
")",
",",
"d",
".",
"scan",
".",
"takePos",
"(",
")",
"\n",
"}"
] | //wrappers scanner funcs | [
"wrappers",
"scanner",
"funcs"
] | f846ae58a1ab4a99d9480ce565601aebd84e333a | https://github.com/intel-go/fastjson/blob/f846ae58a1ab4a99d9480ce565601aebd84e333a/decode.go#L319-L321 |
17,073 | mailgun/holster | misc.go | GetEnv | func GetEnv(envName, defaultValue string) string {
value := os.Getenv(envName)
if value == "" {
return defaultValue
}
return value
} | go | func GetEnv(envName, defaultValue string) string {
value := os.Getenv(envName)
if value == "" {
return defaultValue
}
return value
} | [
"func",
"GetEnv",
"(",
"envName",
",",
"defaultValue",
"string",
")",
"string",
"{",
"value",
":=",
"os",
".",
"Getenv",
"(",
"envName",
")",
"\n",
"if",
"value",
"==",
"\"",
"\"",
"{",
"return",
"defaultValue",
"\n",
"}",
"\n",
"return",
"value",
"\n"... | // Get the environment variable or return the default value if unset | [
"Get",
"the",
"environment",
"variable",
"or",
"return",
"the",
"default",
"value",
"if",
"unset"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/misc.go#L67-L73 |
17,074 | mailgun/holster | expire_cache.go | NewExpireCache | func NewExpireCache(ttl time.Duration) *ExpireCache {
return &ExpireCache{
cache: make(map[interface{}]*expireRecord),
ttl: ttl,
}
} | go | func NewExpireCache(ttl time.Duration) *ExpireCache {
return &ExpireCache{
cache: make(map[interface{}]*expireRecord),
ttl: ttl,
}
} | [
"func",
"NewExpireCache",
"(",
"ttl",
"time",
".",
"Duration",
")",
"*",
"ExpireCache",
"{",
"return",
"&",
"ExpireCache",
"{",
"cache",
":",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"*",
"expireRecord",
")",
",",
"ttl",
":",
"ttl",
",",
... | // New creates a new ExpireCache. | [
"New",
"creates",
"a",
"new",
"ExpireCache",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L65-L70 |
17,075 | mailgun/holster | expire_cache.go | Get | func (c *ExpireCache) Get(key interface{}) (interface{}, bool) {
c.mutex.Lock()
defer c.mutex.Unlock()
record, ok := c.cache[key]
if !ok {
c.stats.Miss++
return nil, ok
}
// Since this was recently accessed, keep it in
// the cache by resetting the expire time
record.ExpireAt = time.Now().UTC().Add(c.ttl)
c.stats.Hit++
return record.Value, ok
} | go | func (c *ExpireCache) Get(key interface{}) (interface{}, bool) {
c.mutex.Lock()
defer c.mutex.Unlock()
record, ok := c.cache[key]
if !ok {
c.stats.Miss++
return nil, ok
}
// Since this was recently accessed, keep it in
// the cache by resetting the expire time
record.ExpireAt = time.Now().UTC().Add(c.ttl)
c.stats.Hit++
return record.Value, ok
} | [
"func",
"(",
"c",
"*",
"ExpireCache",
")",
"Get",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
... | // Retrieves a key's value from the cache | [
"Retrieves",
"a",
"key",
"s",
"value",
"from",
"the",
"cache"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L73-L89 |
17,076 | mailgun/holster | expire_cache.go | Add | func (c *ExpireCache) Add(key interface{}, value interface{}) {
c.mutex.Lock()
defer c.mutex.Unlock()
record := expireRecord{
Value: value,
ExpireAt: time.Now().UTC().Add(c.ttl),
}
// Add the record to the cache
c.cache[key] = &record
} | go | func (c *ExpireCache) Add(key interface{}, value interface{}) {
c.mutex.Lock()
defer c.mutex.Unlock()
record := expireRecord{
Value: value,
ExpireAt: time.Now().UTC().Add(c.ttl),
}
// Add the record to the cache
c.cache[key] = &record
} | [
"func",
"(",
"c",
"*",
"ExpireCache",
")",
"Add",
"(",
"key",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"re... | // Put the key, value and TTL in the cache | [
"Put",
"the",
"key",
"value",
"and",
"TTL",
"in",
"the",
"cache"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L92-L102 |
17,077 | mailgun/holster | expire_cache.go | Update | func (c *ExpireCache) Update(key interface{}, value interface{}) error {
c.mutex.Lock()
defer c.mutex.Unlock()
record, ok := c.cache[key]
if !ok {
return errors.Errorf("ExpoireCache() - No record found for '%+v'", key)
}
record.Value = value
return nil
} | go | func (c *ExpireCache) Update(key interface{}, value interface{}) error {
c.mutex.Lock()
defer c.mutex.Unlock()
record, ok := c.cache[key]
if !ok {
return errors.Errorf("ExpoireCache() - No record found for '%+v'", key)
}
record.Value = value
return nil
} | [
"func",
"(",
"c",
"*",
"ExpireCache",
")",
"Update",
"(",
"key",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
... | // Update the value in the cache without updating the TTL | [
"Update",
"the",
"value",
"in",
"the",
"cache",
"without",
"updating",
"the",
"TTL"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L105-L115 |
17,078 | mailgun/holster | expire_cache.go | Peek | func (c *ExpireCache) Peek(key interface{}) (value interface{}, ok bool) {
defer c.mutex.Unlock()
c.mutex.Lock()
if record, hit := c.cache[key]; hit {
return record.Value, true
}
return nil, false
} | go | func (c *ExpireCache) Peek(key interface{}) (value interface{}, ok bool) {
defer c.mutex.Unlock()
c.mutex.Lock()
if record, hit := c.cache[key]; hit {
return record.Value, true
}
return nil, false
} | [
"func",
"(",
"c",
"*",
"ExpireCache",
")",
"Peek",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"value",
"interface",
"{",
"}",
",",
"ok",
"bool",
")",
"{",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"mutex",
".",
"Loc... | // Get the value without updating the expiration | [
"Get",
"the",
"value",
"without",
"updating",
"the",
"expiration"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L129-L137 |
17,079 | mailgun/holster | expire_cache.go | Each | func (c *ExpireCache) Each(concurrent int, callBack func(key interface{}, value interface{}) error) []error {
fanOut := NewFanOut(concurrent)
keys := c.Keys()
for _, key := range keys {
fanOut.Run(func(key interface{}) error {
c.mutex.Lock()
record, ok := c.cache[key]
c.mutex.Unlock()
if !ok {
return errors.Errorf("Each() - key '%+v' disapeared "+
"from cache during iteration", key)
}
err := callBack(key, record.Value)
if err != nil {
return err
}
c.mutex.Lock()
if record.ExpireAt.Before(time.Now().UTC()) {
delete(c.cache, key)
}
c.mutex.Unlock()
return nil
}, key)
}
// Wait for all the routines to complete
errs := fanOut.Wait()
if errs != nil {
return errs
}
return nil
} | go | func (c *ExpireCache) Each(concurrent int, callBack func(key interface{}, value interface{}) error) []error {
fanOut := NewFanOut(concurrent)
keys := c.Keys()
for _, key := range keys {
fanOut.Run(func(key interface{}) error {
c.mutex.Lock()
record, ok := c.cache[key]
c.mutex.Unlock()
if !ok {
return errors.Errorf("Each() - key '%+v' disapeared "+
"from cache during iteration", key)
}
err := callBack(key, record.Value)
if err != nil {
return err
}
c.mutex.Lock()
if record.ExpireAt.Before(time.Now().UTC()) {
delete(c.cache, key)
}
c.mutex.Unlock()
return nil
}, key)
}
// Wait for all the routines to complete
errs := fanOut.Wait()
if errs != nil {
return errs
}
return nil
} | [
"func",
"(",
"c",
"*",
"ExpireCache",
")",
"Each",
"(",
"concurrent",
"int",
",",
"callBack",
"func",
"(",
"key",
"interface",
"{",
"}",
",",
"value",
"interface",
"{",
"}",
")",
"error",
")",
"[",
"]",
"error",
"{",
"fanOut",
":=",
"NewFanOut",
"(",... | // Processes each item in the cache in a thread safe way, such that the cache can be in use
// while processing items in the cache | [
"Processes",
"each",
"item",
"in",
"the",
"cache",
"in",
"a",
"thread",
"safe",
"way",
"such",
"that",
"the",
"cache",
"can",
"be",
"in",
"use",
"while",
"processing",
"items",
"in",
"the",
"cache"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L141-L176 |
17,080 | mailgun/holster | expire_cache.go | GetStats | func (c *ExpireCache) GetStats() ExpireCacheStats {
c.mutex.Lock()
c.stats.Size = int64(len(c.cache))
defer func() {
c.stats = ExpireCacheStats{}
c.mutex.Unlock()
}()
return c.stats
} | go | func (c *ExpireCache) GetStats() ExpireCacheStats {
c.mutex.Lock()
c.stats.Size = int64(len(c.cache))
defer func() {
c.stats = ExpireCacheStats{}
c.mutex.Unlock()
}()
return c.stats
} | [
"func",
"(",
"c",
"*",
"ExpireCache",
")",
"GetStats",
"(",
")",
"ExpireCacheStats",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"stats",
".",
"Size",
"=",
"int64",
"(",
"len",
"(",
"c",
".",
"cache",
")",
")",
"\n",
"defer",
... | // Retrieve stats about the cache | [
"Retrieve",
"stats",
"about",
"the",
"cache"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L179-L187 |
17,081 | mailgun/holster | expire_cache.go | Size | func (c *ExpireCache) Size() int64 {
defer c.mutex.Unlock()
c.mutex.Lock()
return int64(len(c.cache))
} | go | func (c *ExpireCache) Size() int64 {
defer c.mutex.Unlock()
c.mutex.Lock()
return int64(len(c.cache))
} | [
"func",
"(",
"c",
"*",
"ExpireCache",
")",
"Size",
"(",
")",
"int64",
"{",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"return",
"int64",
"(",
"len",
"(",
"c",
".",
"cache",
")",
... | // Returns the number of items in the cache. | [
"Returns",
"the",
"number",
"of",
"items",
"in",
"the",
"cache",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/expire_cache.go#L190-L194 |
17,082 | mailgun/holster | fanout.go | Run | func (p *FanOut) Run(callBack func(interface{}) error, data interface{}) {
p.size <- true
go func() {
err := callBack(data)
if err != nil {
p.errChan <- err
}
<-p.size
}()
} | go | func (p *FanOut) Run(callBack func(interface{}) error, data interface{}) {
p.size <- true
go func() {
err := callBack(data)
if err != nil {
p.errChan <- err
}
<-p.size
}()
} | [
"func",
"(",
"p",
"*",
"FanOut",
")",
"Run",
"(",
"callBack",
"func",
"(",
"interface",
"{",
"}",
")",
"error",
",",
"data",
"interface",
"{",
"}",
")",
"{",
"p",
".",
"size",
"<-",
"true",
"\n",
"go",
"func",
"(",
")",
"{",
"err",
":=",
"callB... | // Run a new routine with an optional data value | [
"Run",
"a",
"new",
"routine",
"with",
"an",
"optional",
"data",
"value"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/fanout.go#L63-L72 |
17,083 | mailgun/holster | fanout.go | Wait | func (p *FanOut) Wait() []error {
// Wait for all the routines to complete
for i := 0; i < cap(p.size); i++ {
p.size <- true
}
// Close the err channel
if p.errChan != nil {
close(p.errChan)
}
// Wait until the error collector routine is complete
p.wg.Wait()
// If there are no errors
if len(p.errs) == 0 {
return nil
}
return p.errs
} | go | func (p *FanOut) Wait() []error {
// Wait for all the routines to complete
for i := 0; i < cap(p.size); i++ {
p.size <- true
}
// Close the err channel
if p.errChan != nil {
close(p.errChan)
}
// Wait until the error collector routine is complete
p.wg.Wait()
// If there are no errors
if len(p.errs) == 0 {
return nil
}
return p.errs
} | [
"func",
"(",
"p",
"*",
"FanOut",
")",
"Wait",
"(",
")",
"[",
"]",
"error",
"{",
"// Wait for all the routines to complete",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"cap",
"(",
"p",
".",
"size",
")",
";",
"i",
"++",
"{",
"p",
".",
"size",
"<-",
"tru... | // Wait for all the routines to complete and return any errors | [
"Wait",
"for",
"all",
"the",
"routines",
"to",
"complete",
"and",
"return",
"any",
"errors"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/fanout.go#L75-L93 |
17,084 | mailgun/holster | random.go | RandomRunes | func RandomRunes(prefix string, length int, runes ...string) string {
chars := strings.Join(runes, "")
var bytes = make([]byte, length)
rand.Read(bytes)
for i, b := range bytes {
bytes[i] = chars[b%byte(len(chars))]
}
return prefix + string(bytes)
} | go | func RandomRunes(prefix string, length int, runes ...string) string {
chars := strings.Join(runes, "")
var bytes = make([]byte, length)
rand.Read(bytes)
for i, b := range bytes {
bytes[i] = chars[b%byte(len(chars))]
}
return prefix + string(bytes)
} | [
"func",
"RandomRunes",
"(",
"prefix",
"string",
",",
"length",
"int",
",",
"runes",
"...",
"string",
")",
"string",
"{",
"chars",
":=",
"strings",
".",
"Join",
"(",
"runes",
",",
"\"",
"\"",
")",
"\n",
"var",
"bytes",
"=",
"make",
"(",
"[",
"]",
"b... | // Return a random string made up of characters passed | [
"Return",
"a",
"random",
"string",
"made",
"up",
"of",
"characters",
"passed"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/random.go#L28-L36 |
17,085 | mailgun/holster | random.go | RandomAlpha | func RandomAlpha(prefix string, length int) string {
return RandomRunes(prefix, length, AlphaRunes)
} | go | func RandomAlpha(prefix string, length int) string {
return RandomRunes(prefix, length, AlphaRunes)
} | [
"func",
"RandomAlpha",
"(",
"prefix",
"string",
",",
"length",
"int",
")",
"string",
"{",
"return",
"RandomRunes",
"(",
"prefix",
",",
"length",
",",
"AlphaRunes",
")",
"\n",
"}"
] | // Return a random string of alpha characters | [
"Return",
"a",
"random",
"string",
"of",
"alpha",
"characters"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/random.go#L39-L41 |
17,086 | mailgun/holster | random.go | RandomString | func RandomString(prefix string, length int) string {
return RandomRunes(prefix, length, AlphaRunes, NumericRunes)
} | go | func RandomString(prefix string, length int) string {
return RandomRunes(prefix, length, AlphaRunes, NumericRunes)
} | [
"func",
"RandomString",
"(",
"prefix",
"string",
",",
"length",
"int",
")",
"string",
"{",
"return",
"RandomRunes",
"(",
"prefix",
",",
"length",
",",
"AlphaRunes",
",",
"NumericRunes",
")",
"\n",
"}"
] | // Return a random string of alpha and numeric characters | [
"Return",
"a",
"random",
"string",
"of",
"alpha",
"and",
"numeric",
"characters"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/random.go#L44-L46 |
17,087 | mailgun/holster | random.go | RandomItem | func RandomItem(items ...string) string {
var bytes = make([]byte, 1)
rand.Read(bytes)
return items[bytes[0]%byte(len(items))]
} | go | func RandomItem(items ...string) string {
var bytes = make([]byte, 1)
rand.Read(bytes)
return items[bytes[0]%byte(len(items))]
} | [
"func",
"RandomItem",
"(",
"items",
"...",
"string",
")",
"string",
"{",
"var",
"bytes",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"rand",
".",
"Read",
"(",
"bytes",
")",
"\n",
"return",
"items",
"[",
"bytes",
"[",
"0",
"]",
"%",
... | // Given a list of strings, return one of the strings randomly | [
"Given",
"a",
"list",
"of",
"strings",
"return",
"one",
"of",
"the",
"strings",
"randomly"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/random.go#L49-L53 |
17,088 | mailgun/holster | clock/clock.go | Advance | func Advance(d time.Duration) time.Duration {
ft, ok := provider.(*frozenTime)
if !ok {
panic("Freeze time first!")
}
ft.advance(d)
return Now().UTC().Sub(frozenAt)
} | go | func Advance(d time.Duration) time.Duration {
ft, ok := provider.(*frozenTime)
if !ok {
panic("Freeze time first!")
}
ft.advance(d)
return Now().UTC().Sub(frozenAt)
} | [
"func",
"Advance",
"(",
"d",
"time",
".",
"Duration",
")",
"time",
".",
"Duration",
"{",
"ft",
",",
"ok",
":=",
"provider",
".",
"(",
"*",
"frozenTime",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"ft",
".",... | // Makes the deterministic time move forward by the specified duration, firing
// timers along the way in the natural order. It returns how much time has
// passed since it was frozen. So you can assert on the return value in tests
// to make it explicit where you stand on the deterministic time scale. | [
"Makes",
"the",
"deterministic",
"time",
"move",
"forward",
"by",
"the",
"specified",
"duration",
"firing",
"timers",
"along",
"the",
"way",
"in",
"the",
"natural",
"order",
".",
"It",
"returns",
"how",
"much",
"time",
"has",
"passed",
"since",
"it",
"was",
... | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/clock/clock.go#L54-L61 |
17,089 | mailgun/holster | clock/clock.go | Wait4Scheduled | func Wait4Scheduled(count int, timeout time.Duration) bool {
return provider.Wait4Scheduled(count, timeout)
} | go | func Wait4Scheduled(count int, timeout time.Duration) bool {
return provider.Wait4Scheduled(count, timeout)
} | [
"func",
"Wait4Scheduled",
"(",
"count",
"int",
",",
"timeout",
"time",
".",
"Duration",
")",
"bool",
"{",
"return",
"provider",
".",
"Wait4Scheduled",
"(",
"count",
",",
"timeout",
")",
"\n",
"}"
] | // Wait4Scheduled blocks until either there are n or more scheduled events, or
// the timeout elapses. It returns true if the wait condition has been met
// before the timeout expired, false otherwise. | [
"Wait4Scheduled",
"blocks",
"until",
"either",
"there",
"are",
"n",
"or",
"more",
"scheduled",
"events",
"or",
"the",
"timeout",
"elapses",
".",
"It",
"returns",
"true",
"if",
"the",
"wait",
"condition",
"has",
"been",
"met",
"before",
"the",
"timeout",
"exp... | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/clock/clock.go#L66-L68 |
17,090 | mailgun/holster | clock/clock.go | AfterFunc | func AfterFunc(d time.Duration, f func()) Timer {
return provider.AfterFunc(d, f)
} | go | func AfterFunc(d time.Duration, f func()) Timer {
return provider.AfterFunc(d, f)
} | [
"func",
"AfterFunc",
"(",
"d",
"time",
".",
"Duration",
",",
"f",
"func",
"(",
")",
")",
"Timer",
"{",
"return",
"provider",
".",
"AfterFunc",
"(",
"d",
",",
"f",
")",
"\n",
"}"
] | // AfterFunc see time.AfterFunc. | [
"AfterFunc",
"see",
"time",
".",
"AfterFunc",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/clock/clock.go#L98-L100 |
17,091 | mailgun/holster | httpsign/auth.go | SignRequest | func (s *Service) SignRequest(r *http.Request) error {
if s.secretKey == nil {
return fmt.Errorf("service not loaded with key.")
}
return s.SignRequestWithKey(r, s.secretKey)
} | go | func (s *Service) SignRequest(r *http.Request) error {
if s.secretKey == nil {
return fmt.Errorf("service not loaded with key.")
}
return s.SignRequestWithKey(r, s.secretKey)
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"SignRequest",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"if",
"s",
".",
"secretKey",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"s",
... | // Signs a given HTTP request with signature, nonce, and timestamp. | [
"Signs",
"a",
"given",
"HTTP",
"request",
"with",
"signature",
"nonce",
"and",
"timestamp",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/httpsign/auth.go#L216-L221 |
17,092 | mailgun/holster | httpsign/auth.go | AuthenticateRequest | func (s *Service) AuthenticateRequest(r *http.Request) error {
if s.secretKey == nil {
return fmt.Errorf("service not loaded with key.")
}
return s.AuthenticateRequestWithKey(r, s.secretKey)
} | go | func (s *Service) AuthenticateRequest(r *http.Request) error {
if s.secretKey == nil {
return fmt.Errorf("service not loaded with key.")
}
return s.AuthenticateRequestWithKey(r, s.secretKey)
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"AuthenticateRequest",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"if",
"s",
".",
"secretKey",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
... | // Authenticates HTTP request to ensure it was sent by an authorized sender. | [
"Authenticates",
"HTTP",
"request",
"to",
"ensure",
"it",
"was",
"sent",
"by",
"an",
"authorized",
"sender",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/httpsign/auth.go#L265-L270 |
17,093 | mailgun/holster | httpsign/auth.go | AuthenticateRequestWithKey | func (s *Service) AuthenticateRequestWithKey(r *http.Request, secretKey []byte) (err error) {
// Emit a success or failure metric on return.
defer func() {
if err == nil {
s.metricsClient.Inc("success", 1, 1)
} else {
s.metricsClient.Inc("failure", 1, 1)
}
}()
// extract parameters
signature := r.Header.Get(s.config.SignatureHeaderName)
if signature == "" {
return fmt.Errorf("header not found: %v", s.config.SignatureHeaderName)
}
nonce := r.Header.Get(s.config.NonceHeaderName)
if nonce == "" {
return fmt.Errorf("header not found: %v", s.config.NonceHeaderName)
}
timestamp := r.Header.Get(s.config.TimestampHeaderName)
if timestamp == "" {
return fmt.Errorf("header not found: %v", s.config.TimestampHeaderName)
}
// extract request body bytes
bodyBytes, err := readBody(r)
if err != nil {
return err
}
// extract any headers if requested
headerValues, err := extractHeaderValues(r, s.config.HeadersToSign)
if err != nil {
return err
}
// check the hmac
isValid, err := checkMAC(secretKey, s.config.SignVerbAndURI, r.Method, r.URL.RequestURI(),
timestamp, nonce, bodyBytes, headerValues, signature)
if !isValid {
return err
}
// check timestamp
isValid, err = s.CheckTimestamp(timestamp)
if !isValid {
return err
}
// check to see if we have seen nonce before
inCache := s.nonceCache.InCache(nonce)
if inCache {
return fmt.Errorf("nonce already in cache: %v", nonce)
}
// set the body bytes we read in to nil to hint to the gc to pick it up
bodyBytes = nil
return nil
} | go | func (s *Service) AuthenticateRequestWithKey(r *http.Request, secretKey []byte) (err error) {
// Emit a success or failure metric on return.
defer func() {
if err == nil {
s.metricsClient.Inc("success", 1, 1)
} else {
s.metricsClient.Inc("failure", 1, 1)
}
}()
// extract parameters
signature := r.Header.Get(s.config.SignatureHeaderName)
if signature == "" {
return fmt.Errorf("header not found: %v", s.config.SignatureHeaderName)
}
nonce := r.Header.Get(s.config.NonceHeaderName)
if nonce == "" {
return fmt.Errorf("header not found: %v", s.config.NonceHeaderName)
}
timestamp := r.Header.Get(s.config.TimestampHeaderName)
if timestamp == "" {
return fmt.Errorf("header not found: %v", s.config.TimestampHeaderName)
}
// extract request body bytes
bodyBytes, err := readBody(r)
if err != nil {
return err
}
// extract any headers if requested
headerValues, err := extractHeaderValues(r, s.config.HeadersToSign)
if err != nil {
return err
}
// check the hmac
isValid, err := checkMAC(secretKey, s.config.SignVerbAndURI, r.Method, r.URL.RequestURI(),
timestamp, nonce, bodyBytes, headerValues, signature)
if !isValid {
return err
}
// check timestamp
isValid, err = s.CheckTimestamp(timestamp)
if !isValid {
return err
}
// check to see if we have seen nonce before
inCache := s.nonceCache.InCache(nonce)
if inCache {
return fmt.Errorf("nonce already in cache: %v", nonce)
}
// set the body bytes we read in to nil to hint to the gc to pick it up
bodyBytes = nil
return nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"AuthenticateRequestWithKey",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"secretKey",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"// Emit a success or failure metric on return.",
"defer",
"func",
"(",
")",
"... | // Authenticates HTTP request to ensure it was sent by an authorized sender.
// Checks message signature with the passed in key, not the one initialized with. | [
"Authenticates",
"HTTP",
"request",
"to",
"ensure",
"it",
"was",
"sent",
"by",
"an",
"authorized",
"sender",
".",
"Checks",
"message",
"signature",
"with",
"the",
"passed",
"in",
"key",
"not",
"the",
"one",
"initialized",
"with",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/httpsign/auth.go#L274-L333 |
17,094 | mailgun/holster | httpsign/auth.go | CheckTimestamp | func (s *Service) CheckTimestamp(timestampHeader string) (bool, error) {
// convert unix timestamp string into time struct
timestamp, err := strconv.ParseInt(timestampHeader, 10, 0)
if err != nil {
return false, fmt.Errorf("unable to parse %v: %v", s.config.TimestampHeaderName, timestampHeader)
}
now := s.clock.Now().UTC().Unix()
// if timestamp is from the future, it's invalid
if timestamp >= now+MaxSkewSec {
return false, fmt.Errorf("timestamp header from the future; now: %v; %v: %v; difference: %v",
now, s.config.TimestampHeaderName, timestamp, timestamp-now)
}
// if the timestamp is older than ttl - skew, it's invalid
if timestamp <= now-int64(s.nonceCache.cacheTTL-MaxSkewSec) {
return false, fmt.Errorf("timestamp header too old; now: %v; %v: %v; difference: %v",
now, s.config.TimestampHeaderName, timestamp, now-timestamp)
}
return true, nil
} | go | func (s *Service) CheckTimestamp(timestampHeader string) (bool, error) {
// convert unix timestamp string into time struct
timestamp, err := strconv.ParseInt(timestampHeader, 10, 0)
if err != nil {
return false, fmt.Errorf("unable to parse %v: %v", s.config.TimestampHeaderName, timestampHeader)
}
now := s.clock.Now().UTC().Unix()
// if timestamp is from the future, it's invalid
if timestamp >= now+MaxSkewSec {
return false, fmt.Errorf("timestamp header from the future; now: %v; %v: %v; difference: %v",
now, s.config.TimestampHeaderName, timestamp, timestamp-now)
}
// if the timestamp is older than ttl - skew, it's invalid
if timestamp <= now-int64(s.nonceCache.cacheTTL-MaxSkewSec) {
return false, fmt.Errorf("timestamp header too old; now: %v; %v: %v; difference: %v",
now, s.config.TimestampHeaderName, timestamp, now-timestamp)
}
return true, nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"CheckTimestamp",
"(",
"timestampHeader",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"// convert unix timestamp string into time struct",
"timestamp",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"timestampHead... | // Parses a timestamp header and returns true if the timestamp is neither older than the TTL or is from the future. | [
"Parses",
"a",
"timestamp",
"header",
"and",
"returns",
"true",
"if",
"the",
"timestamp",
"is",
"neither",
"older",
"than",
"the",
"TTL",
"or",
"is",
"from",
"the",
"future",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/httpsign/auth.go#L336-L358 |
17,095 | mailgun/holster | stack/stack.go | GetLastFrame | func GetLastFrame(frames errors.StackTrace) FrameInfo {
if len(frames) == 0 {
return FrameInfo{}
}
pc := uintptr(frames[0]) - 1
fn := runtime.FuncForPC(pc)
if fn == nil {
return FrameInfo{Func: fmt.Sprintf("unknown func at %v", pc)}
}
filePath, lineNo := fn.FileLine(pc)
return FrameInfo{
CallStack: GetCallStack(frames),
Func: FuncName(fn),
File: filePath,
LineNo: lineNo,
}
} | go | func GetLastFrame(frames errors.StackTrace) FrameInfo {
if len(frames) == 0 {
return FrameInfo{}
}
pc := uintptr(frames[0]) - 1
fn := runtime.FuncForPC(pc)
if fn == nil {
return FrameInfo{Func: fmt.Sprintf("unknown func at %v", pc)}
}
filePath, lineNo := fn.FileLine(pc)
return FrameInfo{
CallStack: GetCallStack(frames),
Func: FuncName(fn),
File: filePath,
LineNo: lineNo,
}
} | [
"func",
"GetLastFrame",
"(",
"frames",
"errors",
".",
"StackTrace",
")",
"FrameInfo",
"{",
"if",
"len",
"(",
"frames",
")",
"==",
"0",
"{",
"return",
"FrameInfo",
"{",
"}",
"\n",
"}",
"\n",
"pc",
":=",
"uintptr",
"(",
"frames",
"[",
"0",
"]",
")",
... | // Returns Caller information on the first frame in the stack trace | [
"Returns",
"Caller",
"information",
"on",
"the",
"first",
"frame",
"in",
"the",
"stack",
"trace"
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/stack/stack.go#L29-L45 |
17,096 | mailgun/holster | secret/secret.go | New | func New(config *Config) (SecretService, error) {
var err error
var keyBytes *[SecretKeyLength]byte
var metricsClient metrics.Client
// Read in key from KeyPath or if not given, try getting them from KeyBytes.
if config.KeyPath != "" {
if keyBytes, err = ReadKeyFromDisk(config.KeyPath); err != nil {
return nil, err
}
} else {
if config.KeyBytes == nil {
return nil, errors.New("No key bytes provided.")
}
keyBytes = config.KeyBytes
}
// setup metrics service
if config.EmitStats {
// get hostname of box
hostname, err := os.Hostname()
if err != nil {
return nil, fmt.Errorf("failed to obtain hostname: %v", err)
}
// build lemma prefix
prefix := "lemma." + strings.Replace(hostname, ".", "_", -1)
if config.StatsdPrefix != "" {
prefix += "." + config.StatsdPrefix
}
// build metrics client
hostport := fmt.Sprintf("%v:%v", config.StatsdHost, config.StatsdPort)
metricsClient, err = metrics.NewWithOptions(hostport, prefix, metrics.Options{UseBuffering: true})
if err != nil {
return nil, err
}
} else {
// if you don't want to emit stats, use the nop client
metricsClient = metrics.NewNop()
}
return &Service{
secretKey: keyBytes,
metricsClient: metricsClient,
}, nil
} | go | func New(config *Config) (SecretService, error) {
var err error
var keyBytes *[SecretKeyLength]byte
var metricsClient metrics.Client
// Read in key from KeyPath or if not given, try getting them from KeyBytes.
if config.KeyPath != "" {
if keyBytes, err = ReadKeyFromDisk(config.KeyPath); err != nil {
return nil, err
}
} else {
if config.KeyBytes == nil {
return nil, errors.New("No key bytes provided.")
}
keyBytes = config.KeyBytes
}
// setup metrics service
if config.EmitStats {
// get hostname of box
hostname, err := os.Hostname()
if err != nil {
return nil, fmt.Errorf("failed to obtain hostname: %v", err)
}
// build lemma prefix
prefix := "lemma." + strings.Replace(hostname, ".", "_", -1)
if config.StatsdPrefix != "" {
prefix += "." + config.StatsdPrefix
}
// build metrics client
hostport := fmt.Sprintf("%v:%v", config.StatsdHost, config.StatsdPort)
metricsClient, err = metrics.NewWithOptions(hostport, prefix, metrics.Options{UseBuffering: true})
if err != nil {
return nil, err
}
} else {
// if you don't want to emit stats, use the nop client
metricsClient = metrics.NewNop()
}
return &Service{
secretKey: keyBytes,
metricsClient: metricsClient,
}, nil
} | [
"func",
"New",
"(",
"config",
"*",
"Config",
")",
"(",
"SecretService",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"keyBytes",
"*",
"[",
"SecretKeyLength",
"]",
"byte",
"\n",
"var",
"metricsClient",
"metrics",
".",
"Client",
"\n\n",
"// ... | // New returns a new Service. Config can not be nil. | [
"New",
"returns",
"a",
"new",
"Service",
".",
"Config",
"can",
"not",
"be",
"nil",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/secret/secret.go#L94-L140 |
17,097 | mailgun/holster | secret/secret.go | Seal | func Seal(value []byte, secretKey *[SecretKeyLength]byte) (SealedData, error) {
if secretKey == nil {
return nil, fmt.Errorf("secret key is nil")
}
secretService, err := New(&Config{KeyBytes: secretKey})
if err != nil {
return nil, err
}
return secretService.Seal(value)
} | go | func Seal(value []byte, secretKey *[SecretKeyLength]byte) (SealedData, error) {
if secretKey == nil {
return nil, fmt.Errorf("secret key is nil")
}
secretService, err := New(&Config{KeyBytes: secretKey})
if err != nil {
return nil, err
}
return secretService.Seal(value)
} | [
"func",
"Seal",
"(",
"value",
"[",
"]",
"byte",
",",
"secretKey",
"*",
"[",
"SecretKeyLength",
"]",
"byte",
")",
"(",
"SealedData",
",",
"error",
")",
"{",
"if",
"secretKey",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
... | // Seal takes plaintext and a key and returns encrypted and authenticated ciphertext.
// Allows passing in a key and useful for one off sealing purposes, otherwise
// create a secret.Service to seal multiple times. | [
"Seal",
"takes",
"plaintext",
"and",
"a",
"key",
"and",
"returns",
"encrypted",
"and",
"authenticated",
"ciphertext",
".",
"Allows",
"passing",
"in",
"a",
"key",
"and",
"useful",
"for",
"one",
"off",
"sealing",
"purposes",
"otherwise",
"create",
"a",
"secret",... | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/secret/secret.go#L145-L156 |
17,098 | mailgun/holster | secret/secret.go | Open | func Open(e SealedData, secretKey *[SecretKeyLength]byte) ([]byte, error) {
if secretKey == nil {
return nil, fmt.Errorf("secret key is nil")
}
secretService, err := New(&Config{KeyBytes: secretKey})
if err != nil {
return nil, err
}
return secretService.Open(e)
} | go | func Open(e SealedData, secretKey *[SecretKeyLength]byte) ([]byte, error) {
if secretKey == nil {
return nil, fmt.Errorf("secret key is nil")
}
secretService, err := New(&Config{KeyBytes: secretKey})
if err != nil {
return nil, err
}
return secretService.Open(e)
} | [
"func",
"Open",
"(",
"e",
"SealedData",
",",
"secretKey",
"*",
"[",
"SecretKeyLength",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"secretKey",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\""... | // Open authenticates the ciphertext and if valid, decrypts and returns plaintext.
// Allows passing in a key and useful for one off opening purposes, otherwise
// create a secret.Service to open multiple times. | [
"Open",
"authenticates",
"the",
"ciphertext",
"and",
"if",
"valid",
"decrypts",
"and",
"returns",
"plaintext",
".",
"Allows",
"passing",
"in",
"a",
"key",
"and",
"useful",
"for",
"one",
"off",
"opening",
"purposes",
"otherwise",
"create",
"a",
"secret",
".",
... | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/secret/secret.go#L161-L172 |
17,099 | mailgun/holster | secret/secret.go | Seal | func (s *Service) Seal(value []byte) (SealedData, error) {
// generate nonce
nonce, err := generateNonce()
if err != nil {
return nil, fmt.Errorf("unable to generate nonce: %v", err)
}
// use nacl secret box to encrypt plaintext
var encrypted []byte
encrypted = secretbox.Seal(encrypted, value, nonce, s.secretKey)
// return sealed ciphertext
return &SealedBytes{
Ciphertext: encrypted,
Nonce: nonce[:],
}, nil
} | go | func (s *Service) Seal(value []byte) (SealedData, error) {
// generate nonce
nonce, err := generateNonce()
if err != nil {
return nil, fmt.Errorf("unable to generate nonce: %v", err)
}
// use nacl secret box to encrypt plaintext
var encrypted []byte
encrypted = secretbox.Seal(encrypted, value, nonce, s.secretKey)
// return sealed ciphertext
return &SealedBytes{
Ciphertext: encrypted,
Nonce: nonce[:],
}, nil
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Seal",
"(",
"value",
"[",
"]",
"byte",
")",
"(",
"SealedData",
",",
"error",
")",
"{",
"// generate nonce",
"nonce",
",",
"err",
":=",
"generateNonce",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // Seal takes plaintext and returns encrypted and authenticated ciphertext. | [
"Seal",
"takes",
"plaintext",
"and",
"returns",
"encrypted",
"and",
"authenticated",
"ciphertext",
"."
] | 769f8d7f9b18d38062e704a0c26c8861702f0ea6 | https://github.com/mailgun/holster/blob/769f8d7f9b18d38062e704a0c26c8861702f0ea6/secret/secret.go#L175-L191 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.