repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
flynn/flynn | controller/scheduler/scheduler.go | findVolume | func (s *Scheduler) findVolume(job *Job, req *ct.VolumeReq) *Volume {
for _, vol := range s.volumes {
// skip destroyed or decommissioned volumes
if vol.GetState() == ct.VolumeStateDestroyed || vol.DecommissionedAt != nil {
continue
}
// skip if the app, release, type or path do not match
if vol.AppID != job.AppID {
continue
}
if vol.ReleaseID != job.ReleaseID {
continue
}
if vol.JobType != job.Type {
continue
}
if vol.Path != req.Path {
continue
}
// skip if the volume is assigned to another job
if vol.JobID != nil && *vol.JobID != job.ID {
continue
}
// skip if we have already assigned the job to a host
// and this volume doesn't exist on that host
if job.HostID != "" && vol.HostID != job.HostID {
continue
}
// return the matching volume
return vol
}
return nil
} | go | func (s *Scheduler) findVolume(job *Job, req *ct.VolumeReq) *Volume {
for _, vol := range s.volumes {
// skip destroyed or decommissioned volumes
if vol.GetState() == ct.VolumeStateDestroyed || vol.DecommissionedAt != nil {
continue
}
// skip if the app, release, type or path do not match
if vol.AppID != job.AppID {
continue
}
if vol.ReleaseID != job.ReleaseID {
continue
}
if vol.JobType != job.Type {
continue
}
if vol.Path != req.Path {
continue
}
// skip if the volume is assigned to another job
if vol.JobID != nil && *vol.JobID != job.ID {
continue
}
// skip if we have already assigned the job to a host
// and this volume doesn't exist on that host
if job.HostID != "" && vol.HostID != job.HostID {
continue
}
// return the matching volume
return vol
}
return nil
} | [
"func",
"(",
"s",
"*",
"Scheduler",
")",
"findVolume",
"(",
"job",
"*",
"Job",
",",
"req",
"*",
"ct",
".",
"VolumeReq",
")",
"*",
"Volume",
"{",
"for",
"_",
",",
"vol",
":=",
"range",
"s",
".",
"volumes",
"{",
"// skip destroyed or decommissioned volumes",
"if",
"vol",
".",
"GetState",
"(",
")",
"==",
"ct",
".",
"VolumeStateDestroyed",
"||",
"vol",
".",
"DecommissionedAt",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"// skip if the app, release, type or path do not match",
"if",
"vol",
".",
"AppID",
"!=",
"job",
".",
"AppID",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"vol",
".",
"ReleaseID",
"!=",
"job",
".",
"ReleaseID",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"vol",
".",
"JobType",
"!=",
"job",
".",
"Type",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"vol",
".",
"Path",
"!=",
"req",
".",
"Path",
"{",
"continue",
"\n",
"}",
"\n\n",
"// skip if the volume is assigned to another job",
"if",
"vol",
".",
"JobID",
"!=",
"nil",
"&&",
"*",
"vol",
".",
"JobID",
"!=",
"job",
".",
"ID",
"{",
"continue",
"\n",
"}",
"\n\n",
"// skip if we have already assigned the job to a host",
"// and this volume doesn't exist on that host",
"if",
"job",
".",
"HostID",
"!=",
"\"",
"\"",
"&&",
"vol",
".",
"HostID",
"!=",
"job",
".",
"HostID",
"{",
"continue",
"\n",
"}",
"\n\n",
"// return the matching volume",
"return",
"vol",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // findVolume looks for an existing, unassigned volume which matches the given
// job's app, release and type, and the volume request's path | [
"findVolume",
"looks",
"for",
"an",
"existing",
"unassigned",
"volume",
"which",
"matches",
"the",
"given",
"job",
"s",
"app",
"release",
"and",
"type",
"and",
"the",
"volume",
"request",
"s",
"path"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/scheduler/scheduler.go#L1040-L1076 | train |
flynn/flynn | controller/scheduler/scheduler.go | activeFormationCount | func (s *Scheduler) activeFormationCount(appID string) int {
activeReleases := make(map[string]struct{})
for _, job := range s.jobs {
if job.IsRunning() && job.IsInApp(appID) {
activeReleases[job.Formation.Release.ID] = struct{}{}
}
}
return len(activeReleases)
} | go | func (s *Scheduler) activeFormationCount(appID string) int {
activeReleases := make(map[string]struct{})
for _, job := range s.jobs {
if job.IsRunning() && job.IsInApp(appID) {
activeReleases[job.Formation.Release.ID] = struct{}{}
}
}
return len(activeReleases)
} | [
"func",
"(",
"s",
"*",
"Scheduler",
")",
"activeFormationCount",
"(",
"appID",
"string",
")",
"int",
"{",
"activeReleases",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"job",
":=",
"range",
"s",
".",
"jobs",
"{",
"if",
"job",
".",
"IsRunning",
"(",
")",
"&&",
"job",
".",
"IsInApp",
"(",
"appID",
")",
"{",
"activeReleases",
"[",
"job",
".",
"Formation",
".",
"Release",
".",
"ID",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"len",
"(",
"activeReleases",
")",
"\n",
"}"
] | // activeFormationCount returns the number of formations which have running
// jobs for the given app | [
"activeFormationCount",
"returns",
"the",
"number",
"of",
"formations",
"which",
"have",
"running",
"jobs",
"for",
"the",
"given",
"app"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/scheduler/scheduler.go#L1537-L1545 | train |
flynn/flynn | controller/scheduler/scheduler.go | findJobToStop | func (s *Scheduler) findJobToStop(f *Formation, typ string) (*Job, error) {
var found *Job
for _, job := range s.jobs.WithFormationAndType(f, typ) {
switch job.State {
case JobStatePending:
return job, nil
case JobStateStarting, JobStateRunning:
// if the job is on a host which is shutting down,
// return it (it is about to stop anyway, and this
// avoids a race where modifying the omni counts to
// remove a shut down host could cause a subsequent
// rectify to stop a job on an active host before the
// shutting down host's job has stopped)
if host, ok := s.hosts[job.HostID]; ok && host.Shutdown {
return job, nil
}
// return the most recent job (which is the first in
// the slice we are iterating over) if none of the
// above cases match, preferring starting jobs to
// running ones
if found == nil || found.State == JobStateRunning && job.State == JobStateStarting {
found = job
}
}
}
if found == nil {
return nil, fmt.Errorf("no %s jobs running", typ)
}
return found, nil
} | go | func (s *Scheduler) findJobToStop(f *Formation, typ string) (*Job, error) {
var found *Job
for _, job := range s.jobs.WithFormationAndType(f, typ) {
switch job.State {
case JobStatePending:
return job, nil
case JobStateStarting, JobStateRunning:
// if the job is on a host which is shutting down,
// return it (it is about to stop anyway, and this
// avoids a race where modifying the omni counts to
// remove a shut down host could cause a subsequent
// rectify to stop a job on an active host before the
// shutting down host's job has stopped)
if host, ok := s.hosts[job.HostID]; ok && host.Shutdown {
return job, nil
}
// return the most recent job (which is the first in
// the slice we are iterating over) if none of the
// above cases match, preferring starting jobs to
// running ones
if found == nil || found.State == JobStateRunning && job.State == JobStateStarting {
found = job
}
}
}
if found == nil {
return nil, fmt.Errorf("no %s jobs running", typ)
}
return found, nil
} | [
"func",
"(",
"s",
"*",
"Scheduler",
")",
"findJobToStop",
"(",
"f",
"*",
"Formation",
",",
"typ",
"string",
")",
"(",
"*",
"Job",
",",
"error",
")",
"{",
"var",
"found",
"*",
"Job",
"\n",
"for",
"_",
",",
"job",
":=",
"range",
"s",
".",
"jobs",
".",
"WithFormationAndType",
"(",
"f",
",",
"typ",
")",
"{",
"switch",
"job",
".",
"State",
"{",
"case",
"JobStatePending",
":",
"return",
"job",
",",
"nil",
"\n",
"case",
"JobStateStarting",
",",
"JobStateRunning",
":",
"// if the job is on a host which is shutting down,",
"// return it (it is about to stop anyway, and this",
"// avoids a race where modifying the omni counts to",
"// remove a shut down host could cause a subsequent",
"// rectify to stop a job on an active host before the",
"// shutting down host's job has stopped)",
"if",
"host",
",",
"ok",
":=",
"s",
".",
"hosts",
"[",
"job",
".",
"HostID",
"]",
";",
"ok",
"&&",
"host",
".",
"Shutdown",
"{",
"return",
"job",
",",
"nil",
"\n",
"}",
"\n\n",
"// return the most recent job (which is the first in",
"// the slice we are iterating over) if none of the",
"// above cases match, preferring starting jobs to",
"// running ones",
"if",
"found",
"==",
"nil",
"||",
"found",
".",
"State",
"==",
"JobStateRunning",
"&&",
"job",
".",
"State",
"==",
"JobStateStarting",
"{",
"found",
"=",
"job",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"found",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"typ",
")",
"\n",
"}",
"\n",
"return",
"found",
",",
"nil",
"\n",
"}"
] | // findJobToStop finds a job from the given formation and type which should be
// stopped, choosing pending jobs if present, and the most recently started job
// otherwise | [
"findJobToStop",
"finds",
"a",
"job",
"from",
"the",
"given",
"formation",
"and",
"type",
"which",
"should",
"be",
"stopped",
"choosing",
"pending",
"jobs",
"if",
"present",
"and",
"the",
"most",
"recently",
"started",
"job",
"otherwise"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/scheduler/scheduler.go#L2478-L2508 | train |
flynn/flynn | appliance/redis/cmd/flynn-redis/main.go | readID | func (m *Main) readID(path string) (string, error) {
buf, err := ioutil.ReadFile(path)
if err != nil && !os.IsNotExist(err) {
return "", fmt.Errorf("error reading instance ID: %s", err)
}
// If the ID exists then return it immediately.
id := string(buf)
if id != "" {
return id, nil
}
// Generate a new ID and write it to file.
id = random.UUID()
if err := ioutil.WriteFile(path, []byte(id), 0644); err != nil {
return "", fmt.Errorf("error writing instance ID: %s", err)
}
return id, nil
} | go | func (m *Main) readID(path string) (string, error) {
buf, err := ioutil.ReadFile(path)
if err != nil && !os.IsNotExist(err) {
return "", fmt.Errorf("error reading instance ID: %s", err)
}
// If the ID exists then return it immediately.
id := string(buf)
if id != "" {
return id, nil
}
// Generate a new ID and write it to file.
id = random.UUID()
if err := ioutil.WriteFile(path, []byte(id), 0644); err != nil {
return "", fmt.Errorf("error writing instance ID: %s", err)
}
return id, nil
} | [
"func",
"(",
"m",
"*",
"Main",
")",
"readID",
"(",
"path",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"buf",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// If the ID exists then return it immediately.",
"id",
":=",
"string",
"(",
"buf",
")",
"\n",
"if",
"id",
"!=",
"\"",
"\"",
"{",
"return",
"id",
",",
"nil",
"\n",
"}",
"\n\n",
"// Generate a new ID and write it to file.",
"id",
"=",
"random",
".",
"UUID",
"(",
")",
"\n",
"if",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"path",
",",
"[",
"]",
"byte",
"(",
"id",
")",
",",
"0644",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"id",
",",
"nil",
"\n",
"}"
] | // readID reads the instance id from path.
// If the file instance id doesn't exist then a random ID is generated. | [
"readID",
"reads",
"the",
"instance",
"id",
"from",
"path",
".",
"If",
"the",
"file",
"instance",
"id",
"doesn",
"t",
"exist",
"then",
"a",
"random",
"ID",
"is",
"generated",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/redis/cmd/flynn-redis/main.go#L195-L213 | train |
flynn/flynn | host/fixer/fixer.go | FindAppReleaseJobs | func (f *ClusterFixer) FindAppReleaseJobs(app, typ string) []map[string]*host.Job {
var sortReleases ReleasesByCreate
releases := make(map[string]map[string]*host.ActiveJob) // map of releaseID -> hostID -> job ordered
// connect to each host, list jobs, find distinct releases
for _, h := range f.hosts {
jobs, err := h.ListJobs()
if err != nil {
f.l.Error("error listing jobs", "host", h.ID(), "error", err)
continue
}
for _, j := range jobs {
if j.Job.Metadata["flynn-controller.app_name"] != app || j.Job.Metadata["flynn-controller.type"] != typ {
continue
}
id := j.Job.Metadata["flynn-controller.release"]
if id == "" {
continue
}
m, ok := releases[id]
if !ok {
sortReleases = append(sortReleases, SortableRelease{id, j.StartedAt})
m = make(map[string]*host.ActiveJob)
releases[id] = m
}
if curr, ok := m[h.ID()]; ok && curr.StartedAt.Before(j.StartedAt) {
continue
}
jobCopy := j
m[h.ID()] = &jobCopy
}
}
sort.Sort(sortReleases)
res := make([]map[string]*host.Job, len(sortReleases))
for i, r := range sortReleases {
res[i] = make(map[string]*host.Job, len(releases[r.id]))
for k, v := range releases[r.id] {
res[i][k] = v.Job
}
}
return res
} | go | func (f *ClusterFixer) FindAppReleaseJobs(app, typ string) []map[string]*host.Job {
var sortReleases ReleasesByCreate
releases := make(map[string]map[string]*host.ActiveJob) // map of releaseID -> hostID -> job ordered
// connect to each host, list jobs, find distinct releases
for _, h := range f.hosts {
jobs, err := h.ListJobs()
if err != nil {
f.l.Error("error listing jobs", "host", h.ID(), "error", err)
continue
}
for _, j := range jobs {
if j.Job.Metadata["flynn-controller.app_name"] != app || j.Job.Metadata["flynn-controller.type"] != typ {
continue
}
id := j.Job.Metadata["flynn-controller.release"]
if id == "" {
continue
}
m, ok := releases[id]
if !ok {
sortReleases = append(sortReleases, SortableRelease{id, j.StartedAt})
m = make(map[string]*host.ActiveJob)
releases[id] = m
}
if curr, ok := m[h.ID()]; ok && curr.StartedAt.Before(j.StartedAt) {
continue
}
jobCopy := j
m[h.ID()] = &jobCopy
}
}
sort.Sort(sortReleases)
res := make([]map[string]*host.Job, len(sortReleases))
for i, r := range sortReleases {
res[i] = make(map[string]*host.Job, len(releases[r.id]))
for k, v := range releases[r.id] {
res[i][k] = v.Job
}
}
return res
} | [
"func",
"(",
"f",
"*",
"ClusterFixer",
")",
"FindAppReleaseJobs",
"(",
"app",
",",
"typ",
"string",
")",
"[",
"]",
"map",
"[",
"string",
"]",
"*",
"host",
".",
"Job",
"{",
"var",
"sortReleases",
"ReleasesByCreate",
"\n",
"releases",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"*",
"host",
".",
"ActiveJob",
")",
"// map of releaseID -> hostID -> job ordered",
"\n",
"// connect to each host, list jobs, find distinct releases",
"for",
"_",
",",
"h",
":=",
"range",
"f",
".",
"hosts",
"{",
"jobs",
",",
"err",
":=",
"h",
".",
"ListJobs",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"f",
".",
"l",
".",
"Error",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"h",
".",
"ID",
"(",
")",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"j",
":=",
"range",
"jobs",
"{",
"if",
"j",
".",
"Job",
".",
"Metadata",
"[",
"\"",
"\"",
"]",
"!=",
"app",
"||",
"j",
".",
"Job",
".",
"Metadata",
"[",
"\"",
"\"",
"]",
"!=",
"typ",
"{",
"continue",
"\n",
"}",
"\n",
"id",
":=",
"j",
".",
"Job",
".",
"Metadata",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"id",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"m",
",",
"ok",
":=",
"releases",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"sortReleases",
"=",
"append",
"(",
"sortReleases",
",",
"SortableRelease",
"{",
"id",
",",
"j",
".",
"StartedAt",
"}",
")",
"\n",
"m",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"host",
".",
"ActiveJob",
")",
"\n",
"releases",
"[",
"id",
"]",
"=",
"m",
"\n",
"}",
"\n",
"if",
"curr",
",",
"ok",
":=",
"m",
"[",
"h",
".",
"ID",
"(",
")",
"]",
";",
"ok",
"&&",
"curr",
".",
"StartedAt",
".",
"Before",
"(",
"j",
".",
"StartedAt",
")",
"{",
"continue",
"\n",
"}",
"\n",
"jobCopy",
":=",
"j",
"\n",
"m",
"[",
"h",
".",
"ID",
"(",
")",
"]",
"=",
"&",
"jobCopy",
"\n",
"}",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"sortReleases",
")",
"\n",
"res",
":=",
"make",
"(",
"[",
"]",
"map",
"[",
"string",
"]",
"*",
"host",
".",
"Job",
",",
"len",
"(",
"sortReleases",
")",
")",
"\n",
"for",
"i",
",",
"r",
":=",
"range",
"sortReleases",
"{",
"res",
"[",
"i",
"]",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"host",
".",
"Job",
",",
"len",
"(",
"releases",
"[",
"r",
".",
"id",
"]",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"releases",
"[",
"r",
".",
"id",
"]",
"{",
"res",
"[",
"i",
"]",
"[",
"k",
"]",
"=",
"v",
".",
"Job",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // FindAppReleaseJobs returns a slice with one map of host id to job for each
// known release of the given app and type, most recent first | [
"FindAppReleaseJobs",
"returns",
"a",
"slice",
"with",
"one",
"map",
"of",
"host",
"id",
"to",
"job",
"for",
"each",
"known",
"release",
"of",
"the",
"given",
"app",
"and",
"type",
"most",
"recent",
"first"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/host/fixer/fixer.go#L220-L260 | train |
flynn/flynn | pkg/cors/cors.go | IsOriginAllowed | func (o *Options) IsOriginAllowed(origin string, req *http.Request) (allowed bool) {
if o.ShouldAllowOrigin != nil {
return o.ShouldAllowOrigin(origin, req)
}
for _, pattern := range allowOriginPatterns {
allowed, _ = regexp.MatchString(pattern, origin)
if allowed {
return
}
}
return
} | go | func (o *Options) IsOriginAllowed(origin string, req *http.Request) (allowed bool) {
if o.ShouldAllowOrigin != nil {
return o.ShouldAllowOrigin(origin, req)
}
for _, pattern := range allowOriginPatterns {
allowed, _ = regexp.MatchString(pattern, origin)
if allowed {
return
}
}
return
} | [
"func",
"(",
"o",
"*",
"Options",
")",
"IsOriginAllowed",
"(",
"origin",
"string",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"allowed",
"bool",
")",
"{",
"if",
"o",
".",
"ShouldAllowOrigin",
"!=",
"nil",
"{",
"return",
"o",
".",
"ShouldAllowOrigin",
"(",
"origin",
",",
"req",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"pattern",
":=",
"range",
"allowOriginPatterns",
"{",
"allowed",
",",
"_",
"=",
"regexp",
".",
"MatchString",
"(",
"pattern",
",",
"origin",
")",
"\n",
"if",
"allowed",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Looks up if the origin matches one of the patterns
// generated from Options.AllowOrigins patterns. | [
"Looks",
"up",
"if",
"the",
"origin",
"matches",
"one",
"of",
"the",
"patterns",
"generated",
"from",
"Options",
".",
"AllowOrigins",
"patterns",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cors/cors.go#L106-L117 | train |
flynn/flynn | pkg/cors/cors.go | Handler | func (o *Options) Handler(next http.Handler) http.HandlerFunc {
// Allow default headers if nothing is specified.
if len(o.AllowHeaders) == 0 {
o.AllowHeaders = defaultAllowHeaders
}
for _, origin := range o.AllowOrigins {
pattern := regexp.QuoteMeta(origin)
pattern = strings.Replace(pattern, "\\*", ".*", -1)
pattern = strings.Replace(pattern, "\\?", ".", -1)
allowOriginPatterns = append(allowOriginPatterns, "^"+pattern+"$")
}
return func(w http.ResponseWriter, req *http.Request) {
if origin := req.Header.Get(headerOrigin); origin != "" {
for key, value := range o.Header(origin, req) {
w.Header().Set(key, value)
}
if req.Method == "OPTIONS" {
w.WriteHeader(200)
return
}
}
next.ServeHTTP(w, req)
}
} | go | func (o *Options) Handler(next http.Handler) http.HandlerFunc {
// Allow default headers if nothing is specified.
if len(o.AllowHeaders) == 0 {
o.AllowHeaders = defaultAllowHeaders
}
for _, origin := range o.AllowOrigins {
pattern := regexp.QuoteMeta(origin)
pattern = strings.Replace(pattern, "\\*", ".*", -1)
pattern = strings.Replace(pattern, "\\?", ".", -1)
allowOriginPatterns = append(allowOriginPatterns, "^"+pattern+"$")
}
return func(w http.ResponseWriter, req *http.Request) {
if origin := req.Header.Get(headerOrigin); origin != "" {
for key, value := range o.Header(origin, req) {
w.Header().Set(key, value)
}
if req.Method == "OPTIONS" {
w.WriteHeader(200)
return
}
}
next.ServeHTTP(w, req)
}
} | [
"func",
"(",
"o",
"*",
"Options",
")",
"Handler",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"HandlerFunc",
"{",
"// Allow default headers if nothing is specified.",
"if",
"len",
"(",
"o",
".",
"AllowHeaders",
")",
"==",
"0",
"{",
"o",
".",
"AllowHeaders",
"=",
"defaultAllowHeaders",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"origin",
":=",
"range",
"o",
".",
"AllowOrigins",
"{",
"pattern",
":=",
"regexp",
".",
"QuoteMeta",
"(",
"origin",
")",
"\n",
"pattern",
"=",
"strings",
".",
"Replace",
"(",
"pattern",
",",
"\"",
"\\\\",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"pattern",
"=",
"strings",
".",
"Replace",
"(",
"pattern",
",",
"\"",
"\\\\",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"allowOriginPatterns",
"=",
"append",
"(",
"allowOriginPatterns",
",",
"\"",
"\"",
"+",
"pattern",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"origin",
":=",
"req",
".",
"Header",
".",
"Get",
"(",
"headerOrigin",
")",
";",
"origin",
"!=",
"\"",
"\"",
"{",
"for",
"key",
",",
"value",
":=",
"range",
"o",
".",
"Header",
"(",
"origin",
",",
"req",
")",
"{",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"key",
",",
"value",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Method",
"==",
"\"",
"\"",
"{",
"w",
".",
"WriteHeader",
"(",
"200",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"next",
".",
"ServeHTTP",
"(",
"w",
",",
"req",
")",
"\n",
"}",
"\n",
"}"
] | // Allows CORS for requests those match the provided options. | [
"Allows",
"CORS",
"for",
"requests",
"those",
"match",
"the",
"provided",
"options",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cors/cors.go#L120-L145 | train |
flynn/flynn | appliance/postgresql/process.go | initDB | func (p *Process) initDB() error {
log := p.log.New("fn", "initDB", "dir", p.dataDir)
log.Debug("starting initDB")
// ignore errors, since the db could be already initialized
// TODO(titanous): check errors when this is not the case
_ = p.runCmd(exec.Command(
p.binPath("initdb"),
"--pgdata", p.dataDir,
"--username=postgres",
"--encoding=UTF-8",
"--locale=en_US.UTF-8",
))
return p.writeHBAConf()
} | go | func (p *Process) initDB() error {
log := p.log.New("fn", "initDB", "dir", p.dataDir)
log.Debug("starting initDB")
// ignore errors, since the db could be already initialized
// TODO(titanous): check errors when this is not the case
_ = p.runCmd(exec.Command(
p.binPath("initdb"),
"--pgdata", p.dataDir,
"--username=postgres",
"--encoding=UTF-8",
"--locale=en_US.UTF-8",
))
return p.writeHBAConf()
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"initDB",
"(",
")",
"error",
"{",
"log",
":=",
"p",
".",
"log",
".",
"New",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"p",
".",
"dataDir",
")",
"\n",
"log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"// ignore errors, since the db could be already initialized",
"// TODO(titanous): check errors when this is not the case",
"_",
"=",
"p",
".",
"runCmd",
"(",
"exec",
".",
"Command",
"(",
"p",
".",
"binPath",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
",",
"p",
".",
"dataDir",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
")",
")",
"\n\n",
"return",
"p",
".",
"writeHBAConf",
"(",
")",
"\n",
"}"
] | // initDB initializes the postgres data directory for a new dDB. This can fail
// if the db has already been initialized, which is not a fatal error.
//
// This method should only be called by the primary of a shard. Standbys will
// not need to initialize, as they will restore from an already running primary. | [
"initDB",
"initializes",
"the",
"postgres",
"data",
"directory",
"for",
"a",
"new",
"dDB",
".",
"This",
"can",
"fail",
"if",
"the",
"db",
"has",
"already",
"been",
"initialized",
"which",
"is",
"not",
"a",
"fatal",
"error",
".",
"This",
"method",
"should",
"only",
"be",
"called",
"by",
"the",
"primary",
"of",
"a",
"shard",
".",
"Standbys",
"will",
"not",
"need",
"to",
"initialize",
"as",
"they",
"will",
"restore",
"from",
"an",
"already",
"running",
"primary",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/postgresql/process.go#L809-L824 | train |
flynn/flynn | host/downloader/downloader.go | DownloadConfig | func (d *Downloader) DownloadConfig(dir string) (map[string]string, error) {
if err := os.MkdirAll(dir, 0755); err != nil {
return nil, fmt.Errorf("error creating config dir: %s", err)
}
paths := make(map[string]string, len(config))
for _, conf := range config {
path, err := d.downloadGzippedFile(conf, dir, false)
if err != nil {
return nil, err
}
paths[conf] = path
}
return paths, nil
} | go | func (d *Downloader) DownloadConfig(dir string) (map[string]string, error) {
if err := os.MkdirAll(dir, 0755); err != nil {
return nil, fmt.Errorf("error creating config dir: %s", err)
}
paths := make(map[string]string, len(config))
for _, conf := range config {
path, err := d.downloadGzippedFile(conf, dir, false)
if err != nil {
return nil, err
}
paths[conf] = path
}
return paths, nil
} | [
"func",
"(",
"d",
"*",
"Downloader",
")",
"DownloadConfig",
"(",
"dir",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"dir",
",",
"0755",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"paths",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"len",
"(",
"config",
")",
")",
"\n",
"for",
"_",
",",
"conf",
":=",
"range",
"config",
"{",
"path",
",",
"err",
":=",
"d",
".",
"downloadGzippedFile",
"(",
"conf",
",",
"dir",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"paths",
"[",
"conf",
"]",
"=",
"path",
"\n",
"}",
"\n",
"return",
"paths",
",",
"nil",
"\n",
"}"
] | // DownloadConfig downloads the Flynn config files using the tuf client to the
// given dir. | [
"DownloadConfig",
"downloads",
"the",
"Flynn",
"config",
"files",
"using",
"the",
"tuf",
"client",
"to",
"the",
"given",
"dir",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/host/downloader/downloader.go#L69-L82 | train |
flynn/flynn | pkg/cluster/utils.go | ExtractHostID | func ExtractHostID(id string) (string, error) {
ids := strings.SplitN(id, "-", 2)
if len(ids) != 2 || ids[0] == "" || ids[1] == "" {
return "", errors.New("invalid ID")
}
return ids[0], nil
} | go | func ExtractHostID(id string) (string, error) {
ids := strings.SplitN(id, "-", 2)
if len(ids) != 2 || ids[0] == "" || ids[1] == "" {
return "", errors.New("invalid ID")
}
return ids[0], nil
} | [
"func",
"ExtractHostID",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"ids",
":=",
"strings",
".",
"SplitN",
"(",
"id",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"ids",
")",
"!=",
"2",
"||",
"ids",
"[",
"0",
"]",
"==",
"\"",
"\"",
"||",
"ids",
"[",
"1",
"]",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"ids",
"[",
"0",
"]",
",",
"nil",
"\n",
"}"
] | // ExtractHostID returns the host ID component of a job ID, returning an error
// if the given ID is invalid. | [
"ExtractHostID",
"returns",
"the",
"host",
"ID",
"component",
"of",
"a",
"job",
"ID",
"returning",
"an",
"error",
"if",
"the",
"given",
"ID",
"is",
"invalid",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/utils.go#L12-L18 | train |
flynn/flynn | pkg/cluster/utils.go | GenerateJobID | func GenerateJobID(hostID, uuid string) string {
if uuid == "" {
uuid = random.UUID()
}
return hostID + "-" + uuid
} | go | func GenerateJobID(hostID, uuid string) string {
if uuid == "" {
uuid = random.UUID()
}
return hostID + "-" + uuid
} | [
"func",
"GenerateJobID",
"(",
"hostID",
",",
"uuid",
"string",
")",
"string",
"{",
"if",
"uuid",
"==",
"\"",
"\"",
"{",
"uuid",
"=",
"random",
".",
"UUID",
"(",
")",
"\n",
"}",
"\n",
"return",
"hostID",
"+",
"\"",
"\"",
"+",
"uuid",
"\n",
"}"
] | // GenerateJobID returns a random job identifier, prefixed with the given host ID. | [
"GenerateJobID",
"returns",
"a",
"random",
"job",
"identifier",
"prefixed",
"with",
"the",
"given",
"host",
"ID",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/utils.go#L31-L36 | train |
flynn/flynn | appliance/mongodb/process.go | waitForSync | func (p *Process) waitForSync(downstream *discoverd.Instance) {
p.Logger.Debug("waiting for downstream sync")
stopCh := make(chan struct{})
doneCh := make(chan struct{})
var once sync.Once
p.cancelSyncWait = func() {
once.Do(func() { close(stopCh); <-doneCh })
}
go p.waitForSyncInner(downstream, stopCh, doneCh)
} | go | func (p *Process) waitForSync(downstream *discoverd.Instance) {
p.Logger.Debug("waiting for downstream sync")
stopCh := make(chan struct{})
doneCh := make(chan struct{})
var once sync.Once
p.cancelSyncWait = func() {
once.Do(func() { close(stopCh); <-doneCh })
}
go p.waitForSyncInner(downstream, stopCh, doneCh)
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"waitForSync",
"(",
"downstream",
"*",
"discoverd",
".",
"Instance",
")",
"{",
"p",
".",
"Logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"stopCh",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"doneCh",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n\n",
"var",
"once",
"sync",
".",
"Once",
"\n",
"p",
".",
"cancelSyncWait",
"=",
"func",
"(",
")",
"{",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"stopCh",
")",
";",
"<-",
"doneCh",
"}",
")",
"\n",
"}",
"\n\n",
"go",
"p",
".",
"waitForSyncInner",
"(",
"downstream",
",",
"stopCh",
",",
"doneCh",
")",
"\n",
"}"
] | // waitForSync waits for downstream sync in goroutine | [
"waitForSync",
"waits",
"for",
"downstream",
"sync",
"in",
"goroutine"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mongodb/process.go#L853-L865 | train |
flynn/flynn | appliance/mongodb/process.go | DialInfo | func (p *Process) DialInfo() *mgo.DialInfo {
localhost := net.JoinHostPort("localhost", p.Port)
info := &mgo.DialInfo{
Addrs: []string{localhost},
Timeout: 5 * time.Second,
Direct: true,
}
if p.securityEnabled() {
info.Addrs = []string{p.addr()}
info.Database = "admin"
info.Username = "flynn"
info.Password = p.Password
}
return info
} | go | func (p *Process) DialInfo() *mgo.DialInfo {
localhost := net.JoinHostPort("localhost", p.Port)
info := &mgo.DialInfo{
Addrs: []string{localhost},
Timeout: 5 * time.Second,
Direct: true,
}
if p.securityEnabled() {
info.Addrs = []string{p.addr()}
info.Database = "admin"
info.Username = "flynn"
info.Password = p.Password
}
return info
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"DialInfo",
"(",
")",
"*",
"mgo",
".",
"DialInfo",
"{",
"localhost",
":=",
"net",
".",
"JoinHostPort",
"(",
"\"",
"\"",
",",
"p",
".",
"Port",
")",
"\n",
"info",
":=",
"&",
"mgo",
".",
"DialInfo",
"{",
"Addrs",
":",
"[",
"]",
"string",
"{",
"localhost",
"}",
",",
"Timeout",
":",
"5",
"*",
"time",
".",
"Second",
",",
"Direct",
":",
"true",
",",
"}",
"\n\n",
"if",
"p",
".",
"securityEnabled",
"(",
")",
"{",
"info",
".",
"Addrs",
"=",
"[",
"]",
"string",
"{",
"p",
".",
"addr",
"(",
")",
"}",
"\n",
"info",
".",
"Database",
"=",
"\"",
"\"",
"\n",
"info",
".",
"Username",
"=",
"\"",
"\"",
"\n",
"info",
".",
"Password",
"=",
"p",
".",
"Password",
"\n",
"}",
"\n",
"return",
"info",
"\n",
"}"
] | // DialInfo returns dial info for connecting to the local process as the "flynn" user. | [
"DialInfo",
"returns",
"dial",
"info",
"for",
"connecting",
"to",
"the",
"local",
"process",
"as",
"the",
"flynn",
"user",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mongodb/process.go#L868-L883 | train |
flynn/flynn | router/proxyproto/protocol.go | Read | func (p *conn) Read(b []byte) (int, error) {
var err error
p.initOnce.Do(func() { err = p.checkPrefix() })
if err != nil {
return 0, err
}
if p.connBuf != nil {
n := copy(b, p.connBuf)
p.connBuf = p.connBuf[n:]
if len(p.connBuf) == 0 {
p.connBuf = nil
}
if len(b) == n {
return n, nil
}
readN, err := p.Conn.Read(b[n:])
return readN + n, err
}
return p.Conn.Read(b)
} | go | func (p *conn) Read(b []byte) (int, error) {
var err error
p.initOnce.Do(func() { err = p.checkPrefix() })
if err != nil {
return 0, err
}
if p.connBuf != nil {
n := copy(b, p.connBuf)
p.connBuf = p.connBuf[n:]
if len(p.connBuf) == 0 {
p.connBuf = nil
}
if len(b) == n {
return n, nil
}
readN, err := p.Conn.Read(b[n:])
return readN + n, err
}
return p.Conn.Read(b)
} | [
"func",
"(",
"p",
"*",
"conn",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"p",
".",
"initOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"err",
"=",
"p",
".",
"checkPrefix",
"(",
")",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"if",
"p",
".",
"connBuf",
"!=",
"nil",
"{",
"n",
":=",
"copy",
"(",
"b",
",",
"p",
".",
"connBuf",
")",
"\n",
"p",
".",
"connBuf",
"=",
"p",
".",
"connBuf",
"[",
"n",
":",
"]",
"\n",
"if",
"len",
"(",
"p",
".",
"connBuf",
")",
"==",
"0",
"{",
"p",
".",
"connBuf",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"len",
"(",
"b",
")",
"==",
"n",
"{",
"return",
"n",
",",
"nil",
"\n",
"}",
"\n",
"readN",
",",
"err",
":=",
"p",
".",
"Conn",
".",
"Read",
"(",
"b",
"[",
"n",
":",
"]",
")",
"\n",
"return",
"readN",
"+",
"n",
",",
"err",
"\n",
"}",
"\n",
"return",
"p",
".",
"Conn",
".",
"Read",
"(",
"b",
")",
"\n",
"}"
] | // Read checks for the PROXY protocol header when doing the initial scan. If
// there is an error parsing the header, it is returned and the socket is
// closed. | [
"Read",
"checks",
"for",
"the",
"PROXY",
"protocol",
"header",
"when",
"doing",
"the",
"initial",
"scan",
".",
"If",
"there",
"is",
"an",
"error",
"parsing",
"the",
"header",
"it",
"is",
"returned",
"and",
"the",
"socket",
"is",
"closed",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/router/proxyproto/protocol.go#L55-L74 | train |
flynn/flynn | logaggregator/aggregator.go | NewAggregator | func NewAggregator() *Aggregator {
a := &Aggregator{
buffers: make(map[string]*buffer.Buffer),
msgc: make(chan *rfc5424.Message, 1000),
pausec: make(chan struct{}),
}
go a.run()
return a
} | go | func NewAggregator() *Aggregator {
a := &Aggregator{
buffers: make(map[string]*buffer.Buffer),
msgc: make(chan *rfc5424.Message, 1000),
pausec: make(chan struct{}),
}
go a.run()
return a
} | [
"func",
"NewAggregator",
"(",
")",
"*",
"Aggregator",
"{",
"a",
":=",
"&",
"Aggregator",
"{",
"buffers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"buffer",
".",
"Buffer",
")",
",",
"msgc",
":",
"make",
"(",
"chan",
"*",
"rfc5424",
".",
"Message",
",",
"1000",
")",
",",
"pausec",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"go",
"a",
".",
"run",
"(",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // NewAggregator creates a new running Aggregator. | [
"NewAggregator",
"creates",
"a",
"new",
"running",
"Aggregator",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/logaggregator/aggregator.go#L22-L30 | train |
flynn/flynn | logaggregator/aggregator.go | Read | func (a *Aggregator) Read(id string) []*rfc5424.Message {
return a.getBuffer(id).Read()
} | go | func (a *Aggregator) Read(id string) []*rfc5424.Message {
return a.getBuffer(id).Read()
} | [
"func",
"(",
"a",
"*",
"Aggregator",
")",
"Read",
"(",
"id",
"string",
")",
"[",
"]",
"*",
"rfc5424",
".",
"Message",
"{",
"return",
"a",
".",
"getBuffer",
"(",
"id",
")",
".",
"Read",
"(",
")",
"\n",
"}"
] | // Read returns the buffered messages for id. | [
"Read",
"returns",
"the",
"buffered",
"messages",
"for",
"id",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/logaggregator/aggregator.go#L49-L51 | train |
flynn/flynn | logaggregator/aggregator.go | ReadAll | func (a *Aggregator) ReadAll() [][]*rfc5424.Message {
// TODO(benburkert): restructure Aggregator & ring.Buffer to avoid nested locks
a.bmu.Lock()
defer a.bmu.Unlock()
buffers := make([][]*rfc5424.Message, 0, len(a.buffers))
for _, buf := range a.buffers {
buffers = append(buffers, buf.Read())
}
return buffers
} | go | func (a *Aggregator) ReadAll() [][]*rfc5424.Message {
// TODO(benburkert): restructure Aggregator & ring.Buffer to avoid nested locks
a.bmu.Lock()
defer a.bmu.Unlock()
buffers := make([][]*rfc5424.Message, 0, len(a.buffers))
for _, buf := range a.buffers {
buffers = append(buffers, buf.Read())
}
return buffers
} | [
"func",
"(",
"a",
"*",
"Aggregator",
")",
"ReadAll",
"(",
")",
"[",
"]",
"[",
"]",
"*",
"rfc5424",
".",
"Message",
"{",
"// TODO(benburkert): restructure Aggregator & ring.Buffer to avoid nested locks",
"a",
".",
"bmu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"bmu",
".",
"Unlock",
"(",
")",
"\n\n",
"buffers",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"*",
"rfc5424",
".",
"Message",
",",
"0",
",",
"len",
"(",
"a",
".",
"buffers",
")",
")",
"\n",
"for",
"_",
",",
"buf",
":=",
"range",
"a",
".",
"buffers",
"{",
"buffers",
"=",
"append",
"(",
"buffers",
",",
"buf",
".",
"Read",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"buffers",
"\n",
"}"
] | // ReadAll returns all buffered messages. | [
"ReadAll",
"returns",
"all",
"buffered",
"messages",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/logaggregator/aggregator.go#L54-L65 | train |
flynn/flynn | logaggregator/aggregator.go | ReadAndSubscribe | func (a *Aggregator) ReadAndSubscribe(id string, msgc chan<- *rfc5424.Message, donec <-chan struct{}) []*rfc5424.Message {
return a.getBuffer(id).ReadAndSubscribe(msgc, donec)
} | go | func (a *Aggregator) ReadAndSubscribe(id string, msgc chan<- *rfc5424.Message, donec <-chan struct{}) []*rfc5424.Message {
return a.getBuffer(id).ReadAndSubscribe(msgc, donec)
} | [
"func",
"(",
"a",
"*",
"Aggregator",
")",
"ReadAndSubscribe",
"(",
"id",
"string",
",",
"msgc",
"chan",
"<-",
"*",
"rfc5424",
".",
"Message",
",",
"donec",
"<-",
"chan",
"struct",
"{",
"}",
")",
"[",
"]",
"*",
"rfc5424",
".",
"Message",
"{",
"return",
"a",
".",
"getBuffer",
"(",
"id",
")",
".",
"ReadAndSubscribe",
"(",
"msgc",
",",
"donec",
")",
"\n",
"}"
] | // Read returns the buffered messages and adds a subscriber channel for id. | [
"Read",
"returns",
"the",
"buffered",
"messages",
"and",
"adds",
"a",
"subscriber",
"channel",
"for",
"id",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/logaggregator/aggregator.go#L68-L70 | train |
flynn/flynn | logaggregator/aggregator.go | Reset | func (a *Aggregator) Reset() {
a.bmu.Lock()
defer a.bmu.Unlock()
for k, buf := range a.buffers {
buf.Close()
delete(a.buffers, k)
}
} | go | func (a *Aggregator) Reset() {
a.bmu.Lock()
defer a.bmu.Unlock()
for k, buf := range a.buffers {
buf.Close()
delete(a.buffers, k)
}
} | [
"func",
"(",
"a",
"*",
"Aggregator",
")",
"Reset",
"(",
")",
"{",
"a",
".",
"bmu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"bmu",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"k",
",",
"buf",
":=",
"range",
"a",
".",
"buffers",
"{",
"buf",
".",
"Close",
"(",
")",
"\n",
"delete",
"(",
"a",
".",
"buffers",
",",
"k",
")",
"\n",
"}",
"\n",
"}"
] | // Reset clears all buffered data and closes subscribers. | [
"Reset",
"clears",
"all",
"buffered",
"data",
"and",
"closes",
"subscribers",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/logaggregator/aggregator.go#L73-L81 | train |
flynn/flynn | logaggregator/aggregator.go | Subscribe | func (a *Aggregator) Subscribe(id string, msgc chan<- *rfc5424.Message, donec <-chan struct{}) {
a.getBuffer(id).Subscribe(msgc, donec)
} | go | func (a *Aggregator) Subscribe(id string, msgc chan<- *rfc5424.Message, donec <-chan struct{}) {
a.getBuffer(id).Subscribe(msgc, donec)
} | [
"func",
"(",
"a",
"*",
"Aggregator",
")",
"Subscribe",
"(",
"id",
"string",
",",
"msgc",
"chan",
"<-",
"*",
"rfc5424",
".",
"Message",
",",
"donec",
"<-",
"chan",
"struct",
"{",
"}",
")",
"{",
"a",
".",
"getBuffer",
"(",
"id",
")",
".",
"Subscribe",
"(",
"msgc",
",",
"donec",
")",
"\n",
"}"
] | // Read adds a subscriber channel for id. | [
"Read",
"adds",
"a",
"subscriber",
"channel",
"for",
"id",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/logaggregator/aggregator.go#L91-L93 | train |
flynn/flynn | gitreceive/server.go | pktLine | func pktLine(w io.Writer, s string) error {
_, err := fmt.Fprintf(w, "%04x%s", len(s)+4, s)
return err
} | go | func pktLine(w io.Writer, s string) error {
_, err := fmt.Fprintf(w, "%04x%s", len(s)+4, s)
return err
} | [
"func",
"pktLine",
"(",
"w",
"io",
".",
"Writer",
",",
"s",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\"",
",",
"len",
"(",
"s",
")",
"+",
"4",
",",
"s",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Git HTTP line protocol functions | [
"Git",
"HTTP",
"line",
"protocol",
"functions"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/gitreceive/server.go#L268-L271 | train |
flynn/flynn | appliance/redis/cmd/flynn-redis-api/main.go | NewHandler | func NewHandler() *Handler {
h := &Handler{
router: httprouter.New(),
Logger: log15.New(),
}
h.router.POST("/clusters", h.servePostCluster)
h.router.DELETE("/clusters", h.serveDeleteCluster)
h.router.GET("/ping", h.serveGetPing)
return h
} | go | func NewHandler() *Handler {
h := &Handler{
router: httprouter.New(),
Logger: log15.New(),
}
h.router.POST("/clusters", h.servePostCluster)
h.router.DELETE("/clusters", h.serveDeleteCluster)
h.router.GET("/ping", h.serveGetPing)
return h
} | [
"func",
"NewHandler",
"(",
")",
"*",
"Handler",
"{",
"h",
":=",
"&",
"Handler",
"{",
"router",
":",
"httprouter",
".",
"New",
"(",
")",
",",
"Logger",
":",
"log15",
".",
"New",
"(",
")",
",",
"}",
"\n",
"h",
".",
"router",
".",
"POST",
"(",
"\"",
"\"",
",",
"h",
".",
"servePostCluster",
")",
"\n",
"h",
".",
"router",
".",
"DELETE",
"(",
"\"",
"\"",
",",
"h",
".",
"serveDeleteCluster",
")",
"\n",
"h",
".",
"router",
".",
"GET",
"(",
"\"",
"\"",
",",
"h",
".",
"serveGetPing",
")",
"\n",
"return",
"h",
"\n",
"}"
] | // NewAPIHandler returns a new instance of APIHandler. | [
"NewAPIHandler",
"returns",
"a",
"new",
"instance",
"of",
"APIHandler",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/redis/cmd/flynn-redis-api/main.go#L169-L178 | train |
flynn/flynn | pkg/cluster/host.go | NewHost | func NewHost(id string, addr string, h *http.Client, tags map[string]string) *Host {
if h == nil {
h = http.DefaultClient
}
if !strings.HasPrefix(addr, "http") {
addr = "http://" + addr
}
return &Host{
id: id,
tags: tags,
c: &httpclient.Client{
ErrNotFound: ErrNotFound,
URL: addr,
HTTP: h,
},
}
} | go | func NewHost(id string, addr string, h *http.Client, tags map[string]string) *Host {
if h == nil {
h = http.DefaultClient
}
if !strings.HasPrefix(addr, "http") {
addr = "http://" + addr
}
return &Host{
id: id,
tags: tags,
c: &httpclient.Client{
ErrNotFound: ErrNotFound,
URL: addr,
HTTP: h,
},
}
} | [
"func",
"NewHost",
"(",
"id",
"string",
",",
"addr",
"string",
",",
"h",
"*",
"http",
".",
"Client",
",",
"tags",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"Host",
"{",
"if",
"h",
"==",
"nil",
"{",
"h",
"=",
"http",
".",
"DefaultClient",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"addr",
",",
"\"",
"\"",
")",
"{",
"addr",
"=",
"\"",
"\"",
"+",
"addr",
"\n",
"}",
"\n",
"return",
"&",
"Host",
"{",
"id",
":",
"id",
",",
"tags",
":",
"tags",
",",
"c",
":",
"&",
"httpclient",
".",
"Client",
"{",
"ErrNotFound",
":",
"ErrNotFound",
",",
"URL",
":",
"addr",
",",
"HTTP",
":",
"h",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewHost creates a new Host that uses client to communicate with it.
// addr is used by Attach. | [
"NewHost",
"creates",
"a",
"new",
"Host",
"that",
"uses",
"client",
"to",
"communicate",
"with",
"it",
".",
"addr",
"is",
"used",
"by",
"Attach",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L30-L46 | train |
flynn/flynn | pkg/cluster/host.go | ListJobs | func (c *Host) ListJobs() (map[string]host.ActiveJob, error) {
var jobs map[string]host.ActiveJob
err := c.c.Get("/host/jobs", &jobs)
return jobs, err
} | go | func (c *Host) ListJobs() (map[string]host.ActiveJob, error) {
var jobs map[string]host.ActiveJob
err := c.c.Get("/host/jobs", &jobs)
return jobs, err
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"ListJobs",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"host",
".",
"ActiveJob",
",",
"error",
")",
"{",
"var",
"jobs",
"map",
"[",
"string",
"]",
"host",
".",
"ActiveJob",
"\n",
"err",
":=",
"c",
".",
"c",
".",
"Get",
"(",
"\"",
"\"",
",",
"&",
"jobs",
")",
"\n",
"return",
"jobs",
",",
"err",
"\n",
"}"
] | // ListJobs lists all jobs on the host. | [
"ListJobs",
"lists",
"all",
"jobs",
"on",
"the",
"host",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L93-L97 | train |
flynn/flynn | pkg/cluster/host.go | AddJob | func (c *Host) AddJob(job *host.Job) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s", job.ID), job, nil)
} | go | func (c *Host) AddJob(job *host.Job) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s", job.ID), job, nil)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"AddJob",
"(",
"job",
"*",
"host",
".",
"Job",
")",
"error",
"{",
"return",
"c",
".",
"c",
".",
"Put",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"job",
".",
"ID",
")",
",",
"job",
",",
"nil",
")",
"\n",
"}"
] | // AddJob runs a job on the host. | [
"AddJob",
"runs",
"a",
"job",
"on",
"the",
"host",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L107-L109 | train |
flynn/flynn | pkg/cluster/host.go | GetJob | func (c *Host) GetJob(id string) (*host.ActiveJob, error) {
var res host.ActiveJob
err := c.c.Get(fmt.Sprintf("/host/jobs/%s", id), &res)
return &res, err
} | go | func (c *Host) GetJob(id string) (*host.ActiveJob, error) {
var res host.ActiveJob
err := c.c.Get(fmt.Sprintf("/host/jobs/%s", id), &res)
return &res, err
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"GetJob",
"(",
"id",
"string",
")",
"(",
"*",
"host",
".",
"ActiveJob",
",",
"error",
")",
"{",
"var",
"res",
"host",
".",
"ActiveJob",
"\n",
"err",
":=",
"c",
".",
"c",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
")",
",",
"&",
"res",
")",
"\n",
"return",
"&",
"res",
",",
"err",
"\n",
"}"
] | // GetJob retrieves job details by ID. | [
"GetJob",
"retrieves",
"job",
"details",
"by",
"ID",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L112-L116 | train |
flynn/flynn | pkg/cluster/host.go | StopJob | func (c *Host) StopJob(id string) error {
return c.c.Delete(fmt.Sprintf("/host/jobs/%s", id))
} | go | func (c *Host) StopJob(id string) error {
return c.c.Delete(fmt.Sprintf("/host/jobs/%s", id))
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"StopJob",
"(",
"id",
"string",
")",
"error",
"{",
"return",
"c",
".",
"c",
".",
"Delete",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
")",
")",
"\n",
"}"
] | // StopJob stops a running job. | [
"StopJob",
"stops",
"a",
"running",
"job",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L119-L121 | train |
flynn/flynn | pkg/cluster/host.go | SignalJob | func (c *Host) SignalJob(id string, sig int) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s/signal/%d", id, sig), nil, nil)
} | go | func (c *Host) SignalJob(id string, sig int) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s/signal/%d", id, sig), nil, nil)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"SignalJob",
"(",
"id",
"string",
",",
"sig",
"int",
")",
"error",
"{",
"return",
"c",
".",
"c",
".",
"Put",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
",",
"sig",
")",
",",
"nil",
",",
"nil",
")",
"\n",
"}"
] | // SignalJob sends a signal to a running job. | [
"SignalJob",
"sends",
"a",
"signal",
"to",
"a",
"running",
"job",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L124-L126 | train |
flynn/flynn | pkg/cluster/host.go | DiscoverdDeregisterJob | func (c *Host) DiscoverdDeregisterJob(id string) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s/discoverd-deregister", id), nil, nil)
} | go | func (c *Host) DiscoverdDeregisterJob(id string) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s/discoverd-deregister", id), nil, nil)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"DiscoverdDeregisterJob",
"(",
"id",
"string",
")",
"error",
"{",
"return",
"c",
".",
"c",
".",
"Put",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
")",
",",
"nil",
",",
"nil",
")",
"\n",
"}"
] | // DiscoverdDeregisterJob requests a job to deregister from service discovery. | [
"DiscoverdDeregisterJob",
"requests",
"a",
"job",
"to",
"deregister",
"from",
"service",
"discovery",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L129-L131 | train |
flynn/flynn | pkg/cluster/host.go | StreamEvents | func (c *Host) StreamEvents(id string, ch chan *host.Event) (stream.Stream, error) {
r := fmt.Sprintf("/host/jobs/%s", id)
if id == "all" {
r = "/host/jobs"
}
return c.c.ResumingStream("GET", r, ch)
} | go | func (c *Host) StreamEvents(id string, ch chan *host.Event) (stream.Stream, error) {
r := fmt.Sprintf("/host/jobs/%s", id)
if id == "all" {
r = "/host/jobs"
}
return c.c.ResumingStream("GET", r, ch)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"StreamEvents",
"(",
"id",
"string",
",",
"ch",
"chan",
"*",
"host",
".",
"Event",
")",
"(",
"stream",
".",
"Stream",
",",
"error",
")",
"{",
"r",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"if",
"id",
"==",
"\"",
"\"",
"{",
"r",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"c",
".",
"c",
".",
"ResumingStream",
"(",
"\"",
"\"",
",",
"r",
",",
"ch",
")",
"\n",
"}"
] | // StreamEvents about job state changes to ch. id may be "all" or a single
// job ID. | [
"StreamEvents",
"about",
"job",
"state",
"changes",
"to",
"ch",
".",
"id",
"may",
"be",
"all",
"or",
"a",
"single",
"job",
"ID",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L135-L141 | train |
flynn/flynn | pkg/cluster/host.go | CreateVolume | func (c *Host) CreateVolume(providerId string, info *volume.Info) error {
return c.c.Post(fmt.Sprintf("/storage/providers/%s/volumes", providerId), info, info)
} | go | func (c *Host) CreateVolume(providerId string, info *volume.Info) error {
return c.c.Post(fmt.Sprintf("/storage/providers/%s/volumes", providerId), info, info)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"CreateVolume",
"(",
"providerId",
"string",
",",
"info",
"*",
"volume",
".",
"Info",
")",
"error",
"{",
"return",
"c",
".",
"c",
".",
"Post",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"providerId",
")",
",",
"info",
",",
"info",
")",
"\n",
"}"
] | // CreateVolume a new volume with the given configuration.
// When in doubt, use a providerId of "default". | [
"CreateVolume",
"a",
"new",
"volume",
"with",
"the",
"given",
"configuration",
".",
"When",
"in",
"doubt",
"use",
"a",
"providerId",
"of",
"default",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L145-L147 | train |
flynn/flynn | pkg/cluster/host.go | GetVolume | func (c *Host) GetVolume(volumeID string) (*volume.Info, error) {
var volume volume.Info
return &volume, c.c.Get(fmt.Sprintf("/storage/volumes/%s", volumeID), &volume)
} | go | func (c *Host) GetVolume(volumeID string) (*volume.Info, error) {
var volume volume.Info
return &volume, c.c.Get(fmt.Sprintf("/storage/volumes/%s", volumeID), &volume)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"GetVolume",
"(",
"volumeID",
"string",
")",
"(",
"*",
"volume",
".",
"Info",
",",
"error",
")",
"{",
"var",
"volume",
"volume",
".",
"Info",
"\n",
"return",
"&",
"volume",
",",
"c",
".",
"c",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"volumeID",
")",
",",
"&",
"volume",
")",
"\n",
"}"
] | // GetVolume gets a volume by ID | [
"GetVolume",
"gets",
"a",
"volume",
"by",
"ID"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L150-L153 | train |
flynn/flynn | pkg/cluster/host.go | ListVolumes | func (c *Host) ListVolumes() ([]*volume.Info, error) {
var volumes []*volume.Info
return volumes, c.c.Get("/storage/volumes", &volumes)
} | go | func (c *Host) ListVolumes() ([]*volume.Info, error) {
var volumes []*volume.Info
return volumes, c.c.Get("/storage/volumes", &volumes)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"ListVolumes",
"(",
")",
"(",
"[",
"]",
"*",
"volume",
".",
"Info",
",",
"error",
")",
"{",
"var",
"volumes",
"[",
"]",
"*",
"volume",
".",
"Info",
"\n",
"return",
"volumes",
",",
"c",
".",
"c",
".",
"Get",
"(",
"\"",
"\"",
",",
"&",
"volumes",
")",
"\n",
"}"
] | // ListVolume returns a list of volume IDs | [
"ListVolume",
"returns",
"a",
"list",
"of",
"volume",
"IDs"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L156-L159 | train |
flynn/flynn | pkg/cluster/host.go | StreamVolumes | func (c *Host) StreamVolumes(ch chan *volume.Event) (stream.Stream, error) {
return c.c.ResumingStream("GET", "/storage/volumes", ch)
} | go | func (c *Host) StreamVolumes(ch chan *volume.Event) (stream.Stream, error) {
return c.c.ResumingStream("GET", "/storage/volumes", ch)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"StreamVolumes",
"(",
"ch",
"chan",
"*",
"volume",
".",
"Event",
")",
"(",
"stream",
".",
"Stream",
",",
"error",
")",
"{",
"return",
"c",
".",
"c",
".",
"ResumingStream",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"ch",
")",
"\n",
"}"
] | // StreamVolumes streams volume events to the given channel | [
"StreamVolumes",
"streams",
"volume",
"events",
"to",
"the",
"given",
"channel"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L162-L164 | train |
flynn/flynn | pkg/cluster/host.go | DestroyVolume | func (c *Host) DestroyVolume(volumeID string) error {
return c.c.Delete(fmt.Sprintf("/storage/volumes/%s", volumeID))
} | go | func (c *Host) DestroyVolume(volumeID string) error {
return c.c.Delete(fmt.Sprintf("/storage/volumes/%s", volumeID))
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"DestroyVolume",
"(",
"volumeID",
"string",
")",
"error",
"{",
"return",
"c",
".",
"c",
".",
"Delete",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"volumeID",
")",
")",
"\n",
"}"
] | // DestroyVolume deletes a volume by ID | [
"DestroyVolume",
"deletes",
"a",
"volume",
"by",
"ID"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L167-L169 | train |
flynn/flynn | pkg/cluster/host.go | CreateSnapshot | func (c *Host) CreateSnapshot(volumeID string) (*volume.Info, error) {
var res volume.Info
err := c.c.Put(fmt.Sprintf("/storage/volumes/%s/snapshot", volumeID), nil, &res)
return &res, err
} | go | func (c *Host) CreateSnapshot(volumeID string) (*volume.Info, error) {
var res volume.Info
err := c.c.Put(fmt.Sprintf("/storage/volumes/%s/snapshot", volumeID), nil, &res)
return &res, err
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"CreateSnapshot",
"(",
"volumeID",
"string",
")",
"(",
"*",
"volume",
".",
"Info",
",",
"error",
")",
"{",
"var",
"res",
"volume",
".",
"Info",
"\n",
"err",
":=",
"c",
".",
"c",
".",
"Put",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"volumeID",
")",
",",
"nil",
",",
"&",
"res",
")",
"\n",
"return",
"&",
"res",
",",
"err",
"\n",
"}"
] | // Create snapshot creates a snapshot of a volume on a host. | [
"Create",
"snapshot",
"creates",
"a",
"snapshot",
"of",
"a",
"volume",
"on",
"a",
"host",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L172-L176 | train |
flynn/flynn | pkg/cluster/host.go | PullSnapshot | func (c *Host) PullSnapshot(receiveVolID string, sourceHostID string, sourceSnapID string) (*volume.Info, error) {
var res volume.Info
pull := volume.PullCoordinate{
HostID: sourceHostID,
SnapshotID: sourceSnapID,
}
err := c.c.Post(fmt.Sprintf("/storage/volumes/%s/pull_snapshot", receiveVolID), pull, &res)
return &res, err
} | go | func (c *Host) PullSnapshot(receiveVolID string, sourceHostID string, sourceSnapID string) (*volume.Info, error) {
var res volume.Info
pull := volume.PullCoordinate{
HostID: sourceHostID,
SnapshotID: sourceSnapID,
}
err := c.c.Post(fmt.Sprintf("/storage/volumes/%s/pull_snapshot", receiveVolID), pull, &res)
return &res, err
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"PullSnapshot",
"(",
"receiveVolID",
"string",
",",
"sourceHostID",
"string",
",",
"sourceSnapID",
"string",
")",
"(",
"*",
"volume",
".",
"Info",
",",
"error",
")",
"{",
"var",
"res",
"volume",
".",
"Info",
"\n",
"pull",
":=",
"volume",
".",
"PullCoordinate",
"{",
"HostID",
":",
"sourceHostID",
",",
"SnapshotID",
":",
"sourceSnapID",
",",
"}",
"\n",
"err",
":=",
"c",
".",
"c",
".",
"Post",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"receiveVolID",
")",
",",
"pull",
",",
"&",
"res",
")",
"\n",
"return",
"&",
"res",
",",
"err",
"\n",
"}"
] | // PullSnapshot requests the host pull a snapshot from another host onto one of
// its volumes. Returns the info for the new snapshot. | [
"PullSnapshot",
"requests",
"the",
"host",
"pull",
"a",
"snapshot",
"from",
"another",
"host",
"onto",
"one",
"of",
"its",
"volumes",
".",
"Returns",
"the",
"info",
"for",
"the",
"new",
"snapshot",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L180-L188 | train |
flynn/flynn | pkg/cluster/host.go | PullImages | func (c *Host) PullImages(repository, configDir, version string, tufDB io.Reader, ch chan *ct.ImagePullInfo) (stream.Stream, error) {
header := http.Header{"Content-Type": {"application/octet-stream"}}
query := make(url.Values)
query.Set("repository", repository)
query.Set("config-dir", configDir)
query.Set("version", version)
path := "/host/pull/images?" + query.Encode()
return c.c.StreamWithHeader("POST", path, header, tufDB, ch)
} | go | func (c *Host) PullImages(repository, configDir, version string, tufDB io.Reader, ch chan *ct.ImagePullInfo) (stream.Stream, error) {
header := http.Header{"Content-Type": {"application/octet-stream"}}
query := make(url.Values)
query.Set("repository", repository)
query.Set("config-dir", configDir)
query.Set("version", version)
path := "/host/pull/images?" + query.Encode()
return c.c.StreamWithHeader("POST", path, header, tufDB, ch)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"PullImages",
"(",
"repository",
",",
"configDir",
",",
"version",
"string",
",",
"tufDB",
"io",
".",
"Reader",
",",
"ch",
"chan",
"*",
"ct",
".",
"ImagePullInfo",
")",
"(",
"stream",
".",
"Stream",
",",
"error",
")",
"{",
"header",
":=",
"http",
".",
"Header",
"{",
"\"",
"\"",
":",
"{",
"\"",
"\"",
"}",
"}",
"\n",
"query",
":=",
"make",
"(",
"url",
".",
"Values",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"repository",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"configDir",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"path",
":=",
"\"",
"\"",
"+",
"query",
".",
"Encode",
"(",
")",
"\n",
"return",
"c",
".",
"c",
".",
"StreamWithHeader",
"(",
"\"",
"\"",
",",
"path",
",",
"header",
",",
"tufDB",
",",
"ch",
")",
"\n",
"}"
] | // PullImages pulls images from a TUF repository using the local TUF file in tufDB | [
"PullImages",
"pulls",
"images",
"from",
"a",
"TUF",
"repository",
"using",
"the",
"local",
"TUF",
"file",
"in",
"tufDB"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L204-L212 | train |
flynn/flynn | pkg/cluster/host.go | PullBinariesAndConfig | func (c *Host) PullBinariesAndConfig(repository, binDir, configDir, version string, tufDB io.Reader) (map[string]string, error) {
query := make(url.Values)
query.Set("repository", repository)
query.Set("bin-dir", binDir)
query.Set("config-dir", configDir)
query.Set("version", version)
path := "/host/pull/binaries?" + query.Encode()
var paths map[string]string
return paths, c.c.Post(path, tufDB, &paths)
} | go | func (c *Host) PullBinariesAndConfig(repository, binDir, configDir, version string, tufDB io.Reader) (map[string]string, error) {
query := make(url.Values)
query.Set("repository", repository)
query.Set("bin-dir", binDir)
query.Set("config-dir", configDir)
query.Set("version", version)
path := "/host/pull/binaries?" + query.Encode()
var paths map[string]string
return paths, c.c.Post(path, tufDB, &paths)
} | [
"func",
"(",
"c",
"*",
"Host",
")",
"PullBinariesAndConfig",
"(",
"repository",
",",
"binDir",
",",
"configDir",
",",
"version",
"string",
",",
"tufDB",
"io",
".",
"Reader",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"query",
":=",
"make",
"(",
"url",
".",
"Values",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"repository",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"binDir",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"configDir",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"path",
":=",
"\"",
"\"",
"+",
"query",
".",
"Encode",
"(",
")",
"\n",
"var",
"paths",
"map",
"[",
"string",
"]",
"string",
"\n",
"return",
"paths",
",",
"c",
".",
"c",
".",
"Post",
"(",
"path",
",",
"tufDB",
",",
"&",
"paths",
")",
"\n",
"}"
] | // PullBinariesAndConfig pulls binaries and config from a TUF repository using the local TUF file in tufDB | [
"PullBinariesAndConfig",
"pulls",
"binaries",
"and",
"config",
"from",
"a",
"TUF",
"repository",
"using",
"the",
"local",
"TUF",
"file",
"in",
"tufDB"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/cluster/host.go#L215-L224 | train |
flynn/flynn | discoverd/server/handler.go | proxyWhitelisted | func proxyWhitelisted(r *http.Request) bool {
for _, url := range []string{"/raft/promote", "/raft/demote", "/shutdown"} {
if strings.HasPrefix(r.URL.Path, url) {
return true
}
}
return false
} | go | func proxyWhitelisted(r *http.Request) bool {
for _, url := range []string{"/raft/promote", "/raft/demote", "/shutdown"} {
if strings.HasPrefix(r.URL.Path, url) {
return true
}
}
return false
} | [
"func",
"proxyWhitelisted",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"for",
"_",
",",
"url",
":=",
"range",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"r",
".",
"URL",
".",
"Path",
",",
"url",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // Whitelisted endpoints won't be proxied. | [
"Whitelisted",
"endpoints",
"won",
"t",
"be",
"proxied",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L115-L122 | train |
flynn/flynn | discoverd/server/handler.go | servePutService | func (h *Handler) servePutService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve the path parameter.
service := params.ByName("service")
if err := ValidServiceName(service); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Read config from the request.
config := &discoverd.ServiceConfig{}
if err := hh.DecodeJSON(r, config); err != nil {
hh.Error(w, err)
return
}
// Add the service to the store.
if err := h.Store.AddService(service, config); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsServiceExists(err) {
hh.ObjectExistsError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) servePutService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve the path parameter.
service := params.ByName("service")
if err := ValidServiceName(service); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Read config from the request.
config := &discoverd.ServiceConfig{}
if err := hh.DecodeJSON(r, config); err != nil {
hh.Error(w, err)
return
}
// Add the service to the store.
if err := h.Store.AddService(service, config); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsServiceExists(err) {
hh.ObjectExistsError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"servePutService",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Retrieve the path parameter.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"ValidServiceName",
"(",
"service",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"ValidationError",
"(",
"w",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Read config from the request.",
"config",
":=",
"&",
"discoverd",
".",
"ServiceConfig",
"{",
"}",
"\n",
"if",
"err",
":=",
"hh",
".",
"DecodeJSON",
"(",
"r",
",",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Add the service to the store.",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"AddService",
"(",
"service",
",",
"config",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"IsServiceExists",
"(",
"err",
")",
"{",
"hh",
".",
"ObjectExistsError",
"(",
"w",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // servePutService creates a service. | [
"servePutService",
"creates",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L151-L177 | train |
flynn/flynn | discoverd/server/handler.go | serveDeleteService | func (h *Handler) serveDeleteService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve the path parameter.
service := params.ByName("service")
if err := ValidServiceName(service); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Delete from the store.
if err := h.Store.RemoveService(params.ByName("service")); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) serveDeleteService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve the path parameter.
service := params.ByName("service")
if err := ValidServiceName(service); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Delete from the store.
if err := h.Store.RemoveService(params.ByName("service")); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveDeleteService",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Retrieve the path parameter.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"ValidServiceName",
"(",
"service",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"ValidationError",
"(",
"w",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Delete from the store.",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"RemoveService",
"(",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"IsNotFound",
"(",
"err",
")",
"{",
"hh",
".",
"ObjectNotFoundError",
"(",
"w",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // serveDeleteService removes a service from the store by name. | [
"serveDeleteService",
"removes",
"a",
"service",
"from",
"the",
"store",
"by",
"name",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L180-L199 | train |
flynn/flynn | discoverd/server/handler.go | serveGetService | func (h *Handler) serveGetService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// This should only return a stream if the Accept header is
// text/event-stream (and return a 406 otherwise), but we
// always return a stream due to Go's http.Client not
// maintaining headers through a redirect.
//
// See https://github.com/flynn/flynn/issues/1880
h.serveStream(w, params, discoverd.EventKindAll)
} | go | func (h *Handler) serveGetService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// This should only return a stream if the Accept header is
// text/event-stream (and return a 406 otherwise), but we
// always return a stream due to Go's http.Client not
// maintaining headers through a redirect.
//
// See https://github.com/flynn/flynn/issues/1880
h.serveStream(w, params, discoverd.EventKindAll)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveGetService",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// This should only return a stream if the Accept header is",
"// text/event-stream (and return a 406 otherwise), but we",
"// always return a stream due to Go's http.Client not",
"// maintaining headers through a redirect.",
"//",
"// See https://github.com/flynn/flynn/issues/1880",
"h",
".",
"serveStream",
"(",
"w",
",",
"params",
",",
"discoverd",
".",
"EventKindAll",
")",
"\n",
"}"
] | // serveGetService streams service events to the client. | [
"serveGetService",
"streams",
"service",
"events",
"to",
"the",
"client",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L202-L210 | train |
flynn/flynn | discoverd/server/handler.go | servePutServiceMeta | func (h *Handler) servePutServiceMeta(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read the metadata from the request.
meta := &discoverd.ServiceMeta{}
if err := hh.DecodeJSON(r, meta); err != nil {
hh.Error(w, err)
return
}
// Update the meta in the store.
if err := h.Store.SetServiceMeta(params.ByName("service"), meta); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
// Write meta back to response.
hh.JSON(w, 200, meta)
} | go | func (h *Handler) servePutServiceMeta(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read the metadata from the request.
meta := &discoverd.ServiceMeta{}
if err := hh.DecodeJSON(r, meta); err != nil {
hh.Error(w, err)
return
}
// Update the meta in the store.
if err := h.Store.SetServiceMeta(params.ByName("service"), meta); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
// Write meta back to response.
hh.JSON(w, 200, meta)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"servePutServiceMeta",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Read the metadata from the request.",
"meta",
":=",
"&",
"discoverd",
".",
"ServiceMeta",
"{",
"}",
"\n",
"if",
"err",
":=",
"hh",
".",
"DecodeJSON",
"(",
"r",
",",
"meta",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Update the meta in the store.",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"SetServiceMeta",
"(",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
",",
"meta",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"IsNotFound",
"(",
"err",
")",
"{",
"hh",
".",
"ObjectNotFoundError",
"(",
"w",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Write meta back to response.",
"hh",
".",
"JSON",
"(",
"w",
",",
"200",
",",
"meta",
")",
"\n",
"}"
] | // serveServiceMeta sets the metadata for a service. | [
"serveServiceMeta",
"sets",
"the",
"metadata",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L213-L235 | train |
flynn/flynn | discoverd/server/handler.go | serveGetServiceMeta | func (h *Handler) serveGetServiceMeta(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read path parameter.
service := params.ByName("service")
// Read meta from the store.
meta := h.Store.ServiceMeta(service)
if meta == nil {
hh.ObjectNotFoundError(w, "service meta not found")
return
}
// Write meta to the response.
hh.JSON(w, 200, meta)
} | go | func (h *Handler) serveGetServiceMeta(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read path parameter.
service := params.ByName("service")
// Read meta from the store.
meta := h.Store.ServiceMeta(service)
if meta == nil {
hh.ObjectNotFoundError(w, "service meta not found")
return
}
// Write meta to the response.
hh.JSON(w, 200, meta)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveGetServiceMeta",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Read path parameter.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n\n",
"// Read meta from the store.",
"meta",
":=",
"h",
".",
"Store",
".",
"ServiceMeta",
"(",
"service",
")",
"\n",
"if",
"meta",
"==",
"nil",
"{",
"hh",
".",
"ObjectNotFoundError",
"(",
"w",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Write meta to the response.",
"hh",
".",
"JSON",
"(",
"w",
",",
"200",
",",
"meta",
")",
"\n",
"}"
] | // serveGetServiceMeta returns the metadata for a service. | [
"serveGetServiceMeta",
"returns",
"the",
"metadata",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L238-L251 | train |
flynn/flynn | discoverd/server/handler.go | servePutInstance | func (h *Handler) servePutInstance(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read path parameter.
service := params.ByName("service")
// Read instance from request.
inst := &discoverd.Instance{}
if err := json.NewDecoder(r.Body).Decode(inst); err != nil {
hh.Error(w, err)
return
}
// Ensure instance is valid.
if err := inst.Valid(); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Add instance to service in the store.
if err := h.Store.AddInstance(service, inst); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) servePutInstance(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read path parameter.
service := params.ByName("service")
// Read instance from request.
inst := &discoverd.Instance{}
if err := json.NewDecoder(r.Body).Decode(inst); err != nil {
hh.Error(w, err)
return
}
// Ensure instance is valid.
if err := inst.Valid(); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Add instance to service in the store.
if err := h.Store.AddInstance(service, inst); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"servePutInstance",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Read path parameter.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n\n",
"// Read instance from request.",
"inst",
":=",
"&",
"discoverd",
".",
"Instance",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
".",
"Body",
")",
".",
"Decode",
"(",
"inst",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Ensure instance is valid.",
"if",
"err",
":=",
"inst",
".",
"Valid",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"ValidationError",
"(",
"w",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Add instance to service in the store.",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"AddInstance",
"(",
"service",
",",
"inst",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"IsNotFound",
"(",
"err",
")",
"{",
"hh",
".",
"ObjectNotFoundError",
"(",
"w",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // servePutInstance adds an instance to a service. | [
"servePutInstance",
"adds",
"an",
"instance",
"to",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L254-L282 | train |
flynn/flynn | discoverd/server/handler.go | serveDeleteInstance | func (h *Handler) serveDeleteInstance(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve path parameters.
service := params.ByName("service")
instanceID := params.ByName("instance_id")
// Remove instance from the store.
if err := h.Store.RemoveInstance(service, instanceID); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) serveDeleteInstance(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve path parameters.
service := params.ByName("service")
instanceID := params.ByName("instance_id")
// Remove instance from the store.
if err := h.Store.RemoveInstance(service, instanceID); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveDeleteInstance",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Retrieve path parameters.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"instanceID",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n\n",
"// Remove instance from the store.",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"RemoveInstance",
"(",
"service",
",",
"instanceID",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"IsNotFound",
"(",
"err",
")",
"{",
"hh",
".",
"ObjectNotFoundError",
"(",
"w",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // serveDeleteInstance removes an instance from the store by name. | [
"serveDeleteInstance",
"removes",
"an",
"instance",
"from",
"the",
"store",
"by",
"name",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L285-L301 | train |
flynn/flynn | discoverd/server/handler.go | serveGetInstances | func (h *Handler) serveGetInstances(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// If the client is requesting a stream, then handle as a stream.
if strings.Contains(r.Header.Get("Accept"), "text/event-stream") {
h.serveStream(w, params, discoverd.EventKindUp|discoverd.EventKindUpdate|discoverd.EventKindDown)
return
}
// Otherwise read instances from the store.
instances, err := h.Store.Instances(params.ByName("service"))
if err != nil {
hh.Error(w, err)
return
} else if instances == nil {
hh.ObjectNotFoundError(w, fmt.Sprintf("service not found: %q", params.ByName("service")))
return
}
// Write instances to the response.
hh.JSON(w, 200, instances)
} | go | func (h *Handler) serveGetInstances(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// If the client is requesting a stream, then handle as a stream.
if strings.Contains(r.Header.Get("Accept"), "text/event-stream") {
h.serveStream(w, params, discoverd.EventKindUp|discoverd.EventKindUpdate|discoverd.EventKindDown)
return
}
// Otherwise read instances from the store.
instances, err := h.Store.Instances(params.ByName("service"))
if err != nil {
hh.Error(w, err)
return
} else if instances == nil {
hh.ObjectNotFoundError(w, fmt.Sprintf("service not found: %q", params.ByName("service")))
return
}
// Write instances to the response.
hh.JSON(w, 200, instances)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveGetInstances",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// If the client is requesting a stream, then handle as a stream.",
"if",
"strings",
".",
"Contains",
"(",
"r",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
")",
"{",
"h",
".",
"serveStream",
"(",
"w",
",",
"params",
",",
"discoverd",
".",
"EventKindUp",
"|",
"discoverd",
".",
"EventKindUpdate",
"|",
"discoverd",
".",
"EventKindDown",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Otherwise read instances from the store.",
"instances",
",",
"err",
":=",
"h",
".",
"Store",
".",
"Instances",
"(",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"instances",
"==",
"nil",
"{",
"hh",
".",
"ObjectNotFoundError",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Write instances to the response.",
"hh",
".",
"JSON",
"(",
"w",
",",
"200",
",",
"instances",
")",
"\n",
"}"
] | // serveGetInstances returns a list of all instances for a service. | [
"serveGetInstances",
"returns",
"a",
"list",
"of",
"all",
"instances",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L304-L323 | train |
flynn/flynn | discoverd/server/handler.go | servePutLeader | func (h *Handler) servePutLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve path parameters.
service := params.ByName("service")
// Check if the service allows manual leader election.
config := h.Store.Config(service)
if config == nil || config.LeaderType != discoverd.LeaderTypeManual {
hh.ValidationError(w, "", "service leader election type is not manual")
return
}
// Read instance from the request.
inst := &discoverd.Instance{}
if err := hh.DecodeJSON(r, inst); err != nil {
hh.Error(w, err)
return
}
// Manually set the leader on the service.
if err := h.Store.SetServiceLeader(service, inst.ID); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) servePutLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve path parameters.
service := params.ByName("service")
// Check if the service allows manual leader election.
config := h.Store.Config(service)
if config == nil || config.LeaderType != discoverd.LeaderTypeManual {
hh.ValidationError(w, "", "service leader election type is not manual")
return
}
// Read instance from the request.
inst := &discoverd.Instance{}
if err := hh.DecodeJSON(r, inst); err != nil {
hh.Error(w, err)
return
}
// Manually set the leader on the service.
if err := h.Store.SetServiceLeader(service, inst.ID); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"servePutLeader",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Retrieve path parameters.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n\n",
"// Check if the service allows manual leader election.",
"config",
":=",
"h",
".",
"Store",
".",
"Config",
"(",
"service",
")",
"\n",
"if",
"config",
"==",
"nil",
"||",
"config",
".",
"LeaderType",
"!=",
"discoverd",
".",
"LeaderTypeManual",
"{",
"hh",
".",
"ValidationError",
"(",
"w",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Read instance from the request.",
"inst",
":=",
"&",
"discoverd",
".",
"Instance",
"{",
"}",
"\n",
"if",
"err",
":=",
"hh",
".",
"DecodeJSON",
"(",
"r",
",",
"inst",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Manually set the leader on the service.",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"SetServiceLeader",
"(",
"service",
",",
"inst",
".",
"ID",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // servePutLeader sets the leader for a service. | [
"servePutLeader",
"sets",
"the",
"leader",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L326-L352 | train |
flynn/flynn | discoverd/server/handler.go | serveGetLeader | func (h *Handler) serveGetLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Process as a stream if that's what the client wants.
if strings.Contains(r.Header.Get("Accept"), "text/event-stream") {
h.serveStream(w, params, discoverd.EventKindLeader)
return
}
// Otherwise retrieve the current leader.
service := params.ByName("service")
leader, err := h.Store.ServiceLeader(service)
if err != nil {
hh.Error(w, err)
return
} else if leader == nil {
hh.ObjectNotFoundError(w, "no leader found")
return
}
// Write leader to the response.
hh.JSON(w, 200, leader)
} | go | func (h *Handler) serveGetLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Process as a stream if that's what the client wants.
if strings.Contains(r.Header.Get("Accept"), "text/event-stream") {
h.serveStream(w, params, discoverd.EventKindLeader)
return
}
// Otherwise retrieve the current leader.
service := params.ByName("service")
leader, err := h.Store.ServiceLeader(service)
if err != nil {
hh.Error(w, err)
return
} else if leader == nil {
hh.ObjectNotFoundError(w, "no leader found")
return
}
// Write leader to the response.
hh.JSON(w, 200, leader)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveGetLeader",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"// Process as a stream if that's what the client wants.",
"if",
"strings",
".",
"Contains",
"(",
"r",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
")",
"{",
"h",
".",
"serveStream",
"(",
"w",
",",
"params",
",",
"discoverd",
".",
"EventKindLeader",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Otherwise retrieve the current leader.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"leader",
",",
"err",
":=",
"h",
".",
"Store",
".",
"ServiceLeader",
"(",
"service",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"leader",
"==",
"nil",
"{",
"hh",
".",
"ObjectNotFoundError",
"(",
"w",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Write leader to the response.",
"hh",
".",
"JSON",
"(",
"w",
",",
"200",
",",
"leader",
")",
"\n",
"}"
] | // serveGetLeader returns the current leader for a service. | [
"serveGetLeader",
"returns",
"the",
"current",
"leader",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L355-L375 | train |
flynn/flynn | discoverd/server/handler.go | servePromote | func (h *Handler) servePromote(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
if err := h.Main.Promote(); err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) servePromote(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
if err := h.Main.Promote(); err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"servePromote",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"if",
"err",
":=",
"h",
".",
"Main",
".",
"Promote",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // servePromote attempts to promote this discoverd peer to a raft peer | [
"servePromote",
"attempts",
"to",
"promote",
"this",
"discoverd",
"peer",
"to",
"a",
"raft",
"peer"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L397-L402 | train |
flynn/flynn | discoverd/server/handler.go | serveDemote | func (h *Handler) serveDemote(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
if err := h.Main.Demote(); err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) serveDemote(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
if err := h.Main.Demote(); err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveDemote",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"if",
"err",
":=",
"h",
".",
"Main",
".",
"Demote",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // serveDemote attempts to demote this peer from a raft peer to a proxy | [
"serveDemote",
"attempts",
"to",
"demote",
"this",
"peer",
"from",
"a",
"raft",
"peer",
"to",
"a",
"proxy"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L405-L410 | train |
flynn/flynn | discoverd/server/handler.go | serveStream | func (h *Handler) serveStream(w http.ResponseWriter, params httprouter.Params, kind discoverd.EventKind) {
// Create a buffered channel to receive events.
ch := make(chan *discoverd.Event, StreamBufferSize)
// Subscribe to events on the store.
service := params.ByName("service")
stream := h.Store.Subscribe(service, true, kind, ch)
// Create and serve an SSE stream.
s := sse.NewStream(w, ch, nil)
s.Serve()
s.Wait()
stream.Close()
// Check if there was an error while closing.
if err := stream.Err(); err != nil {
s.CloseWithError(err)
}
} | go | func (h *Handler) serveStream(w http.ResponseWriter, params httprouter.Params, kind discoverd.EventKind) {
// Create a buffered channel to receive events.
ch := make(chan *discoverd.Event, StreamBufferSize)
// Subscribe to events on the store.
service := params.ByName("service")
stream := h.Store.Subscribe(service, true, kind, ch)
// Create and serve an SSE stream.
s := sse.NewStream(w, ch, nil)
s.Serve()
s.Wait()
stream.Close()
// Check if there was an error while closing.
if err := stream.Err(); err != nil {
s.CloseWithError(err)
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveStream",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"params",
"httprouter",
".",
"Params",
",",
"kind",
"discoverd",
".",
"EventKind",
")",
"{",
"// Create a buffered channel to receive events.",
"ch",
":=",
"make",
"(",
"chan",
"*",
"discoverd",
".",
"Event",
",",
"StreamBufferSize",
")",
"\n\n",
"// Subscribe to events on the store.",
"service",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"stream",
":=",
"h",
".",
"Store",
".",
"Subscribe",
"(",
"service",
",",
"true",
",",
"kind",
",",
"ch",
")",
"\n\n",
"// Create and serve an SSE stream.",
"s",
":=",
"sse",
".",
"NewStream",
"(",
"w",
",",
"ch",
",",
"nil",
")",
"\n",
"s",
".",
"Serve",
"(",
")",
"\n",
"s",
".",
"Wait",
"(",
")",
"\n",
"stream",
".",
"Close",
"(",
")",
"\n\n",
"// Check if there was an error while closing.",
"if",
"err",
":=",
"stream",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"s",
".",
"CloseWithError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // serveStream creates a subscription and streams out events in SSE format. | [
"serveStream",
"creates",
"a",
"subscription",
"and",
"streams",
"out",
"events",
"in",
"SSE",
"format",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L413-L431 | train |
flynn/flynn | discoverd/server/handler.go | serveGetRaftLeader | func (h *Handler) serveGetRaftLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
leader := h.Store.Leader()
if leader == "" {
hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
hh.JSON(w, 200, dt.RaftLeader{Host: h.Store.Leader()})
} | go | func (h *Handler) serveGetRaftLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
leader := h.Store.Leader()
if leader == "" {
hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
hh.JSON(w, 200, dt.RaftLeader{Host: h.Store.Leader()})
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveGetRaftLeader",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"leader",
":=",
"h",
".",
"Store",
".",
"Leader",
"(",
")",
"\n",
"if",
"leader",
"==",
"\"",
"\"",
"{",
"hh",
".",
"ServiceUnavailableError",
"(",
"w",
",",
"ErrNoKnownLeader",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"hh",
".",
"JSON",
"(",
"w",
",",
"200",
",",
"dt",
".",
"RaftLeader",
"{",
"Host",
":",
"h",
".",
"Store",
".",
"Leader",
"(",
")",
"}",
")",
"\n",
"}"
] | // serveGetRaftLeader returns the current raft leader. | [
"serveGetRaftLeader",
"returns",
"the",
"current",
"raft",
"leader",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L434-L442 | train |
flynn/flynn | discoverd/server/handler.go | serveGetRaftPeers | func (h *Handler) serveGetRaftPeers(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peers, err := h.Store.GetPeers()
if err != nil {
hh.Error(w, err)
}
hh.JSON(w, 200, peers)
} | go | func (h *Handler) serveGetRaftPeers(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peers, err := h.Store.GetPeers()
if err != nil {
hh.Error(w, err)
}
hh.JSON(w, 200, peers)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveGetRaftPeers",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"peers",
",",
"err",
":=",
"h",
".",
"Store",
".",
"GetPeers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"}",
"\n\n",
"hh",
".",
"JSON",
"(",
"w",
",",
"200",
",",
"peers",
")",
"\n",
"}"
] | // serveGetRaftPeers returns the current raft peers. | [
"serveGetRaftPeers",
"returns",
"the",
"current",
"raft",
"peers",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L445-L452 | train |
flynn/flynn | discoverd/server/handler.go | servePutRaftPeer | func (h *Handler) servePutRaftPeer(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peer := params.ByName("peer")
if err := h.Store.AddPeer(peer); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
var targetLogIndex dt.TargetLogIndex
targetLogIndex.LastIndex = h.Store.LastIndex()
hh.JSON(w, 200, targetLogIndex)
} | go | func (h *Handler) servePutRaftPeer(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peer := params.ByName("peer")
if err := h.Store.AddPeer(peer); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
var targetLogIndex dt.TargetLogIndex
targetLogIndex.LastIndex = h.Store.LastIndex()
hh.JSON(w, 200, targetLogIndex)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"servePutRaftPeer",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"peer",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"AddPeer",
"(",
"peer",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"var",
"targetLogIndex",
"dt",
".",
"TargetLogIndex",
"\n",
"targetLogIndex",
".",
"LastIndex",
"=",
"h",
".",
"Store",
".",
"LastIndex",
"(",
")",
"\n",
"hh",
".",
"JSON",
"(",
"w",
",",
"200",
",",
"targetLogIndex",
")",
"\n",
"}"
] | // servePutRaftNodes joins a peer to the store cluster. | [
"servePutRaftNodes",
"joins",
"a",
"peer",
"to",
"the",
"store",
"cluster",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L455-L467 | train |
flynn/flynn | discoverd/server/handler.go | serveDeleteRaftPeer | func (h *Handler) serveDeleteRaftPeer(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peer := params.ByName("peer")
if err := h.Store.RemovePeer(peer); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
} | go | func (h *Handler) serveDeleteRaftPeer(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peer := params.ByName("peer")
if err := h.Store.RemovePeer(peer); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"serveDeleteRaftPeer",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"params",
"httprouter",
".",
"Params",
")",
"{",
"peer",
":=",
"params",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"h",
".",
"Store",
".",
"RemovePeer",
"(",
"peer",
")",
";",
"err",
"==",
"ErrNotLeader",
"{",
"h",
".",
"redirectToLeader",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"hh",
".",
"Error",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] | // serveDeleteRaftNodes removes a peer to the store cluster. | [
"serveDeleteRaftNodes",
"removes",
"a",
"peer",
"to",
"the",
"store",
"cluster",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L470-L479 | train |
flynn/flynn | discoverd/server/handler.go | redirectToLeader | func (h *Handler) redirectToLeader(w http.ResponseWriter, r *http.Request) {
// Find the current leader.
leader := h.Store.Leader()
if leader == "" {
hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
redirectToHost(w, r, leader)
} | go | func (h *Handler) redirectToLeader(w http.ResponseWriter, r *http.Request) {
// Find the current leader.
leader := h.Store.Leader()
if leader == "" {
hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
redirectToHost(w, r, leader)
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"redirectToLeader",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"// Find the current leader.",
"leader",
":=",
"h",
".",
"Store",
".",
"Leader",
"(",
")",
"\n",
"if",
"leader",
"==",
"\"",
"\"",
"{",
"hh",
".",
"ServiceUnavailableError",
"(",
"w",
",",
"ErrNoKnownLeader",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"redirectToHost",
"(",
"w",
",",
"r",
",",
"leader",
")",
"\n",
"}"
] | // redirectToLeader redirects the request to the current known leader. | [
"redirectToLeader",
"redirects",
"the",
"request",
"to",
"the",
"current",
"known",
"leader",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/handler.go#L482-L491 | train |
flynn/flynn | discoverd/server/store.go | NewStore | func NewStore(path string) *Store {
return &Store{
path: path,
data: newRaftData(),
subscribers: make(map[string]*list.List),
leaderCh: make(chan bool),
heartbeats: make(map[instanceKey]time.Time),
closing: make(chan struct{}),
HeartbeatTimeout: 1000 * time.Millisecond,
ElectionTimeout: 1000 * time.Millisecond,
LeaderLeaseTimeout: 500 * time.Millisecond,
CommitTimeout: 50 * time.Millisecond,
InstanceTTL: DefaultInstanceTTL,
ExpiryCheckInterval: DefaultExpiryCheckInterval,
LogOutput: os.Stderr,
Now: time.Now,
}
} | go | func NewStore(path string) *Store {
return &Store{
path: path,
data: newRaftData(),
subscribers: make(map[string]*list.List),
leaderCh: make(chan bool),
heartbeats: make(map[instanceKey]time.Time),
closing: make(chan struct{}),
HeartbeatTimeout: 1000 * time.Millisecond,
ElectionTimeout: 1000 * time.Millisecond,
LeaderLeaseTimeout: 500 * time.Millisecond,
CommitTimeout: 50 * time.Millisecond,
InstanceTTL: DefaultInstanceTTL,
ExpiryCheckInterval: DefaultExpiryCheckInterval,
LogOutput: os.Stderr,
Now: time.Now,
}
} | [
"func",
"NewStore",
"(",
"path",
"string",
")",
"*",
"Store",
"{",
"return",
"&",
"Store",
"{",
"path",
":",
"path",
",",
"data",
":",
"newRaftData",
"(",
")",
",",
"subscribers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"list",
".",
"List",
")",
",",
"leaderCh",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"heartbeats",
":",
"make",
"(",
"map",
"[",
"instanceKey",
"]",
"time",
".",
"Time",
")",
",",
"closing",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"HeartbeatTimeout",
":",
"1000",
"*",
"time",
".",
"Millisecond",
",",
"ElectionTimeout",
":",
"1000",
"*",
"time",
".",
"Millisecond",
",",
"LeaderLeaseTimeout",
":",
"500",
"*",
"time",
".",
"Millisecond",
",",
"CommitTimeout",
":",
"50",
"*",
"time",
".",
"Millisecond",
",",
"InstanceTTL",
":",
"DefaultInstanceTTL",
",",
"ExpiryCheckInterval",
":",
"DefaultExpiryCheckInterval",
",",
"LogOutput",
":",
"os",
".",
"Stderr",
",",
"Now",
":",
"time",
".",
"Now",
",",
"}",
"\n",
"}"
] | // NewStore returns an instance of Store. | [
"NewStore",
"returns",
"an",
"instance",
"of",
"Store",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L115-L137 | train |
flynn/flynn | discoverd/server/store.go | Open | func (s *Store) Open() error {
s.mu.Lock()
defer s.mu.Unlock()
// Set up logging.
s.logger = log.New(s.LogOutput, "[discoverd] ", log.LstdFlags)
// Require listener & advertise address.
if s.Listener == nil {
return ErrListenerRequired
} else if s.Advertise == nil {
return ErrAdvertiseRequired
}
// Create root directory.
if err := os.MkdirAll(s.path, 0777); err != nil {
return err
}
// Create raft configuration.
config := raft.DefaultConfig()
config.HeartbeatTimeout = s.HeartbeatTimeout
config.ElectionTimeout = s.ElectionTimeout
config.LeaderLeaseTimeout = s.LeaderLeaseTimeout
config.CommitTimeout = s.CommitTimeout
config.LogOutput = s.LogOutput
config.EnableSingleNode = s.EnableSingleNode
config.ShutdownOnRemove = false
// Create multiplexing transport layer.
raftLayer := newRaftLayer(s.Listener, s.Advertise)
// Begin listening to TCP port.
s.transport = raft.NewNetworkTransport(raftLayer, 3, 10*time.Second, os.Stderr)
// Setup storage layers.
s.peerStore = raft.NewJSONPeers(s.path, s.transport)
stableStore, err := raftboltdb.NewBoltStore(filepath.Join(s.path, "raft.db"))
if err != nil {
return fmt.Errorf("stable store: %s", err)
}
s.stableStore = stableStore
// Wrap the store in a LogCache to improve performance
cacheStore, err := raft.NewLogCache(512, stableStore)
if err != nil {
stableStore.Close()
return fmt.Errorf("log cache: %s", err)
}
// Create the snapshot store.
ss, err := raft.NewFileSnapshotStore(s.path, 2, os.Stderr)
if err != nil {
return fmt.Errorf("snapshot store: %s", err)
}
// Create raft log.
//
// The mutex must be unlocked as initializing the raft store may
// call back into methods which acquire the lock (e.g. Restore)
s.mu.Unlock()
r, err := raft.NewRaft(config, s, cacheStore, stableStore, ss, s.peerStore, s.transport)
s.mu.Lock()
if err != nil {
return fmt.Errorf("raft: %s", err)
}
// make sure the store was not closed whilst the mutex was unlocked
select {
case <-s.closing:
return ErrShutdown
default:
}
s.raft = r
// Start goroutine to monitor leadership changes.
s.wg.Add(1)
go s.monitorLeaderCh()
// Start goroutine to check for instance expiry.
s.wg.Add(1)
go s.expirer()
return nil
} | go | func (s *Store) Open() error {
s.mu.Lock()
defer s.mu.Unlock()
// Set up logging.
s.logger = log.New(s.LogOutput, "[discoverd] ", log.LstdFlags)
// Require listener & advertise address.
if s.Listener == nil {
return ErrListenerRequired
} else if s.Advertise == nil {
return ErrAdvertiseRequired
}
// Create root directory.
if err := os.MkdirAll(s.path, 0777); err != nil {
return err
}
// Create raft configuration.
config := raft.DefaultConfig()
config.HeartbeatTimeout = s.HeartbeatTimeout
config.ElectionTimeout = s.ElectionTimeout
config.LeaderLeaseTimeout = s.LeaderLeaseTimeout
config.CommitTimeout = s.CommitTimeout
config.LogOutput = s.LogOutput
config.EnableSingleNode = s.EnableSingleNode
config.ShutdownOnRemove = false
// Create multiplexing transport layer.
raftLayer := newRaftLayer(s.Listener, s.Advertise)
// Begin listening to TCP port.
s.transport = raft.NewNetworkTransport(raftLayer, 3, 10*time.Second, os.Stderr)
// Setup storage layers.
s.peerStore = raft.NewJSONPeers(s.path, s.transport)
stableStore, err := raftboltdb.NewBoltStore(filepath.Join(s.path, "raft.db"))
if err != nil {
return fmt.Errorf("stable store: %s", err)
}
s.stableStore = stableStore
// Wrap the store in a LogCache to improve performance
cacheStore, err := raft.NewLogCache(512, stableStore)
if err != nil {
stableStore.Close()
return fmt.Errorf("log cache: %s", err)
}
// Create the snapshot store.
ss, err := raft.NewFileSnapshotStore(s.path, 2, os.Stderr)
if err != nil {
return fmt.Errorf("snapshot store: %s", err)
}
// Create raft log.
//
// The mutex must be unlocked as initializing the raft store may
// call back into methods which acquire the lock (e.g. Restore)
s.mu.Unlock()
r, err := raft.NewRaft(config, s, cacheStore, stableStore, ss, s.peerStore, s.transport)
s.mu.Lock()
if err != nil {
return fmt.Errorf("raft: %s", err)
}
// make sure the store was not closed whilst the mutex was unlocked
select {
case <-s.closing:
return ErrShutdown
default:
}
s.raft = r
// Start goroutine to monitor leadership changes.
s.wg.Add(1)
go s.monitorLeaderCh()
// Start goroutine to check for instance expiry.
s.wg.Add(1)
go s.expirer()
return nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Open",
"(",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// Set up logging.",
"s",
".",
"logger",
"=",
"log",
".",
"New",
"(",
"s",
".",
"LogOutput",
",",
"\"",
"\"",
",",
"log",
".",
"LstdFlags",
")",
"\n\n",
"// Require listener & advertise address.",
"if",
"s",
".",
"Listener",
"==",
"nil",
"{",
"return",
"ErrListenerRequired",
"\n",
"}",
"else",
"if",
"s",
".",
"Advertise",
"==",
"nil",
"{",
"return",
"ErrAdvertiseRequired",
"\n",
"}",
"\n\n",
"// Create root directory.",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"s",
".",
"path",
",",
"0777",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Create raft configuration.",
"config",
":=",
"raft",
".",
"DefaultConfig",
"(",
")",
"\n",
"config",
".",
"HeartbeatTimeout",
"=",
"s",
".",
"HeartbeatTimeout",
"\n",
"config",
".",
"ElectionTimeout",
"=",
"s",
".",
"ElectionTimeout",
"\n",
"config",
".",
"LeaderLeaseTimeout",
"=",
"s",
".",
"LeaderLeaseTimeout",
"\n",
"config",
".",
"CommitTimeout",
"=",
"s",
".",
"CommitTimeout",
"\n",
"config",
".",
"LogOutput",
"=",
"s",
".",
"LogOutput",
"\n",
"config",
".",
"EnableSingleNode",
"=",
"s",
".",
"EnableSingleNode",
"\n",
"config",
".",
"ShutdownOnRemove",
"=",
"false",
"\n\n",
"// Create multiplexing transport layer.",
"raftLayer",
":=",
"newRaftLayer",
"(",
"s",
".",
"Listener",
",",
"s",
".",
"Advertise",
")",
"\n\n",
"// Begin listening to TCP port.",
"s",
".",
"transport",
"=",
"raft",
".",
"NewNetworkTransport",
"(",
"raftLayer",
",",
"3",
",",
"10",
"*",
"time",
".",
"Second",
",",
"os",
".",
"Stderr",
")",
"\n\n",
"// Setup storage layers.",
"s",
".",
"peerStore",
"=",
"raft",
".",
"NewJSONPeers",
"(",
"s",
".",
"path",
",",
"s",
".",
"transport",
")",
"\n",
"stableStore",
",",
"err",
":=",
"raftboltdb",
".",
"NewBoltStore",
"(",
"filepath",
".",
"Join",
"(",
"s",
".",
"path",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"stableStore",
"=",
"stableStore",
"\n\n",
"// Wrap the store in a LogCache to improve performance",
"cacheStore",
",",
"err",
":=",
"raft",
".",
"NewLogCache",
"(",
"512",
",",
"stableStore",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"stableStore",
".",
"Close",
"(",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Create the snapshot store.",
"ss",
",",
"err",
":=",
"raft",
".",
"NewFileSnapshotStore",
"(",
"s",
".",
"path",
",",
"2",
",",
"os",
".",
"Stderr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Create raft log.",
"//",
"// The mutex must be unlocked as initializing the raft store may",
"// call back into methods which acquire the lock (e.g. Restore)",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"r",
",",
"err",
":=",
"raft",
".",
"NewRaft",
"(",
"config",
",",
"s",
",",
"cacheStore",
",",
"stableStore",
",",
"ss",
",",
"s",
".",
"peerStore",
",",
"s",
".",
"transport",
")",
"\n",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// make sure the store was not closed whilst the mutex was unlocked",
"select",
"{",
"case",
"<-",
"s",
".",
"closing",
":",
"return",
"ErrShutdown",
"\n",
"default",
":",
"}",
"\n\n",
"s",
".",
"raft",
"=",
"r",
"\n\n",
"// Start goroutine to monitor leadership changes.",
"s",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"s",
".",
"monitorLeaderCh",
"(",
")",
"\n\n",
"// Start goroutine to check for instance expiry.",
"s",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"s",
".",
"expirer",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Open starts the raft consensus and opens the store. | [
"Open",
"starts",
"the",
"raft",
"consensus",
"and",
"opens",
"the",
"store",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L143-L228 | train |
flynn/flynn | discoverd/server/store.go | Close | func (s *Store) Close() (lastIdx uint64, err error) {
// Notify goroutines of closing and wait until they finish.
close(s.closing)
s.wg.Wait()
s.mu.Lock()
defer s.mu.Unlock()
for _, l := range s.subscribers {
for el := l.Front(); el != nil; el = el.Next() {
go el.Value.(*subscription).Close()
}
}
if s.raft != nil {
s.raft.Shutdown().Error()
lastIdx = s.raft.LastIndex()
s.raft = nil
}
if s.transport != nil {
s.transport.Close()
s.transport = nil
}
if s.stableStore != nil {
s.stableStore.Close()
s.stableStore = nil
}
return lastIdx, nil
} | go | func (s *Store) Close() (lastIdx uint64, err error) {
// Notify goroutines of closing and wait until they finish.
close(s.closing)
s.wg.Wait()
s.mu.Lock()
defer s.mu.Unlock()
for _, l := range s.subscribers {
for el := l.Front(); el != nil; el = el.Next() {
go el.Value.(*subscription).Close()
}
}
if s.raft != nil {
s.raft.Shutdown().Error()
lastIdx = s.raft.LastIndex()
s.raft = nil
}
if s.transport != nil {
s.transport.Close()
s.transport = nil
}
if s.stableStore != nil {
s.stableStore.Close()
s.stableStore = nil
}
return lastIdx, nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Close",
"(",
")",
"(",
"lastIdx",
"uint64",
",",
"err",
"error",
")",
"{",
"// Notify goroutines of closing and wait until they finish.",
"close",
"(",
"s",
".",
"closing",
")",
"\n",
"s",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"l",
":=",
"range",
"s",
".",
"subscribers",
"{",
"for",
"el",
":=",
"l",
".",
"Front",
"(",
")",
";",
"el",
"!=",
"nil",
";",
"el",
"=",
"el",
".",
"Next",
"(",
")",
"{",
"go",
"el",
".",
"Value",
".",
"(",
"*",
"subscription",
")",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"s",
".",
"raft",
"!=",
"nil",
"{",
"s",
".",
"raft",
".",
"Shutdown",
"(",
")",
".",
"Error",
"(",
")",
"\n",
"lastIdx",
"=",
"s",
".",
"raft",
".",
"LastIndex",
"(",
")",
"\n",
"s",
".",
"raft",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"s",
".",
"transport",
"!=",
"nil",
"{",
"s",
".",
"transport",
".",
"Close",
"(",
")",
"\n",
"s",
".",
"transport",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"s",
".",
"stableStore",
"!=",
"nil",
"{",
"s",
".",
"stableStore",
".",
"Close",
"(",
")",
"\n",
"s",
".",
"stableStore",
"=",
"nil",
"\n",
"}",
"\n\n",
"return",
"lastIdx",
",",
"nil",
"\n",
"}"
] | // Close shuts down the transport and store. | [
"Close",
"shuts",
"down",
"the",
"transport",
"and",
"store",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L244-L271 | train |
flynn/flynn | discoverd/server/store.go | Leader | func (s *Store) Leader() string {
if s.raft == nil {
return ""
}
return s.raft.Leader()
} | go | func (s *Store) Leader() string {
if s.raft == nil {
return ""
}
return s.raft.Leader()
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Leader",
"(",
")",
"string",
"{",
"if",
"s",
".",
"raft",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"s",
".",
"raft",
".",
"Leader",
"(",
")",
"\n",
"}"
] | // Leader returns the host of the current leader. Returns empty string if there is no leader.
// Panic if called before store is opened. | [
"Leader",
"returns",
"the",
"host",
"of",
"the",
"current",
"leader",
".",
"Returns",
"empty",
"string",
"if",
"there",
"is",
"no",
"leader",
".",
"Panic",
"if",
"called",
"before",
"store",
"is",
"opened",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L275-L280 | train |
flynn/flynn | discoverd/server/store.go | monitorLeaderCh | func (s *Store) monitorLeaderCh() {
defer s.wg.Done()
incoming := s.raft.LeaderCh()
for {
select {
case <-s.closing:
return
case isLeader, ok := <-incoming:
// Update leader time and clear heartbeats.
s.mu.Lock()
if isLeader {
s.leaderTime = time.Now()
} else {
s.leaderTime = time.Time{}
}
s.heartbeats = make(map[instanceKey]time.Time)
s.mu.Unlock()
// If the incoming channel closed then close our leader channel.
if !ok {
close(s.leaderCh)
return
}
// Resend value to store's leader channel.
select {
case s.leaderCh <- isLeader:
default:
}
}
}
} | go | func (s *Store) monitorLeaderCh() {
defer s.wg.Done()
incoming := s.raft.LeaderCh()
for {
select {
case <-s.closing:
return
case isLeader, ok := <-incoming:
// Update leader time and clear heartbeats.
s.mu.Lock()
if isLeader {
s.leaderTime = time.Now()
} else {
s.leaderTime = time.Time{}
}
s.heartbeats = make(map[instanceKey]time.Time)
s.mu.Unlock()
// If the incoming channel closed then close our leader channel.
if !ok {
close(s.leaderCh)
return
}
// Resend value to store's leader channel.
select {
case s.leaderCh <- isLeader:
default:
}
}
}
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"monitorLeaderCh",
"(",
")",
"{",
"defer",
"s",
".",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"incoming",
":=",
"s",
".",
"raft",
".",
"LeaderCh",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"s",
".",
"closing",
":",
"return",
"\n",
"case",
"isLeader",
",",
"ok",
":=",
"<-",
"incoming",
":",
"// Update leader time and clear heartbeats.",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"isLeader",
"{",
"s",
".",
"leaderTime",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"leaderTime",
"=",
"time",
".",
"Time",
"{",
"}",
"\n",
"}",
"\n",
"s",
".",
"heartbeats",
"=",
"make",
"(",
"map",
"[",
"instanceKey",
"]",
"time",
".",
"Time",
")",
"\n",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// If the incoming channel closed then close our leader channel.",
"if",
"!",
"ok",
"{",
"close",
"(",
"s",
".",
"leaderCh",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Resend value to store's leader channel.",
"select",
"{",
"case",
"s",
".",
"leaderCh",
"<-",
"isLeader",
":",
"default",
":",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // monitors the raft leader channel, updates the leader time, and resends to a local channel. | [
"monitors",
"the",
"raft",
"leader",
"channel",
"updates",
"the",
"leader",
"time",
"and",
"resends",
"to",
"a",
"local",
"channel",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L283-L315 | train |
flynn/flynn | discoverd/server/store.go | LeaderCh | func (s *Store) LeaderCh() <-chan bool {
if s.raft == nil {
ch := make(chan bool, 1)
ch <- true
return ch
}
return s.leaderCh
} | go | func (s *Store) LeaderCh() <-chan bool {
if s.raft == nil {
ch := make(chan bool, 1)
ch <- true
return ch
}
return s.leaderCh
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"LeaderCh",
"(",
")",
"<-",
"chan",
"bool",
"{",
"if",
"s",
".",
"raft",
"==",
"nil",
"{",
"ch",
":=",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
"\n",
"ch",
"<-",
"true",
"\n",
"return",
"ch",
"\n",
"}",
"\n",
"return",
"s",
".",
"leaderCh",
"\n",
"}"
] | // LeaderCh returns a channel that signals leadership change.
// Panic if called before store is opened. | [
"LeaderCh",
"returns",
"a",
"channel",
"that",
"signals",
"leadership",
"change",
".",
"Panic",
"if",
"called",
"before",
"store",
"is",
"opened",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L319-L326 | train |
flynn/flynn | discoverd/server/store.go | AddPeer | func (s *Store) AddPeer(peer string) error {
err := s.raft.AddPeer(peer).Error()
if err == raft.ErrNotLeader {
err = ErrNotLeader
} else if err == raft.ErrKnownPeer {
return nil
}
return err
} | go | func (s *Store) AddPeer(peer string) error {
err := s.raft.AddPeer(peer).Error()
if err == raft.ErrNotLeader {
err = ErrNotLeader
} else if err == raft.ErrKnownPeer {
return nil
}
return err
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"AddPeer",
"(",
"peer",
"string",
")",
"error",
"{",
"err",
":=",
"s",
".",
"raft",
".",
"AddPeer",
"(",
"peer",
")",
".",
"Error",
"(",
")",
"\n",
"if",
"err",
"==",
"raft",
".",
"ErrNotLeader",
"{",
"err",
"=",
"ErrNotLeader",
"\n",
"}",
"else",
"if",
"err",
"==",
"raft",
".",
"ErrKnownPeer",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // AddPeer adds a peer to the raft cluster. Panic if store is not open yet. | [
"AddPeer",
"adds",
"a",
"peer",
"to",
"the",
"raft",
"cluster",
".",
"Panic",
"if",
"store",
"is",
"not",
"open",
"yet",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L332-L340 | train |
flynn/flynn | discoverd/server/store.go | RemovePeer | func (s *Store) RemovePeer(peer string) error {
err := s.raft.RemovePeer(peer).Error()
if err == raft.ErrNotLeader {
err = ErrNotLeader
} else if err == raft.ErrUnknownPeer {
return nil
}
return err
} | go | func (s *Store) RemovePeer(peer string) error {
err := s.raft.RemovePeer(peer).Error()
if err == raft.ErrNotLeader {
err = ErrNotLeader
} else if err == raft.ErrUnknownPeer {
return nil
}
return err
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"RemovePeer",
"(",
"peer",
"string",
")",
"error",
"{",
"err",
":=",
"s",
".",
"raft",
".",
"RemovePeer",
"(",
"peer",
")",
".",
"Error",
"(",
")",
"\n",
"if",
"err",
"==",
"raft",
".",
"ErrNotLeader",
"{",
"err",
"=",
"ErrNotLeader",
"\n",
"}",
"else",
"if",
"err",
"==",
"raft",
".",
"ErrUnknownPeer",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // RemovePeer removes a peer from the raft cluster. Panic if store is not open yet. | [
"RemovePeer",
"removes",
"a",
"peer",
"from",
"the",
"raft",
"cluster",
".",
"Panic",
"if",
"store",
"is",
"not",
"open",
"yet",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L343-L351 | train |
flynn/flynn | discoverd/server/store.go | SetPeers | func (s *Store) SetPeers(peers []string) error {
return s.raft.SetPeers(peers).Error()
} | go | func (s *Store) SetPeers(peers []string) error {
return s.raft.SetPeers(peers).Error()
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"SetPeers",
"(",
"peers",
"[",
"]",
"string",
")",
"error",
"{",
"return",
"s",
".",
"raft",
".",
"SetPeers",
"(",
"peers",
")",
".",
"Error",
"(",
")",
"\n",
"}"
] | // SetPeers sets a list of peers in the raft cluster. Panic if store is not open yet. | [
"SetPeers",
"sets",
"a",
"list",
"of",
"peers",
"in",
"the",
"raft",
"cluster",
".",
"Panic",
"if",
"store",
"is",
"not",
"open",
"yet",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L359-L361 | train |
flynn/flynn | discoverd/server/store.go | ServiceNames | func (s *Store) ServiceNames() []string {
s.mu.RLock()
defer s.mu.RUnlock()
var a []string
for name := range s.data.Services {
a = append(a, name)
}
sort.Strings(a)
return a
} | go | func (s *Store) ServiceNames() []string {
s.mu.RLock()
defer s.mu.RUnlock()
var a []string
for name := range s.data.Services {
a = append(a, name)
}
sort.Strings(a)
return a
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"ServiceNames",
"(",
")",
"[",
"]",
"string",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"var",
"a",
"[",
"]",
"string",
"\n",
"for",
"name",
":=",
"range",
"s",
".",
"data",
".",
"Services",
"{",
"a",
"=",
"append",
"(",
"a",
",",
"name",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"a",
")",
"\n\n",
"return",
"a",
"\n",
"}"
] | // ServiceNames returns a sorted list of existing service names. | [
"ServiceNames",
"returns",
"a",
"sorted",
"list",
"of",
"existing",
"service",
"names",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L364-L375 | train |
flynn/flynn | discoverd/server/store.go | AddService | func (s *Store) AddService(service string, config *discoverd.ServiceConfig) error {
if config == nil {
config = DefaultServiceConfig
}
// Serialize command.
cmd, err := json.Marshal(&addServiceCommand{
Service: service,
Config: config,
})
if err != nil {
return err
}
if _, err := s.raftApply(addServiceCommandType, cmd); err != nil {
return err
}
return err
} | go | func (s *Store) AddService(service string, config *discoverd.ServiceConfig) error {
if config == nil {
config = DefaultServiceConfig
}
// Serialize command.
cmd, err := json.Marshal(&addServiceCommand{
Service: service,
Config: config,
})
if err != nil {
return err
}
if _, err := s.raftApply(addServiceCommandType, cmd); err != nil {
return err
}
return err
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"AddService",
"(",
"service",
"string",
",",
"config",
"*",
"discoverd",
".",
"ServiceConfig",
")",
"error",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"DefaultServiceConfig",
"\n",
"}",
"\n\n",
"// Serialize command.",
"cmd",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"addServiceCommand",
"{",
"Service",
":",
"service",
",",
"Config",
":",
"config",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"s",
".",
"raftApply",
"(",
"addServiceCommandType",
",",
"cmd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // AddService creates a service with a configuration.
// Returns an error if the service already exists. | [
"AddService",
"creates",
"a",
"service",
"with",
"a",
"configuration",
".",
"Returns",
"an",
"error",
"if",
"the",
"service",
"already",
"exists",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L379-L397 | train |
flynn/flynn | discoverd/server/store.go | Config | func (s *Store) Config(service string) *discoverd.ServiceConfig {
s.mu.RLock()
defer s.mu.RUnlock()
return s.data.Services[service]
} | go | func (s *Store) Config(service string) *discoverd.ServiceConfig {
s.mu.RLock()
defer s.mu.RUnlock()
return s.data.Services[service]
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Config",
"(",
"service",
"string",
")",
"*",
"discoverd",
".",
"ServiceConfig",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"s",
".",
"data",
".",
"Services",
"[",
"service",
"]",
"\n",
"}"
] | // Config returns the configuration for service. | [
"Config",
"returns",
"the",
"configuration",
"for",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L417-L421 | train |
flynn/flynn | discoverd/server/store.go | RemoveService | func (s *Store) RemoveService(service string) error {
// Serialize command.
cmd, err := json.Marshal(&removeServiceCommand{Service: service})
if err != nil {
return err
}
if _, err := s.raftApply(removeServiceCommandType, cmd); err != nil {
return err
}
return nil
} | go | func (s *Store) RemoveService(service string) error {
// Serialize command.
cmd, err := json.Marshal(&removeServiceCommand{Service: service})
if err != nil {
return err
}
if _, err := s.raftApply(removeServiceCommandType, cmd); err != nil {
return err
}
return nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"RemoveService",
"(",
"service",
"string",
")",
"error",
"{",
"// Serialize command.",
"cmd",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"removeServiceCommand",
"{",
"Service",
":",
"service",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"s",
".",
"raftApply",
"(",
"removeServiceCommandType",
",",
"cmd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // RemoveService deletes the service from the store. | [
"RemoveService",
"deletes",
"the",
"service",
"from",
"the",
"store",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L424-L435 | train |
flynn/flynn | discoverd/server/store.go | Instances | func (s *Store) Instances(service string) ([]*discoverd.Instance, error) {
s.mu.Lock()
defer s.mu.Unlock()
return s.instances(service), nil
} | go | func (s *Store) Instances(service string) ([]*discoverd.Instance, error) {
s.mu.Lock()
defer s.mu.Unlock()
return s.instances(service), nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Instances",
"(",
"service",
"string",
")",
"(",
"[",
"]",
"*",
"discoverd",
".",
"Instance",
",",
"error",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"s",
".",
"instances",
"(",
"service",
")",
",",
"nil",
"\n",
"}"
] | // Instances returns a list of instances for service. | [
"Instances",
"returns",
"a",
"list",
"of",
"instances",
"for",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L467-L471 | train |
flynn/flynn | discoverd/server/store.go | ServiceMeta | func (s *Store) ServiceMeta(service string) *discoverd.ServiceMeta {
s.mu.Lock()
defer s.mu.Unlock()
return s.serviceMeta(service)
} | go | func (s *Store) ServiceMeta(service string) *discoverd.ServiceMeta {
s.mu.Lock()
defer s.mu.Unlock()
return s.serviceMeta(service)
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"ServiceMeta",
"(",
"service",
"string",
")",
"*",
"discoverd",
".",
"ServiceMeta",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"s",
".",
"serviceMeta",
"(",
"service",
")",
"\n",
"}"
] | // ServiceMeta returns the meta data for a service. | [
"ServiceMeta",
"returns",
"the",
"meta",
"data",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L620-L624 | train |
flynn/flynn | discoverd/server/store.go | SetServiceLeader | func (s *Store) SetServiceLeader(service, id string) error {
// Serialize command.
cmd, err := json.Marshal(&setLeaderCommand{
Service: service,
ID: id,
})
if err != nil {
return err
}
if _, err := s.raftApply(setLeaderCommandType, cmd); err != nil {
return err
}
return nil
} | go | func (s *Store) SetServiceLeader(service, id string) error {
// Serialize command.
cmd, err := json.Marshal(&setLeaderCommand{
Service: service,
ID: id,
})
if err != nil {
return err
}
if _, err := s.raftApply(setLeaderCommandType, cmd); err != nil {
return err
}
return nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"SetServiceLeader",
"(",
"service",
",",
"id",
"string",
")",
"error",
"{",
"// Serialize command.",
"cmd",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"setLeaderCommand",
"{",
"Service",
":",
"service",
",",
"ID",
":",
"id",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"s",
".",
"raftApply",
"(",
"setLeaderCommandType",
",",
"cmd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetServiceLeader manually sets the leader for a service. | [
"SetServiceLeader",
"manually",
"sets",
"the",
"leader",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L709-L723 | train |
flynn/flynn | discoverd/server/store.go | invalidateServiceLeader | func (s *Store) invalidateServiceLeader(service string) {
// Retrieve service config.
c := s.data.Services[service]
// Ignore if there is no config or the leader is manually elected.
if c == nil || c.LeaderType == discoverd.LeaderTypeManual {
return
}
// Retrieve current leader ID.
prevLeaderID := s.data.Leaders[service]
// Find the oldest, non-expired instance.
var leader *discoverd.Instance
for _, inst := range s.data.Instances[service] {
if leader == nil || inst.Index < leader.Index {
leader = inst
}
}
// Retrieve the leader ID.
var leaderID string
if leader != nil {
leaderID = leader.ID
}
// Set leader.
s.data.Leaders[service] = leaderID
// Broadcast event.
if prevLeaderID != leaderID {
var inst *discoverd.Instance
if s.data.Instances[service] != nil {
inst = s.data.Instances[service][leaderID]
}
s.broadcast(&discoverd.Event{
Service: service,
Kind: discoverd.EventKindLeader,
Instance: inst,
})
}
} | go | func (s *Store) invalidateServiceLeader(service string) {
// Retrieve service config.
c := s.data.Services[service]
// Ignore if there is no config or the leader is manually elected.
if c == nil || c.LeaderType == discoverd.LeaderTypeManual {
return
}
// Retrieve current leader ID.
prevLeaderID := s.data.Leaders[service]
// Find the oldest, non-expired instance.
var leader *discoverd.Instance
for _, inst := range s.data.Instances[service] {
if leader == nil || inst.Index < leader.Index {
leader = inst
}
}
// Retrieve the leader ID.
var leaderID string
if leader != nil {
leaderID = leader.ID
}
// Set leader.
s.data.Leaders[service] = leaderID
// Broadcast event.
if prevLeaderID != leaderID {
var inst *discoverd.Instance
if s.data.Instances[service] != nil {
inst = s.data.Instances[service][leaderID]
}
s.broadcast(&discoverd.Event{
Service: service,
Kind: discoverd.EventKindLeader,
Instance: inst,
})
}
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"invalidateServiceLeader",
"(",
"service",
"string",
")",
"{",
"// Retrieve service config.",
"c",
":=",
"s",
".",
"data",
".",
"Services",
"[",
"service",
"]",
"\n\n",
"// Ignore if there is no config or the leader is manually elected.",
"if",
"c",
"==",
"nil",
"||",
"c",
".",
"LeaderType",
"==",
"discoverd",
".",
"LeaderTypeManual",
"{",
"return",
"\n",
"}",
"\n\n",
"// Retrieve current leader ID.",
"prevLeaderID",
":=",
"s",
".",
"data",
".",
"Leaders",
"[",
"service",
"]",
"\n\n",
"// Find the oldest, non-expired instance.",
"var",
"leader",
"*",
"discoverd",
".",
"Instance",
"\n",
"for",
"_",
",",
"inst",
":=",
"range",
"s",
".",
"data",
".",
"Instances",
"[",
"service",
"]",
"{",
"if",
"leader",
"==",
"nil",
"||",
"inst",
".",
"Index",
"<",
"leader",
".",
"Index",
"{",
"leader",
"=",
"inst",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Retrieve the leader ID.",
"var",
"leaderID",
"string",
"\n",
"if",
"leader",
"!=",
"nil",
"{",
"leaderID",
"=",
"leader",
".",
"ID",
"\n",
"}",
"\n\n",
"// Set leader.",
"s",
".",
"data",
".",
"Leaders",
"[",
"service",
"]",
"=",
"leaderID",
"\n\n",
"// Broadcast event.",
"if",
"prevLeaderID",
"!=",
"leaderID",
"{",
"var",
"inst",
"*",
"discoverd",
".",
"Instance",
"\n",
"if",
"s",
".",
"data",
".",
"Instances",
"[",
"service",
"]",
"!=",
"nil",
"{",
"inst",
"=",
"s",
".",
"data",
".",
"Instances",
"[",
"service",
"]",
"[",
"leaderID",
"]",
"\n",
"}",
"\n\n",
"s",
".",
"broadcast",
"(",
"&",
"discoverd",
".",
"Event",
"{",
"Service",
":",
"service",
",",
"Kind",
":",
"discoverd",
".",
"EventKindLeader",
",",
"Instance",
":",
"inst",
",",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // invalidateServiceLeader updates the current leader of service. | [
"invalidateServiceLeader",
"updates",
"the",
"current",
"leader",
"of",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L769-L811 | train |
flynn/flynn | discoverd/server/store.go | expirer | func (s *Store) expirer() {
defer s.wg.Done()
ticker := time.NewTicker(s.ExpiryCheckInterval)
defer ticker.Stop()
for {
// Wait for next check or for close signal.
select {
case <-s.closing:
return
case <-ticker.C:
}
// Check all instances for expiration.
if err := s.EnforceExpiry(); err != nil && err != raft.ErrNotLeader {
s.logger.Printf("enforce expiry: %s", err)
}
}
} | go | func (s *Store) expirer() {
defer s.wg.Done()
ticker := time.NewTicker(s.ExpiryCheckInterval)
defer ticker.Stop()
for {
// Wait for next check or for close signal.
select {
case <-s.closing:
return
case <-ticker.C:
}
// Check all instances for expiration.
if err := s.EnforceExpiry(); err != nil && err != raft.ErrNotLeader {
s.logger.Printf("enforce expiry: %s", err)
}
}
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"expirer",
"(",
")",
"{",
"defer",
"s",
".",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"s",
".",
"ExpiryCheckInterval",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n\n",
"for",
"{",
"// Wait for next check or for close signal.",
"select",
"{",
"case",
"<-",
"s",
".",
"closing",
":",
"return",
"\n",
"case",
"<-",
"ticker",
".",
"C",
":",
"}",
"\n\n",
"// Check all instances for expiration.",
"if",
"err",
":=",
"s",
".",
"EnforceExpiry",
"(",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"raft",
".",
"ErrNotLeader",
"{",
"s",
".",
"logger",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // expirer runs in a separate goroutine and checks for instance expiration. | [
"expirer",
"runs",
"in",
"a",
"separate",
"goroutine",
"and",
"checks",
"for",
"instance",
"expiration",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L814-L833 | train |
flynn/flynn | discoverd/server/store.go | EnforceExpiry | func (s *Store) EnforceExpiry() error {
var cmd []byte
if err := func() error {
s.mu.Lock()
defer s.mu.Unlock()
// Ignore if this store is not the leader and hasn't been for at least 2 TTLs intervals.
if !s.IsLeader() {
return raft.ErrNotLeader
} else if s.leaderTime.IsZero() || time.Since(s.leaderTime) < (2*s.InstanceTTL) {
return ErrLeaderWait
}
// Iterate over services and then instances.
var instances []expireInstance
for service, m := range s.data.Instances {
for _, inst := range m {
// Ignore instances that have heartbeated within the TTL.
if t := s.heartbeats[instanceKey{service, inst.ID}]; time.Since(t) <= s.InstanceTTL {
continue
}
logger.Info("marking instance for expiry",
"fn", "EnforceExpiry",
"service", service,
"instance.id", inst.ID,
"instance.addr", inst.Addr,
)
// Add to list of instances to expire.
// The current expiry time is added to prevent a race condition of
// instances updating their expiry date while this command is applying.
instances = append(instances, expireInstance{
Service: service,
InstanceID: inst.ID,
})
}
}
// If we have no instances to expire then exit.
if len(instances) == 0 {
return nil
}
// Create command to expire instances.
buf, err := json.Marshal(&expireInstancesCommand{
Instances: instances,
})
if err != nil {
return err
}
cmd = buf
return nil
}(); err != nil {
return err
} else if cmd == nil {
return nil
}
// Apply command to raft.
if _, err := s.raftApply(expireInstancesCommandType, cmd); err != nil {
return err
}
return nil
} | go | func (s *Store) EnforceExpiry() error {
var cmd []byte
if err := func() error {
s.mu.Lock()
defer s.mu.Unlock()
// Ignore if this store is not the leader and hasn't been for at least 2 TTLs intervals.
if !s.IsLeader() {
return raft.ErrNotLeader
} else if s.leaderTime.IsZero() || time.Since(s.leaderTime) < (2*s.InstanceTTL) {
return ErrLeaderWait
}
// Iterate over services and then instances.
var instances []expireInstance
for service, m := range s.data.Instances {
for _, inst := range m {
// Ignore instances that have heartbeated within the TTL.
if t := s.heartbeats[instanceKey{service, inst.ID}]; time.Since(t) <= s.InstanceTTL {
continue
}
logger.Info("marking instance for expiry",
"fn", "EnforceExpiry",
"service", service,
"instance.id", inst.ID,
"instance.addr", inst.Addr,
)
// Add to list of instances to expire.
// The current expiry time is added to prevent a race condition of
// instances updating their expiry date while this command is applying.
instances = append(instances, expireInstance{
Service: service,
InstanceID: inst.ID,
})
}
}
// If we have no instances to expire then exit.
if len(instances) == 0 {
return nil
}
// Create command to expire instances.
buf, err := json.Marshal(&expireInstancesCommand{
Instances: instances,
})
if err != nil {
return err
}
cmd = buf
return nil
}(); err != nil {
return err
} else if cmd == nil {
return nil
}
// Apply command to raft.
if _, err := s.raftApply(expireInstancesCommandType, cmd); err != nil {
return err
}
return nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"EnforceExpiry",
"(",
")",
"error",
"{",
"var",
"cmd",
"[",
"]",
"byte",
"\n",
"if",
"err",
":=",
"func",
"(",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// Ignore if this store is not the leader and hasn't been for at least 2 TTLs intervals.",
"if",
"!",
"s",
".",
"IsLeader",
"(",
")",
"{",
"return",
"raft",
".",
"ErrNotLeader",
"\n",
"}",
"else",
"if",
"s",
".",
"leaderTime",
".",
"IsZero",
"(",
")",
"||",
"time",
".",
"Since",
"(",
"s",
".",
"leaderTime",
")",
"<",
"(",
"2",
"*",
"s",
".",
"InstanceTTL",
")",
"{",
"return",
"ErrLeaderWait",
"\n",
"}",
"\n\n",
"// Iterate over services and then instances.",
"var",
"instances",
"[",
"]",
"expireInstance",
"\n",
"for",
"service",
",",
"m",
":=",
"range",
"s",
".",
"data",
".",
"Instances",
"{",
"for",
"_",
",",
"inst",
":=",
"range",
"m",
"{",
"// Ignore instances that have heartbeated within the TTL.",
"if",
"t",
":=",
"s",
".",
"heartbeats",
"[",
"instanceKey",
"{",
"service",
",",
"inst",
".",
"ID",
"}",
"]",
";",
"time",
".",
"Since",
"(",
"t",
")",
"<=",
"s",
".",
"InstanceTTL",
"{",
"continue",
"\n",
"}",
"\n\n",
"logger",
".",
"Info",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"service",
",",
"\"",
"\"",
",",
"inst",
".",
"ID",
",",
"\"",
"\"",
",",
"inst",
".",
"Addr",
",",
")",
"\n\n",
"// Add to list of instances to expire.",
"// The current expiry time is added to prevent a race condition of",
"// instances updating their expiry date while this command is applying.",
"instances",
"=",
"append",
"(",
"instances",
",",
"expireInstance",
"{",
"Service",
":",
"service",
",",
"InstanceID",
":",
"inst",
".",
"ID",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If we have no instances to expire then exit.",
"if",
"len",
"(",
"instances",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Create command to expire instances.",
"buf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"expireInstancesCommand",
"{",
"Instances",
":",
"instances",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"cmd",
"=",
"buf",
"\n\n",
"return",
"nil",
"\n",
"}",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"cmd",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Apply command to raft.",
"if",
"_",
",",
"err",
":=",
"s",
".",
"raftApply",
"(",
"expireInstancesCommandType",
",",
"cmd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // EnforceExpiry checks all instances for expiration and issues an expiration command, if necessary.
// This function returns raft.ErrNotLeader if this store is not the current leader. | [
"EnforceExpiry",
"checks",
"all",
"instances",
"for",
"expiration",
"and",
"issues",
"an",
"expiration",
"command",
"if",
"necessary",
".",
"This",
"function",
"returns",
"raft",
".",
"ErrNotLeader",
"if",
"this",
"store",
"is",
"not",
"the",
"current",
"leader",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L837-L902 | train |
flynn/flynn | discoverd/server/store.go | raftApply | func (s *Store) raftApply(typ byte, cmd []byte) (uint64, error) {
s.mu.RLock()
if s.raft == nil {
s.mu.RUnlock()
return 0, ErrShutdown
}
s.mu.RUnlock()
// Join the command type and data into one message.
buf := append([]byte{typ}, cmd...)
// Apply to raft and receive an ApplyFuture back.
f := s.raft.Apply(buf, 30*time.Second)
if err := f.Error(); err == raft.ErrNotLeader {
return 0, ErrNotLeader // hide underlying implementation error
} else if err != nil {
return f.Index(), err
} else if err, ok := f.Response().(error); ok {
return f.Index(), err
}
return f.Index(), nil
} | go | func (s *Store) raftApply(typ byte, cmd []byte) (uint64, error) {
s.mu.RLock()
if s.raft == nil {
s.mu.RUnlock()
return 0, ErrShutdown
}
s.mu.RUnlock()
// Join the command type and data into one message.
buf := append([]byte{typ}, cmd...)
// Apply to raft and receive an ApplyFuture back.
f := s.raft.Apply(buf, 30*time.Second)
if err := f.Error(); err == raft.ErrNotLeader {
return 0, ErrNotLeader // hide underlying implementation error
} else if err != nil {
return f.Index(), err
} else if err, ok := f.Response().(error); ok {
return f.Index(), err
}
return f.Index(), nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"raftApply",
"(",
"typ",
"byte",
",",
"cmd",
"[",
"]",
"byte",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"if",
"s",
".",
"raft",
"==",
"nil",
"{",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"0",
",",
"ErrShutdown",
"\n",
"}",
"\n",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"// Join the command type and data into one message.",
"buf",
":=",
"append",
"(",
"[",
"]",
"byte",
"{",
"typ",
"}",
",",
"cmd",
"...",
")",
"\n\n",
"// Apply to raft and receive an ApplyFuture back.",
"f",
":=",
"s",
".",
"raft",
".",
"Apply",
"(",
"buf",
",",
"30",
"*",
"time",
".",
"Second",
")",
"\n",
"if",
"err",
":=",
"f",
".",
"Error",
"(",
")",
";",
"err",
"==",
"raft",
".",
"ErrNotLeader",
"{",
"return",
"0",
",",
"ErrNotLeader",
"// hide underlying implementation error",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"f",
".",
"Index",
"(",
")",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
",",
"ok",
":=",
"f",
".",
"Response",
"(",
")",
".",
"(",
"error",
")",
";",
"ok",
"{",
"return",
"f",
".",
"Index",
"(",
")",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"f",
".",
"Index",
"(",
")",
",",
"nil",
"\n",
"}"
] | // raftApply joins typ and cmd and applies it to raft.
// This call blocks until the apply completes and returns the error. | [
"raftApply",
"joins",
"typ",
"and",
"cmd",
"and",
"applies",
"it",
"to",
"raft",
".",
"This",
"call",
"blocks",
"until",
"the",
"apply",
"completes",
"and",
"returns",
"the",
"error",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L949-L971 | train |
flynn/flynn | discoverd/server/store.go | Snapshot | func (s *Store) Snapshot() (raft.FSMSnapshot, error) {
s.mu.Lock()
defer s.mu.Unlock()
buf, err := json.Marshal(s.data)
if err != nil {
return nil, err
}
return &raftSnapshot{data: buf}, nil
} | go | func (s *Store) Snapshot() (raft.FSMSnapshot, error) {
s.mu.Lock()
defer s.mu.Unlock()
buf, err := json.Marshal(s.data)
if err != nil {
return nil, err
}
return &raftSnapshot{data: buf}, nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Snapshot",
"(",
")",
"(",
"raft",
".",
"FSMSnapshot",
",",
"error",
")",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"buf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"s",
".",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"raftSnapshot",
"{",
"data",
":",
"buf",
"}",
",",
"nil",
"\n",
"}"
] | // Snapshot implements raft.FSM. | [
"Snapshot",
"implements",
"raft",
".",
"FSM",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1007-L1016 | train |
flynn/flynn | discoverd/server/store.go | Restore | func (s *Store) Restore(r io.ReadCloser) error {
s.mu.Lock()
defer s.mu.Unlock()
data := &raftData{}
if err := json.NewDecoder(r).Decode(data); err != nil {
return err
}
s.data = data
return nil
} | go | func (s *Store) Restore(r io.ReadCloser) error {
s.mu.Lock()
defer s.mu.Unlock()
data := &raftData{}
if err := json.NewDecoder(r).Decode(data); err != nil {
return err
}
s.data = data
return nil
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Restore",
"(",
"r",
"io",
".",
"ReadCloser",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"data",
":=",
"&",
"raftData",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
")",
".",
"Decode",
"(",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"data",
"=",
"data",
"\n",
"return",
"nil",
"\n",
"}"
] | // Restore implements raft.FSM. | [
"Restore",
"implements",
"raft",
".",
"FSM",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1019-L1029 | train |
flynn/flynn | discoverd/server/store.go | Subscribe | func (s *Store) Subscribe(service string, sendCurrent bool, kinds discoverd.EventKind, ch chan *discoverd.Event) stream.Stream {
s.mu.Lock()
defer s.mu.Unlock()
// Create service subscription list if it doesn't exist yet.
if _, ok := s.subscribers[service]; !ok {
s.subscribers[service] = list.New()
}
// Create and add subscription.
sub := &subscription{
kinds: kinds,
ch: ch,
store: s,
service: service,
}
sub.el = s.subscribers[service].PushBack(sub)
// Send current instances.
if sendCurrent && kinds.Any(discoverd.EventKindUp) {
for _, inst := range s.instances(service) {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindUp,
Instance: inst,
}
// TODO: add a timeout to sends so that clients can't slow things down too much
}
}
// Send current leader.
if leader := s.serviceLeader(service); sendCurrent && kinds&discoverd.EventKindLeader != 0 && leader != nil {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindLeader,
Instance: leader,
}
}
// Send current service meta data.
if meta := s.serviceMeta(service); sendCurrent && kinds.Any(discoverd.EventKindServiceMeta) && meta != nil {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindServiceMeta,
ServiceMeta: meta,
}
}
// Send current service.
if sendCurrent && kinds.Any(discoverd.EventKindCurrent) {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindCurrent,
}
}
return sub
} | go | func (s *Store) Subscribe(service string, sendCurrent bool, kinds discoverd.EventKind, ch chan *discoverd.Event) stream.Stream {
s.mu.Lock()
defer s.mu.Unlock()
// Create service subscription list if it doesn't exist yet.
if _, ok := s.subscribers[service]; !ok {
s.subscribers[service] = list.New()
}
// Create and add subscription.
sub := &subscription{
kinds: kinds,
ch: ch,
store: s,
service: service,
}
sub.el = s.subscribers[service].PushBack(sub)
// Send current instances.
if sendCurrent && kinds.Any(discoverd.EventKindUp) {
for _, inst := range s.instances(service) {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindUp,
Instance: inst,
}
// TODO: add a timeout to sends so that clients can't slow things down too much
}
}
// Send current leader.
if leader := s.serviceLeader(service); sendCurrent && kinds&discoverd.EventKindLeader != 0 && leader != nil {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindLeader,
Instance: leader,
}
}
// Send current service meta data.
if meta := s.serviceMeta(service); sendCurrent && kinds.Any(discoverd.EventKindServiceMeta) && meta != nil {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindServiceMeta,
ServiceMeta: meta,
}
}
// Send current service.
if sendCurrent && kinds.Any(discoverd.EventKindCurrent) {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindCurrent,
}
}
return sub
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Subscribe",
"(",
"service",
"string",
",",
"sendCurrent",
"bool",
",",
"kinds",
"discoverd",
".",
"EventKind",
",",
"ch",
"chan",
"*",
"discoverd",
".",
"Event",
")",
"stream",
".",
"Stream",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"// Create service subscription list if it doesn't exist yet.",
"if",
"_",
",",
"ok",
":=",
"s",
".",
"subscribers",
"[",
"service",
"]",
";",
"!",
"ok",
"{",
"s",
".",
"subscribers",
"[",
"service",
"]",
"=",
"list",
".",
"New",
"(",
")",
"\n",
"}",
"\n\n",
"// Create and add subscription.",
"sub",
":=",
"&",
"subscription",
"{",
"kinds",
":",
"kinds",
",",
"ch",
":",
"ch",
",",
"store",
":",
"s",
",",
"service",
":",
"service",
",",
"}",
"\n",
"sub",
".",
"el",
"=",
"s",
".",
"subscribers",
"[",
"service",
"]",
".",
"PushBack",
"(",
"sub",
")",
"\n\n",
"// Send current instances.",
"if",
"sendCurrent",
"&&",
"kinds",
".",
"Any",
"(",
"discoverd",
".",
"EventKindUp",
")",
"{",
"for",
"_",
",",
"inst",
":=",
"range",
"s",
".",
"instances",
"(",
"service",
")",
"{",
"ch",
"<-",
"&",
"discoverd",
".",
"Event",
"{",
"Service",
":",
"service",
",",
"Kind",
":",
"discoverd",
".",
"EventKindUp",
",",
"Instance",
":",
"inst",
",",
"}",
"\n",
"// TODO: add a timeout to sends so that clients can't slow things down too much",
"}",
"\n",
"}",
"\n\n",
"// Send current leader.",
"if",
"leader",
":=",
"s",
".",
"serviceLeader",
"(",
"service",
")",
";",
"sendCurrent",
"&&",
"kinds",
"&",
"discoverd",
".",
"EventKindLeader",
"!=",
"0",
"&&",
"leader",
"!=",
"nil",
"{",
"ch",
"<-",
"&",
"discoverd",
".",
"Event",
"{",
"Service",
":",
"service",
",",
"Kind",
":",
"discoverd",
".",
"EventKindLeader",
",",
"Instance",
":",
"leader",
",",
"}",
"\n",
"}",
"\n\n",
"// Send current service meta data.",
"if",
"meta",
":=",
"s",
".",
"serviceMeta",
"(",
"service",
")",
";",
"sendCurrent",
"&&",
"kinds",
".",
"Any",
"(",
"discoverd",
".",
"EventKindServiceMeta",
")",
"&&",
"meta",
"!=",
"nil",
"{",
"ch",
"<-",
"&",
"discoverd",
".",
"Event",
"{",
"Service",
":",
"service",
",",
"Kind",
":",
"discoverd",
".",
"EventKindServiceMeta",
",",
"ServiceMeta",
":",
"meta",
",",
"}",
"\n",
"}",
"\n\n",
"// Send current service.",
"if",
"sendCurrent",
"&&",
"kinds",
".",
"Any",
"(",
"discoverd",
".",
"EventKindCurrent",
")",
"{",
"ch",
"<-",
"&",
"discoverd",
".",
"Event",
"{",
"Service",
":",
"service",
",",
"Kind",
":",
"discoverd",
".",
"EventKindCurrent",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"sub",
"\n",
"}"
] | // Subscribe creates a subscription to events on a given service. | [
"Subscribe",
"creates",
"a",
"subscription",
"to",
"events",
"on",
"a",
"given",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1032-L1089 | train |
flynn/flynn | discoverd/server/store.go | broadcast | func (s *Store) broadcast(event *discoverd.Event) {
logBroadcast(event)
// Retrieve list of subscribers for the service.
l, ok := s.subscribers[event.Service]
if !ok {
return
}
// Iterate over each subscriber in the list.
for el := l.Front(); el != nil; el = el.Next() {
sub := el.Value.(*subscription)
// Skip if event type is not subscribed to.
if sub.kinds&event.Kind == 0 {
continue
}
// Send event to subscriber.
// If subscriber is blocked then close it.
select {
case sub.ch <- event:
default:
sub.err = ErrSendBlocked
go sub.Close()
}
}
} | go | func (s *Store) broadcast(event *discoverd.Event) {
logBroadcast(event)
// Retrieve list of subscribers for the service.
l, ok := s.subscribers[event.Service]
if !ok {
return
}
// Iterate over each subscriber in the list.
for el := l.Front(); el != nil; el = el.Next() {
sub := el.Value.(*subscription)
// Skip if event type is not subscribed to.
if sub.kinds&event.Kind == 0 {
continue
}
// Send event to subscriber.
// If subscriber is blocked then close it.
select {
case sub.ch <- event:
default:
sub.err = ErrSendBlocked
go sub.Close()
}
}
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"broadcast",
"(",
"event",
"*",
"discoverd",
".",
"Event",
")",
"{",
"logBroadcast",
"(",
"event",
")",
"\n\n",
"// Retrieve list of subscribers for the service.",
"l",
",",
"ok",
":=",
"s",
".",
"subscribers",
"[",
"event",
".",
"Service",
"]",
"\n\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n\n",
"// Iterate over each subscriber in the list.",
"for",
"el",
":=",
"l",
".",
"Front",
"(",
")",
";",
"el",
"!=",
"nil",
";",
"el",
"=",
"el",
".",
"Next",
"(",
")",
"{",
"sub",
":=",
"el",
".",
"Value",
".",
"(",
"*",
"subscription",
")",
"\n\n",
"// Skip if event type is not subscribed to.",
"if",
"sub",
".",
"kinds",
"&",
"event",
".",
"Kind",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n\n",
"// Send event to subscriber.",
"// If subscriber is blocked then close it.",
"select",
"{",
"case",
"sub",
".",
"ch",
"<-",
"event",
":",
"default",
":",
"sub",
".",
"err",
"=",
"ErrSendBlocked",
"\n",
"go",
"sub",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // broadcast sends an event to all subscribers.
// Requires the mu lock to be obtained. | [
"broadcast",
"sends",
"an",
"event",
"to",
"all",
"subscribers",
".",
"Requires",
"the",
"mu",
"lock",
"to",
"be",
"obtained",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1093-L1121 | train |
flynn/flynn | discoverd/server/store.go | Persist | func (ss *raftSnapshot) Persist(sink raft.SnapshotSink) error {
// Write data to sink.
if _, err := sink.Write(ss.data); err != nil {
sink.Cancel()
return err
}
// Close and exit.
return sink.Close()
} | go | func (ss *raftSnapshot) Persist(sink raft.SnapshotSink) error {
// Write data to sink.
if _, err := sink.Write(ss.data); err != nil {
sink.Cancel()
return err
}
// Close and exit.
return sink.Close()
} | [
"func",
"(",
"ss",
"*",
"raftSnapshot",
")",
"Persist",
"(",
"sink",
"raft",
".",
"SnapshotSink",
")",
"error",
"{",
"// Write data to sink.",
"if",
"_",
",",
"err",
":=",
"sink",
".",
"Write",
"(",
"ss",
".",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"sink",
".",
"Cancel",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// Close and exit.",
"return",
"sink",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Persist writes the snapshot to the sink. | [
"Persist",
"writes",
"the",
"snapshot",
"to",
"the",
"sink",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1148-L1157 | train |
flynn/flynn | discoverd/server/store.go | ServiceInstances | func (d *raftData) ServiceInstances(service string) []*discoverd.Instance {
a := make([]*discoverd.Instance, 0, len(d.Instances[service]))
for _, i := range d.Instances[service] {
a = append(a, i)
}
sort.Sort(instanceSlice(a))
return a
} | go | func (d *raftData) ServiceInstances(service string) []*discoverd.Instance {
a := make([]*discoverd.Instance, 0, len(d.Instances[service]))
for _, i := range d.Instances[service] {
a = append(a, i)
}
sort.Sort(instanceSlice(a))
return a
} | [
"func",
"(",
"d",
"*",
"raftData",
")",
"ServiceInstances",
"(",
"service",
"string",
")",
"[",
"]",
"*",
"discoverd",
".",
"Instance",
"{",
"a",
":=",
"make",
"(",
"[",
"]",
"*",
"discoverd",
".",
"Instance",
",",
"0",
",",
"len",
"(",
"d",
".",
"Instances",
"[",
"service",
"]",
")",
")",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"d",
".",
"Instances",
"[",
"service",
"]",
"{",
"a",
"=",
"append",
"(",
"a",
",",
"i",
")",
"\n",
"}",
"\n\n",
"sort",
".",
"Sort",
"(",
"instanceSlice",
"(",
"a",
")",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // ServiceInstances returns the instances of a service in sorted order. | [
"ServiceInstances",
"returns",
"the",
"instances",
"of",
"a",
"service",
"in",
"sorted",
"order",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1245-L1253 | train |
flynn/flynn | discoverd/server/store.go | ValidServiceName | func ValidServiceName(service string) error {
// Blank service names are not allowed.
if service == "" {
return ErrUnsetService
}
// Service names must consist of the characters [a-z0-9-]
for _, r := range service {
if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
return ErrInvalidService
}
}
return nil
} | go | func ValidServiceName(service string) error {
// Blank service names are not allowed.
if service == "" {
return ErrUnsetService
}
// Service names must consist of the characters [a-z0-9-]
for _, r := range service {
if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
return ErrInvalidService
}
}
return nil
} | [
"func",
"ValidServiceName",
"(",
"service",
"string",
")",
"error",
"{",
"// Blank service names are not allowed.",
"if",
"service",
"==",
"\"",
"\"",
"{",
"return",
"ErrUnsetService",
"\n",
"}",
"\n\n",
"// Service names must consist of the characters [a-z0-9-]",
"for",
"_",
",",
"r",
":=",
"range",
"service",
"{",
"if",
"(",
"r",
"<",
"'a'",
"||",
"r",
">",
"'z'",
")",
"&&",
"(",
"r",
"<",
"'0'",
"||",
"r",
">",
"'9'",
")",
"&&",
"r",
"!=",
"'-'",
"{",
"return",
"ErrInvalidService",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ValidServiceName returns nil if service is valid. Otherwise returns an error. | [
"ValidServiceName",
"returns",
"nil",
"if",
"service",
"is",
"valid",
".",
"Otherwise",
"returns",
"an",
"error",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1328-L1342 | train |
flynn/flynn | discoverd/server/store.go | Instances | func (s *ProxyStore) Instances(service string) ([]*discoverd.Instance, error) {
host := s.Peers[rand.Intn(len(s.Peers))]
client := discoverd.NewClientWithURL("http://" + host)
return client.Service(service).Instances()
} | go | func (s *ProxyStore) Instances(service string) ([]*discoverd.Instance, error) {
host := s.Peers[rand.Intn(len(s.Peers))]
client := discoverd.NewClientWithURL("http://" + host)
return client.Service(service).Instances()
} | [
"func",
"(",
"s",
"*",
"ProxyStore",
")",
"Instances",
"(",
"service",
"string",
")",
"(",
"[",
"]",
"*",
"discoverd",
".",
"Instance",
",",
"error",
")",
"{",
"host",
":=",
"s",
".",
"Peers",
"[",
"rand",
".",
"Intn",
"(",
"len",
"(",
"s",
".",
"Peers",
")",
")",
"]",
"\n",
"client",
":=",
"discoverd",
".",
"NewClientWithURL",
"(",
"\"",
"\"",
"+",
"host",
")",
"\n",
"return",
"client",
".",
"Service",
"(",
"service",
")",
".",
"Instances",
"(",
")",
"\n",
"}"
] | // Instances returns a list of instances for a service. | [
"Instances",
"returns",
"a",
"list",
"of",
"instances",
"for",
"a",
"service",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1351-L1355 | train |
flynn/flynn | discoverd/server/store.go | newRaftLayer | func newRaftLayer(ln net.Listener, addr net.Addr) *raftLayer {
return &raftLayer{
ln: ln,
addr: addr,
}
} | go | func newRaftLayer(ln net.Listener, addr net.Addr) *raftLayer {
return &raftLayer{
ln: ln,
addr: addr,
}
} | [
"func",
"newRaftLayer",
"(",
"ln",
"net",
".",
"Listener",
",",
"addr",
"net",
".",
"Addr",
")",
"*",
"raftLayer",
"{",
"return",
"&",
"raftLayer",
"{",
"ln",
":",
"ln",
",",
"addr",
":",
"addr",
",",
"}",
"\n",
"}"
] | // newRaftLayer returns a new instance of raftLayer. | [
"newRaftLayer",
"returns",
"a",
"new",
"instance",
"of",
"raftLayer",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/discoverd/server/store.go#L1374-L1379 | train |
flynn/flynn | pkg/rpcplus/client.go | CloseStream | func (c *Call) CloseStream() error {
if !c.Stream {
return errors.New("rpc: cannot close non-stream request")
}
<-c.sent
c.client.sending.Lock()
defer c.client.sending.Unlock()
c.client.mutex.Lock()
if c.client.shutdown {
c.client.mutex.Unlock()
return ErrShutdown
}
c.client.mutex.Unlock()
c.client.request.ServiceMethod = "CloseStream"
c.client.request.Seq = c.seq
return c.client.codec.WriteRequest(&c.client.request, struct{}{})
} | go | func (c *Call) CloseStream() error {
if !c.Stream {
return errors.New("rpc: cannot close non-stream request")
}
<-c.sent
c.client.sending.Lock()
defer c.client.sending.Unlock()
c.client.mutex.Lock()
if c.client.shutdown {
c.client.mutex.Unlock()
return ErrShutdown
}
c.client.mutex.Unlock()
c.client.request.ServiceMethod = "CloseStream"
c.client.request.Seq = c.seq
return c.client.codec.WriteRequest(&c.client.request, struct{}{})
} | [
"func",
"(",
"c",
"*",
"Call",
")",
"CloseStream",
"(",
")",
"error",
"{",
"if",
"!",
"c",
".",
"Stream",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"<-",
"c",
".",
"sent",
"\n",
"c",
".",
"client",
".",
"sending",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"client",
".",
"sending",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
".",
"client",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"if",
"c",
".",
"client",
".",
"shutdown",
"{",
"c",
".",
"client",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"return",
"ErrShutdown",
"\n",
"}",
"\n",
"c",
".",
"client",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
".",
"client",
".",
"request",
".",
"ServiceMethod",
"=",
"\"",
"\"",
"\n",
"c",
".",
"client",
".",
"request",
".",
"Seq",
"=",
"c",
".",
"seq",
"\n",
"return",
"c",
".",
"client",
".",
"codec",
".",
"WriteRequest",
"(",
"&",
"c",
".",
"client",
".",
"request",
",",
"struct",
"{",
"}",
"{",
"}",
")",
"\n",
"}"
] | // CloseStream closes the associated stream | [
"CloseStream",
"closes",
"the",
"associated",
"stream"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/client.go#L45-L63 | train |
flynn/flynn | pkg/rpcplus/client.go | NewClient | func NewClient(conn io.ReadWriteCloser) *Client {
encBuf := bufio.NewWriter(conn)
client := &gobClientCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(encBuf), encBuf}
return NewClientWithCodec(client)
} | go | func NewClient(conn io.ReadWriteCloser) *Client {
encBuf := bufio.NewWriter(conn)
client := &gobClientCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(encBuf), encBuf}
return NewClientWithCodec(client)
} | [
"func",
"NewClient",
"(",
"conn",
"io",
".",
"ReadWriteCloser",
")",
"*",
"Client",
"{",
"encBuf",
":=",
"bufio",
".",
"NewWriter",
"(",
"conn",
")",
"\n",
"client",
":=",
"&",
"gobClientCodec",
"{",
"conn",
",",
"gob",
".",
"NewDecoder",
"(",
"conn",
")",
",",
"gob",
".",
"NewEncoder",
"(",
"encBuf",
")",
",",
"encBuf",
"}",
"\n",
"return",
"NewClientWithCodec",
"(",
"client",
")",
"\n",
"}"
] | // NewClient returns a new Client to handle requests to the
// set of services at the other end of the connection.
// It adds a buffer to the write side of the connection so
// the header and payload are sent as a unit. | [
"NewClient",
"returns",
"a",
"new",
"Client",
"to",
"handle",
"requests",
"to",
"the",
"set",
"of",
"services",
"at",
"the",
"other",
"end",
"of",
"the",
"connection",
".",
"It",
"adds",
"a",
"buffer",
"to",
"the",
"write",
"side",
"of",
"the",
"connection",
"so",
"the",
"header",
"and",
"payload",
"are",
"sent",
"as",
"a",
"unit",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/client.go#L243-L247 | train |
flynn/flynn | pkg/rpcplus/client.go | DialHTTP | func DialHTTP(network, address string) (*Client, error) {
return DialHTTPPath(network, address, DefaultRPCPath, nil)
} | go | func DialHTTP(network, address string) (*Client, error) {
return DialHTTPPath(network, address, DefaultRPCPath, nil)
} | [
"func",
"DialHTTP",
"(",
"network",
",",
"address",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"return",
"DialHTTPPath",
"(",
"network",
",",
"address",
",",
"DefaultRPCPath",
",",
"nil",
")",
"\n",
"}"
] | // DialHTTP connects to an HTTP RPC server at the specified network address
// listening on the default HTTP RPC path. | [
"DialHTTP",
"connects",
"to",
"an",
"HTTP",
"RPC",
"server",
"at",
"the",
"specified",
"network",
"address",
"listening",
"on",
"the",
"default",
"HTTP",
"RPC",
"path",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/client.go#L291-L293 | train |
flynn/flynn | pkg/rpcplus/client.go | DialHTTPPath | func DialHTTPPath(network, address, path string, dial DialFunc) (*Client, error) {
if dial == nil {
dial = net.Dial
}
var err error
conn, err := dial(network, address)
if err != nil {
return nil, err
}
client, err := NewHTTPClient(conn, path, nil)
if err != nil {
conn.Close()
return nil, &net.OpError{
Op: "dial-http",
Net: network + " " + address,
Addr: nil,
Err: err,
}
}
return client, nil
} | go | func DialHTTPPath(network, address, path string, dial DialFunc) (*Client, error) {
if dial == nil {
dial = net.Dial
}
var err error
conn, err := dial(network, address)
if err != nil {
return nil, err
}
client, err := NewHTTPClient(conn, path, nil)
if err != nil {
conn.Close()
return nil, &net.OpError{
Op: "dial-http",
Net: network + " " + address,
Addr: nil,
Err: err,
}
}
return client, nil
} | [
"func",
"DialHTTPPath",
"(",
"network",
",",
"address",
",",
"path",
"string",
",",
"dial",
"DialFunc",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"if",
"dial",
"==",
"nil",
"{",
"dial",
"=",
"net",
".",
"Dial",
"\n",
"}",
"\n",
"var",
"err",
"error",
"\n",
"conn",
",",
"err",
":=",
"dial",
"(",
"network",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"client",
",",
"err",
":=",
"NewHTTPClient",
"(",
"conn",
",",
"path",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"&",
"net",
".",
"OpError",
"{",
"Op",
":",
"\"",
"\"",
",",
"Net",
":",
"network",
"+",
"\"",
"\"",
"+",
"address",
",",
"Addr",
":",
"nil",
",",
"Err",
":",
"err",
",",
"}",
"\n",
"}",
"\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] | // DialHTTPPath connects to an HTTP RPC server
// at the specified network address and path. | [
"DialHTTPPath",
"connects",
"to",
"an",
"HTTP",
"RPC",
"server",
"at",
"the",
"specified",
"network",
"address",
"and",
"path",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/client.go#L299-L319 | train |
flynn/flynn | pkg/rpcplus/client.go | Dial | func Dial(network, address string) (*Client, error) {
conn, err := net.Dial(network, address)
if err != nil {
return nil, err
}
return NewClient(conn), nil
} | go | func Dial(network, address string) (*Client, error) {
conn, err := net.Dial(network, address)
if err != nil {
return nil, err
}
return NewClient(conn), nil
} | [
"func",
"Dial",
"(",
"network",
",",
"address",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"network",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewClient",
"(",
"conn",
")",
",",
"nil",
"\n",
"}"
] | // Dial connects to an RPC server at the specified network address. | [
"Dial",
"connects",
"to",
"an",
"RPC",
"server",
"at",
"the",
"specified",
"network",
"address",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/client.go#L344-L350 | train |
flynn/flynn | pkg/rpcplus/client.go | StreamGo | func (client *Client) StreamGo(serviceMethod string, args interface{}, replyStream interface{}) *Call {
// first check the replyStream object is a stream of pointers to a data structure
typ := reflect.TypeOf(replyStream)
// FIXME: check the direction of the channel, maybe?
if typ.Kind() != reflect.Chan || typ.Elem().Kind() != reflect.Ptr {
log.Panic("rpc: replyStream is not a channel of pointers")
return nil
}
call := new(Call)
call.ServiceMethod = serviceMethod
call.Args = args
call.Reply = replyStream
call.Stream = true
call.sent = make(chan struct{})
call.client = client
client.send(call)
return call
} | go | func (client *Client) StreamGo(serviceMethod string, args interface{}, replyStream interface{}) *Call {
// first check the replyStream object is a stream of pointers to a data structure
typ := reflect.TypeOf(replyStream)
// FIXME: check the direction of the channel, maybe?
if typ.Kind() != reflect.Chan || typ.Elem().Kind() != reflect.Ptr {
log.Panic("rpc: replyStream is not a channel of pointers")
return nil
}
call := new(Call)
call.ServiceMethod = serviceMethod
call.Args = args
call.Reply = replyStream
call.Stream = true
call.sent = make(chan struct{})
call.client = client
client.send(call)
return call
} | [
"func",
"(",
"client",
"*",
"Client",
")",
"StreamGo",
"(",
"serviceMethod",
"string",
",",
"args",
"interface",
"{",
"}",
",",
"replyStream",
"interface",
"{",
"}",
")",
"*",
"Call",
"{",
"// first check the replyStream object is a stream of pointers to a data structure",
"typ",
":=",
"reflect",
".",
"TypeOf",
"(",
"replyStream",
")",
"\n",
"// FIXME: check the direction of the channel, maybe?",
"if",
"typ",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Chan",
"||",
"typ",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"log",
".",
"Panic",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"call",
":=",
"new",
"(",
"Call",
")",
"\n",
"call",
".",
"ServiceMethod",
"=",
"serviceMethod",
"\n",
"call",
".",
"Args",
"=",
"args",
"\n",
"call",
".",
"Reply",
"=",
"replyStream",
"\n",
"call",
".",
"Stream",
"=",
"true",
"\n",
"call",
".",
"sent",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"call",
".",
"client",
"=",
"client",
"\n",
"client",
".",
"send",
"(",
"call",
")",
"\n",
"return",
"call",
"\n",
"}"
] | // Go invokes the streaming function asynchronously. It returns the Call structure representing
// the invocation. | [
"Go",
"invokes",
"the",
"streaming",
"function",
"asynchronously",
".",
"It",
"returns",
"the",
"Call",
"structure",
"representing",
"the",
"invocation",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/client.go#L390-L408 | train |
flynn/flynn | appliance/mariadb/dsn.go | String | func (dsn *DSN) String() string {
u := url.URL{
Host: fmt.Sprintf("tcp(%s)", dsn.Host),
Path: "/" + dsn.Database,
RawQuery: url.Values{
"timeout": {dsn.Timeout.String()},
}.Encode(),
}
// Set password, if available.
if dsn.Password == "" {
u.User = url.User(dsn.User)
} else {
u.User = url.UserPassword(dsn.User, dsn.Password)
}
// Remove leading double-slash.
return strings.TrimPrefix(u.String(), "//")
} | go | func (dsn *DSN) String() string {
u := url.URL{
Host: fmt.Sprintf("tcp(%s)", dsn.Host),
Path: "/" + dsn.Database,
RawQuery: url.Values{
"timeout": {dsn.Timeout.String()},
}.Encode(),
}
// Set password, if available.
if dsn.Password == "" {
u.User = url.User(dsn.User)
} else {
u.User = url.UserPassword(dsn.User, dsn.Password)
}
// Remove leading double-slash.
return strings.TrimPrefix(u.String(), "//")
} | [
"func",
"(",
"dsn",
"*",
"DSN",
")",
"String",
"(",
")",
"string",
"{",
"u",
":=",
"url",
".",
"URL",
"{",
"Host",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"dsn",
".",
"Host",
")",
",",
"Path",
":",
"\"",
"\"",
"+",
"dsn",
".",
"Database",
",",
"RawQuery",
":",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"{",
"dsn",
".",
"Timeout",
".",
"String",
"(",
")",
"}",
",",
"}",
".",
"Encode",
"(",
")",
",",
"}",
"\n\n",
"// Set password, if available.",
"if",
"dsn",
".",
"Password",
"==",
"\"",
"\"",
"{",
"u",
".",
"User",
"=",
"url",
".",
"User",
"(",
"dsn",
".",
"User",
")",
"\n",
"}",
"else",
"{",
"u",
".",
"User",
"=",
"url",
".",
"UserPassword",
"(",
"dsn",
".",
"User",
",",
"dsn",
".",
"Password",
")",
"\n",
"}",
"\n\n",
"// Remove leading double-slash.",
"return",
"strings",
".",
"TrimPrefix",
"(",
"u",
".",
"String",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // String encodes dsn to a URL string format. | [
"String",
"encodes",
"dsn",
"to",
"a",
"URL",
"string",
"format",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/dsn.go#L20-L38 | train |
flynn/flynn | flannel/main.go | pingLeases | func pingLeases(leases []subnet.SubnetLease) error {
const workers = 5
const timeout = 1 * time.Second
if len(leases) == 0 {
return nil
}
work := make(chan subnet.SubnetLease)
results := make(chan bool, workers)
client := http.Client{Timeout: timeout}
var wg sync.WaitGroup
wg.Add(workers)
for i := 0; i < workers; i++ {
go func() {
for l := range work {
res, err := client.Get(fmt.Sprintf("http://%s:%s/ping", l.Network.IP, l.Attrs.HTTPPort))
if err == nil {
res.Body.Close()
}
results <- err == nil && res.StatusCode == 200
}
wg.Done()
}()
}
go func() {
wg.Wait()
close(results)
}()
for _, l := range leases {
select {
case work <- l:
case success := <-results:
if success {
close(work)
return nil
}
}
}
close(work)
for success := range results {
if success {
return nil
}
}
return errors.New("failed to successfully ping a neighbor")
} | go | func pingLeases(leases []subnet.SubnetLease) error {
const workers = 5
const timeout = 1 * time.Second
if len(leases) == 0 {
return nil
}
work := make(chan subnet.SubnetLease)
results := make(chan bool, workers)
client := http.Client{Timeout: timeout}
var wg sync.WaitGroup
wg.Add(workers)
for i := 0; i < workers; i++ {
go func() {
for l := range work {
res, err := client.Get(fmt.Sprintf("http://%s:%s/ping", l.Network.IP, l.Attrs.HTTPPort))
if err == nil {
res.Body.Close()
}
results <- err == nil && res.StatusCode == 200
}
wg.Done()
}()
}
go func() {
wg.Wait()
close(results)
}()
for _, l := range leases {
select {
case work <- l:
case success := <-results:
if success {
close(work)
return nil
}
}
}
close(work)
for success := range results {
if success {
return nil
}
}
return errors.New("failed to successfully ping a neighbor")
} | [
"func",
"pingLeases",
"(",
"leases",
"[",
"]",
"subnet",
".",
"SubnetLease",
")",
"error",
"{",
"const",
"workers",
"=",
"5",
"\n",
"const",
"timeout",
"=",
"1",
"*",
"time",
".",
"Second",
"\n\n",
"if",
"len",
"(",
"leases",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"work",
":=",
"make",
"(",
"chan",
"subnet",
".",
"SubnetLease",
")",
"\n",
"results",
":=",
"make",
"(",
"chan",
"bool",
",",
"workers",
")",
"\n",
"client",
":=",
"http",
".",
"Client",
"{",
"Timeout",
":",
"timeout",
"}",
"\n\n",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"wg",
".",
"Add",
"(",
"workers",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"workers",
";",
"i",
"++",
"{",
"go",
"func",
"(",
")",
"{",
"for",
"l",
":=",
"range",
"work",
"{",
"res",
",",
"err",
":=",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"l",
".",
"Network",
".",
"IP",
",",
"l",
".",
"Attrs",
".",
"HTTPPort",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"results",
"<-",
"err",
"==",
"nil",
"&&",
"res",
".",
"StatusCode",
"==",
"200",
"\n",
"}",
"\n",
"wg",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n\n",
"go",
"func",
"(",
")",
"{",
"wg",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"results",
")",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"_",
",",
"l",
":=",
"range",
"leases",
"{",
"select",
"{",
"case",
"work",
"<-",
"l",
":",
"case",
"success",
":=",
"<-",
"results",
":",
"if",
"success",
"{",
"close",
"(",
"work",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"close",
"(",
"work",
")",
"\n\n",
"for",
"success",
":=",
"range",
"results",
"{",
"if",
"success",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // ping neighbor leases five at a time, timeout 1 second, returning as soon as
// one returns success. | [
"ping",
"neighbor",
"leases",
"five",
"at",
"a",
"time",
"timeout",
"1",
"second",
"returning",
"as",
"soon",
"as",
"one",
"returns",
"success",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/flannel/main.go#L235-L286 | train |
flynn/flynn | controller/schema.go | migrateProcessData | func migrateProcessData(tx *postgres.DBTx) error {
type Release struct {
ID string
// use map[string]interface{} for process types so we can just
// update Volumes and Data and leave other fields untouched
Processes map[string]map[string]interface{}
}
var releases []Release
rows, err := tx.Query("SELECT release_id, processes FROM releases")
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
var release Release
if err := rows.Scan(&release.ID, &release.Processes); err != nil {
return err
}
releases = append(releases, release)
}
if err := rows.Err(); err != nil {
return err
}
for _, release := range releases {
for typ, proc := range release.Processes {
v, ok := proc["data"]
if !ok {
continue
}
data, ok := v.(bool)
if !ok || !data {
continue
}
proc["volumes"] = []struct {
Path string `json:"path"`
}{
{Path: "/data"},
}
delete(proc, "data")
release.Processes[typ] = proc
}
// save the processes back to the db
if err := tx.Exec("UPDATE releases SET processes = $1 WHERE release_id = $2", release.Processes, release.ID); err != nil {
return err
}
}
return nil
} | go | func migrateProcessData(tx *postgres.DBTx) error {
type Release struct {
ID string
// use map[string]interface{} for process types so we can just
// update Volumes and Data and leave other fields untouched
Processes map[string]map[string]interface{}
}
var releases []Release
rows, err := tx.Query("SELECT release_id, processes FROM releases")
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
var release Release
if err := rows.Scan(&release.ID, &release.Processes); err != nil {
return err
}
releases = append(releases, release)
}
if err := rows.Err(); err != nil {
return err
}
for _, release := range releases {
for typ, proc := range release.Processes {
v, ok := proc["data"]
if !ok {
continue
}
data, ok := v.(bool)
if !ok || !data {
continue
}
proc["volumes"] = []struct {
Path string `json:"path"`
}{
{Path: "/data"},
}
delete(proc, "data")
release.Processes[typ] = proc
}
// save the processes back to the db
if err := tx.Exec("UPDATE releases SET processes = $1 WHERE release_id = $2", release.Processes, release.ID); err != nil {
return err
}
}
return nil
} | [
"func",
"migrateProcessData",
"(",
"tx",
"*",
"postgres",
".",
"DBTx",
")",
"error",
"{",
"type",
"Release",
"struct",
"{",
"ID",
"string",
"\n\n",
"// use map[string]interface{} for process types so we can just",
"// update Volumes and Data and leave other fields untouched",
"Processes",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"}",
"\n\n",
"var",
"releases",
"[",
"]",
"Release",
"\n",
"rows",
",",
"err",
":=",
"tx",
".",
"Query",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"var",
"release",
"Release",
"\n",
"if",
"err",
":=",
"rows",
".",
"Scan",
"(",
"&",
"release",
".",
"ID",
",",
"&",
"release",
".",
"Processes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"releases",
"=",
"append",
"(",
"releases",
",",
"release",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"rows",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"release",
":=",
"range",
"releases",
"{",
"for",
"typ",
",",
"proc",
":=",
"range",
"release",
".",
"Processes",
"{",
"v",
",",
"ok",
":=",
"proc",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"data",
",",
"ok",
":=",
"v",
".",
"(",
"bool",
")",
"\n",
"if",
"!",
"ok",
"||",
"!",
"data",
"{",
"continue",
"\n",
"}",
"\n",
"proc",
"[",
"\"",
"\"",
"]",
"=",
"[",
"]",
"struct",
"{",
"Path",
"string",
"`json:\"path\"`",
"\n",
"}",
"{",
"{",
"Path",
":",
"\"",
"\"",
"}",
",",
"}",
"\n",
"delete",
"(",
"proc",
",",
"\"",
"\"",
")",
"\n",
"release",
".",
"Processes",
"[",
"typ",
"]",
"=",
"proc",
"\n",
"}",
"\n\n",
"// save the processes back to the db",
"if",
"err",
":=",
"tx",
".",
"Exec",
"(",
"\"",
"\"",
",",
"release",
".",
"Processes",
",",
"release",
".",
"ID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // migrateProcessData populates ProcessType.Volumes if ProcessType.Data is set | [
"migrateProcessData",
"populates",
"ProcessType",
".",
"Volumes",
"if",
"ProcessType",
".",
"Data",
"is",
"set"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/schema.go#L636-L687 | train |
flynn/flynn | router/proxy/transport.go | Finalize | func (r *RequestTrace) Finalize(backend *router.Backend) {
r.mtx.Lock()
r.final = true
r.Backend = backend
r.mtx.Unlock()
} | go | func (r *RequestTrace) Finalize(backend *router.Backend) {
r.mtx.Lock()
r.final = true
r.Backend = backend
r.mtx.Unlock()
} | [
"func",
"(",
"r",
"*",
"RequestTrace",
")",
"Finalize",
"(",
"backend",
"*",
"router",
".",
"Backend",
")",
"{",
"r",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"r",
".",
"final",
"=",
"true",
"\n",
"r",
".",
"Backend",
"=",
"backend",
"\n",
"r",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Finalize safely finalizes the trace for read access. | [
"Finalize",
"safely",
"finalizes",
"the",
"trace",
"for",
"read",
"access",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/router/proxy/transport.go#L272-L277 | train |
flynn/flynn | router/proxy/transport.go | traceRequest | func traceRequest(req *http.Request) (*http.Request, *RequestTrace) {
trace := &RequestTrace{}
ct := &httptrace.ClientTrace{
GetConn: func(hostPort string) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.ConnectStart = time.Now()
},
GotConn: func(info httptrace.GotConnInfo) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.ConnectDone = time.Now()
trace.ReusedConn = info.Reused
trace.WasIdleConn = info.WasIdle
},
WroteHeaders: func() {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.HeadersWritten = time.Now()
},
WroteRequest: func(info httptrace.WroteRequestInfo) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.BodyWritten = time.Now()
},
GotFirstResponseByte: func() {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.FirstByte = time.Now()
},
}
req = req.WithContext(httptrace.WithClientTrace(req.Context(), ct))
return req, trace
} | go | func traceRequest(req *http.Request) (*http.Request, *RequestTrace) {
trace := &RequestTrace{}
ct := &httptrace.ClientTrace{
GetConn: func(hostPort string) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.ConnectStart = time.Now()
},
GotConn: func(info httptrace.GotConnInfo) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.ConnectDone = time.Now()
trace.ReusedConn = info.Reused
trace.WasIdleConn = info.WasIdle
},
WroteHeaders: func() {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.HeadersWritten = time.Now()
},
WroteRequest: func(info httptrace.WroteRequestInfo) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.BodyWritten = time.Now()
},
GotFirstResponseByte: func() {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.FirstByte = time.Now()
},
}
req = req.WithContext(httptrace.WithClientTrace(req.Context(), ct))
return req, trace
} | [
"func",
"traceRequest",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Request",
",",
"*",
"RequestTrace",
")",
"{",
"trace",
":=",
"&",
"RequestTrace",
"{",
"}",
"\n",
"ct",
":=",
"&",
"httptrace",
".",
"ClientTrace",
"{",
"GetConn",
":",
"func",
"(",
"hostPort",
"string",
")",
"{",
"trace",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"trace",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"trace",
".",
"final",
"{",
"return",
"\n",
"}",
"\n",
"trace",
".",
"ConnectStart",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
",",
"GotConn",
":",
"func",
"(",
"info",
"httptrace",
".",
"GotConnInfo",
")",
"{",
"trace",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"trace",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"trace",
".",
"final",
"{",
"return",
"\n",
"}",
"\n",
"trace",
".",
"ConnectDone",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"trace",
".",
"ReusedConn",
"=",
"info",
".",
"Reused",
"\n",
"trace",
".",
"WasIdleConn",
"=",
"info",
".",
"WasIdle",
"\n",
"}",
",",
"WroteHeaders",
":",
"func",
"(",
")",
"{",
"trace",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"trace",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"trace",
".",
"final",
"{",
"return",
"\n",
"}",
"\n",
"trace",
".",
"HeadersWritten",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
",",
"WroteRequest",
":",
"func",
"(",
"info",
"httptrace",
".",
"WroteRequestInfo",
")",
"{",
"trace",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"trace",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"trace",
".",
"final",
"{",
"return",
"\n",
"}",
"\n",
"trace",
".",
"BodyWritten",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
",",
"GotFirstResponseByte",
":",
"func",
"(",
")",
"{",
"trace",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"trace",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"trace",
".",
"final",
"{",
"return",
"\n",
"}",
"\n",
"trace",
".",
"FirstByte",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
",",
"}",
"\n",
"req",
"=",
"req",
".",
"WithContext",
"(",
"httptrace",
".",
"WithClientTrace",
"(",
"req",
".",
"Context",
"(",
")",
",",
"ct",
")",
")",
"\n",
"return",
"req",
",",
"trace",
"\n",
"}"
] | // traceRequest sets up request tracing and returns the modified
// request. | [
"traceRequest",
"sets",
"up",
"request",
"tracing",
"and",
"returns",
"the",
"modified",
"request",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/router/proxy/transport.go#L281-L329 | train |
flynn/flynn | controller/worker/deployment/context.go | execWithRetries | func (c *context) execWithRetries(query string, args ...interface{}) error {
return execAttempts.Run(func() error {
return c.db.Exec(query, args...)
})
} | go | func (c *context) execWithRetries(query string, args ...interface{}) error {
return execAttempts.Run(func() error {
return c.db.Exec(query, args...)
})
} | [
"func",
"(",
"c",
"*",
"context",
")",
"execWithRetries",
"(",
"query",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"execAttempts",
".",
"Run",
"(",
"func",
"(",
")",
"error",
"{",
"return",
"c",
".",
"db",
".",
"Exec",
"(",
"query",
",",
"args",
"...",
")",
"\n",
"}",
")",
"\n",
"}"
] | // Retry db queries in case postgres has been deployed | [
"Retry",
"db",
"queries",
"in",
"case",
"postgres",
"has",
"been",
"deployed"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/worker/deployment/context.go#L180-L184 | train |
flynn/flynn | pkg/mauth/compare/compare.go | UnmarshalBinary | func UnmarshalBinary(b []byte) (interface{}, error) {
if len(b) < 1 {
return nil, fmt.Errorf("compare: buffer to unmarshal is zero-length")
}
switch Type(b[0]) {
case TypeFalse, TypeTrue:
v := new(Bool)
return *v, v.UnmarshalBinary(b)
case TypeIntegers:
v := new(Integers)
return *v, v.UnmarshalBinary(b)
case TypeStrings:
v := new(Strings)
return *v, v.UnmarshalBinary(b)
case TypeRegexp:
v := new(Regexp)
return v, v.UnmarshalBinary(b)
case TypeCIDRs:
v := new(CIDRs)
return *v, v.UnmarshalBinary(b)
default:
return nil, fmt.Errorf("compare: unknown type %d", b[0])
}
} | go | func UnmarshalBinary(b []byte) (interface{}, error) {
if len(b) < 1 {
return nil, fmt.Errorf("compare: buffer to unmarshal is zero-length")
}
switch Type(b[0]) {
case TypeFalse, TypeTrue:
v := new(Bool)
return *v, v.UnmarshalBinary(b)
case TypeIntegers:
v := new(Integers)
return *v, v.UnmarshalBinary(b)
case TypeStrings:
v := new(Strings)
return *v, v.UnmarshalBinary(b)
case TypeRegexp:
v := new(Regexp)
return v, v.UnmarshalBinary(b)
case TypeCIDRs:
v := new(CIDRs)
return *v, v.UnmarshalBinary(b)
default:
return nil, fmt.Errorf("compare: unknown type %d", b[0])
}
} | [
"func",
"UnmarshalBinary",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"len",
"(",
"b",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"switch",
"Type",
"(",
"b",
"[",
"0",
"]",
")",
"{",
"case",
"TypeFalse",
",",
"TypeTrue",
":",
"v",
":=",
"new",
"(",
"Bool",
")",
"\n",
"return",
"*",
"v",
",",
"v",
".",
"UnmarshalBinary",
"(",
"b",
")",
"\n",
"case",
"TypeIntegers",
":",
"v",
":=",
"new",
"(",
"Integers",
")",
"\n",
"return",
"*",
"v",
",",
"v",
".",
"UnmarshalBinary",
"(",
"b",
")",
"\n",
"case",
"TypeStrings",
":",
"v",
":=",
"new",
"(",
"Strings",
")",
"\n",
"return",
"*",
"v",
",",
"v",
".",
"UnmarshalBinary",
"(",
"b",
")",
"\n",
"case",
"TypeRegexp",
":",
"v",
":=",
"new",
"(",
"Regexp",
")",
"\n",
"return",
"v",
",",
"v",
".",
"UnmarshalBinary",
"(",
"b",
")",
"\n",
"case",
"TypeCIDRs",
":",
"v",
":=",
"new",
"(",
"CIDRs",
")",
"\n",
"return",
"*",
"v",
",",
"v",
".",
"UnmarshalBinary",
"(",
"b",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"b",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // comparisons are encoded as a single type byte followed by zero or more bytes
// that are specific to the comparison type.
//
// UINT8 - type
// UINT8 0..n - bytes | [
"comparisons",
"are",
"encoded",
"as",
"a",
"single",
"type",
"byte",
"followed",
"by",
"zero",
"or",
"more",
"bytes",
"that",
"are",
"specific",
"to",
"the",
"comparison",
"type",
".",
"UINT8",
"-",
"type",
"UINT8",
"0",
"..",
"n",
"-",
"bytes"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/mauth/compare/compare.go#L29-L52 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.