repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
flynn/flynn | host/logmux/logmux.go | jobDoneCh | func (m *Mux) jobDoneCh(jobID string, stop <-chan struct{}) <-chan struct{} {
ch := make(chan struct{})
go func() {
defer close(ch)
var started chan struct{}
m.jobsMtx.Lock()
// check if there is already a WaitGroup
wg, ok := m.jobWaits[jobID]
if !ok {
// if not, check if there is a channel to be notified when one is
// created
started, ok = m.jobStarts[jobID]
if !ok {
// if not, make and save the channel
started = make(chan struct{})
m.jobStarts[jobID] = started
}
}
m.jobsMtx.Unlock()
if started != nil {
// if the wg doesn't exist, wait for it
select {
case <-started:
case <-stop:
return
}
m.jobsMtx.Lock()
wg, ok = m.jobWaits[jobID]
m.jobsMtx.Unlock()
if !ok {
// if there is no wg, it was created and deleted before we could
// read it, we're done
return
}
}
// wait for the job to finish
wg.Wait()
}()
return ch
} | go | func (m *Mux) jobDoneCh(jobID string, stop <-chan struct{}) <-chan struct{} {
ch := make(chan struct{})
go func() {
defer close(ch)
var started chan struct{}
m.jobsMtx.Lock()
// check if there is already a WaitGroup
wg, ok := m.jobWaits[jobID]
if !ok {
// if not, check if there is a channel to be notified when one is
// created
started, ok = m.jobStarts[jobID]
if !ok {
// if not, make and save the channel
started = make(chan struct{})
m.jobStarts[jobID] = started
}
}
m.jobsMtx.Unlock()
if started != nil {
// if the wg doesn't exist, wait for it
select {
case <-started:
case <-stop:
return
}
m.jobsMtx.Lock()
wg, ok = m.jobWaits[jobID]
m.jobsMtx.Unlock()
if !ok {
// if there is no wg, it was created and deleted before we could
// read it, we're done
return
}
}
// wait for the job to finish
wg.Wait()
}()
return ch
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"jobDoneCh",
"(",
"jobID",
"string",
",",
"stop",
"<-",
"chan",
"struct",
"{",
"}",
")",
"<-",
"chan",
"struct",
"{",
"}",
"{",
"ch",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"ch",
")",
"\n",
"var",
"started",
"chan",
"struct",
"{",
"}",
"\n",
"m",
".",
"jobsMtx",
".",
"Lock",
"(",
")",
"\n",
"wg",
",",
"ok",
":=",
"m",
".",
"jobWaits",
"[",
"jobID",
"]",
"\n",
"if",
"!",
"ok",
"{",
"started",
",",
"ok",
"=",
"m",
".",
"jobStarts",
"[",
"jobID",
"]",
"\n",
"if",
"!",
"ok",
"{",
"started",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"m",
".",
"jobStarts",
"[",
"jobID",
"]",
"=",
"started",
"\n",
"}",
"\n",
"}",
"\n",
"m",
".",
"jobsMtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"started",
"!=",
"nil",
"{",
"select",
"{",
"case",
"<-",
"started",
":",
"case",
"<-",
"stop",
":",
"return",
"\n",
"}",
"\n",
"m",
".",
"jobsMtx",
".",
"Lock",
"(",
")",
"\n",
"wg",
",",
"ok",
"=",
"m",
".",
"jobWaits",
"[",
"jobID",
"]",
"\n",
"m",
".",
"jobsMtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"return",
"ch",
"\n",
"}"
] | // jobDoneCh returns a channel that is closed when all of the streams we are
// following from the job have been closed. It will never unblock if the job has
// already finished. | [
"jobDoneCh",
"returns",
"a",
"channel",
"that",
"is",
"closed",
"when",
"all",
"of",
"the",
"streams",
"we",
"are",
"following",
"from",
"the",
"job",
"have",
"been",
"closed",
".",
"It",
"will",
"never",
"unblock",
"if",
"the",
"job",
"has",
"already",
"finished",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/host/logmux/logmux.go#L407-L448 | train |
flynn/flynn | host/logmux/logmux.go | logFiles | func (m *Mux) logFiles(app string) (map[string][]string, error) {
files, err := ioutil.ReadDir(m.logDir)
if err != nil {
return nil, err
}
res := make(map[string][]string)
for _, f := range files {
n := f.Name()
if f.IsDir() || !strings.HasSuffix(n, ".log") || !appIDPrefixPattern.MatchString(n) || !strings.HasPrefix(n, app) {
continue
}
appID := n[:36]
res[appID] = append(res[appID], filepath.Join(m.logDir, n))
}
return res, nil
} | go | func (m *Mux) logFiles(app string) (map[string][]string, error) {
files, err := ioutil.ReadDir(m.logDir)
if err != nil {
return nil, err
}
res := make(map[string][]string)
for _, f := range files {
n := f.Name()
if f.IsDir() || !strings.HasSuffix(n, ".log") || !appIDPrefixPattern.MatchString(n) || !strings.HasPrefix(n, app) {
continue
}
appID := n[:36]
res[appID] = append(res[appID], filepath.Join(m.logDir, n))
}
return res, nil
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"logFiles",
"(",
"app",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
",",
"error",
")",
"{",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"m",
".",
"logDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"files",
"{",
"n",
":=",
"f",
".",
"Name",
"(",
")",
"\n",
"if",
"f",
".",
"IsDir",
"(",
")",
"||",
"!",
"strings",
".",
"HasSuffix",
"(",
"n",
",",
"\".log\"",
")",
"||",
"!",
"appIDPrefixPattern",
".",
"MatchString",
"(",
"n",
")",
"||",
"!",
"strings",
".",
"HasPrefix",
"(",
"n",
",",
"app",
")",
"{",
"continue",
"\n",
"}",
"\n",
"appID",
":=",
"n",
"[",
":",
"36",
"]",
"\n",
"res",
"[",
"appID",
"]",
"=",
"append",
"(",
"res",
"[",
"appID",
"]",
",",
"filepath",
".",
"Join",
"(",
"m",
".",
"logDir",
",",
"n",
")",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // logFiles returns a list of app IDs and the list of log file names associated
// with them, from oldest to newest. There is always at least one file, the
// current log for the app. | [
"logFiles",
"returns",
"a",
"list",
"of",
"app",
"IDs",
"and",
"the",
"list",
"of",
"log",
"file",
"names",
"associated",
"with",
"them",
"from",
"oldest",
"to",
"newest",
".",
"There",
"is",
"always",
"at",
"least",
"one",
"file",
"the",
"current",
"log",
"for",
"the",
"app",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/host/logmux/logmux.go#L620-L637 | train |
flynn/flynn | host/logmux/logmux.go | Release | func (l *appLog) Release() {
l.mtx.Lock()
defer l.mtx.Unlock()
l.refs--
if l.refs == 0 {
// we're the last user, clean it up
l.l.Close()
l.m.appLogsMtx.Lock()
delete(l.m.appLogs, l.appID)
l.m.appLogsMtx.Unlock()
}
} | go | func (l *appLog) Release() {
l.mtx.Lock()
defer l.mtx.Unlock()
l.refs--
if l.refs == 0 {
// we're the last user, clean it up
l.l.Close()
l.m.appLogsMtx.Lock()
delete(l.m.appLogs, l.appID)
l.m.appLogsMtx.Unlock()
}
} | [
"func",
"(",
"l",
"*",
"appLog",
")",
"Release",
"(",
")",
"{",
"l",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"l",
".",
"refs",
"--",
"\n",
"if",
"l",
".",
"refs",
"==",
"0",
"{",
"l",
".",
"l",
".",
"Close",
"(",
")",
"\n",
"l",
".",
"m",
".",
"appLogsMtx",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"l",
".",
"m",
".",
"appLogs",
",",
"l",
".",
"appID",
")",
"\n",
"l",
".",
"m",
".",
"appLogsMtx",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Release releases the app log, when the last job releases an app log, it is
// closed. | [
"Release",
"releases",
"the",
"app",
"log",
"when",
"the",
"last",
"job",
"releases",
"an",
"app",
"log",
"it",
"is",
"closed",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/host/logmux/logmux.go#L684-L695 | train |
flynn/flynn | router/tree.go | Insert | func (n *node) Insert(path string, backend *httpRoute) {
cur := n
for part, i := slice(path, 0); ; part, i = slice(path, i) {
if part != "" {
child, _ := cur.children[part]
if child == nil {
// insert node if it doesn't exist
child = &node{children: make(map[string]*node, 0)}
cur.children[part] = child
}
cur = child
}
if i == -1 {
break
}
}
cur.backend = backend // finally set the backend for this node
} | go | func (n *node) Insert(path string, backend *httpRoute) {
cur := n
for part, i := slice(path, 0); ; part, i = slice(path, i) {
if part != "" {
child, _ := cur.children[part]
if child == nil {
// insert node if it doesn't exist
child = &node{children: make(map[string]*node, 0)}
cur.children[part] = child
}
cur = child
}
if i == -1 {
break
}
}
cur.backend = backend // finally set the backend for this node
} | [
"func",
"(",
"n",
"*",
"node",
")",
"Insert",
"(",
"path",
"string",
",",
"backend",
"*",
"httpRoute",
")",
"{",
"cur",
":=",
"n",
"\n",
"for",
"part",
",",
"i",
":=",
"slice",
"(",
"path",
",",
"0",
")",
";",
";",
"part",
",",
"i",
"=",
"slice",
"(",
"path",
",",
"i",
")",
"{",
"if",
"part",
"!=",
"\"\"",
"{",
"child",
",",
"_",
":=",
"cur",
".",
"children",
"[",
"part",
"]",
"\n",
"if",
"child",
"==",
"nil",
"{",
"child",
"=",
"&",
"node",
"{",
"children",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"node",
",",
"0",
")",
"}",
"\n",
"cur",
".",
"children",
"[",
"part",
"]",
"=",
"child",
"\n",
"}",
"\n",
"cur",
"=",
"child",
"\n",
"}",
"\n",
"if",
"i",
"==",
"-",
"1",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"cur",
".",
"backend",
"=",
"backend",
"\n",
"}"
] | // insert a new route into the tree, replacing entry if it exists | [
"insert",
"a",
"new",
"route",
"into",
"the",
"tree",
"replacing",
"entry",
"if",
"it",
"exists"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/router/tree.go#L20-L37 | train |
flynn/flynn | router/tree.go | Lookup | func (n *node) Lookup(path string) *httpRoute {
cur := n
prev := n
for part, i := slice(path, 0); ; part, i = slice(path, i) {
if part != "" {
cur = cur.children[part]
if cur == nil {
// can't progress any deeper, return last backend we saw
return prev.backend
}
if cur.backend != nil {
prev = cur // update last seen backend
}
}
if i == -1 {
break
}
}
if cur.backend != nil {
return cur.backend
}
return prev.backend
} | go | func (n *node) Lookup(path string) *httpRoute {
cur := n
prev := n
for part, i := slice(path, 0); ; part, i = slice(path, i) {
if part != "" {
cur = cur.children[part]
if cur == nil {
// can't progress any deeper, return last backend we saw
return prev.backend
}
if cur.backend != nil {
prev = cur // update last seen backend
}
}
if i == -1 {
break
}
}
if cur.backend != nil {
return cur.backend
}
return prev.backend
} | [
"func",
"(",
"n",
"*",
"node",
")",
"Lookup",
"(",
"path",
"string",
")",
"*",
"httpRoute",
"{",
"cur",
":=",
"n",
"\n",
"prev",
":=",
"n",
"\n",
"for",
"part",
",",
"i",
":=",
"slice",
"(",
"path",
",",
"0",
")",
";",
";",
"part",
",",
"i",
"=",
"slice",
"(",
"path",
",",
"i",
")",
"{",
"if",
"part",
"!=",
"\"\"",
"{",
"cur",
"=",
"cur",
".",
"children",
"[",
"part",
"]",
"\n",
"if",
"cur",
"==",
"nil",
"{",
"return",
"prev",
".",
"backend",
"\n",
"}",
"\n",
"if",
"cur",
".",
"backend",
"!=",
"nil",
"{",
"prev",
"=",
"cur",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"i",
"==",
"-",
"1",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"cur",
".",
"backend",
"!=",
"nil",
"{",
"return",
"cur",
".",
"backend",
"\n",
"}",
"\n",
"return",
"prev",
".",
"backend",
"\n",
"}"
] | // lookup returns the best match for a given path | [
"lookup",
"returns",
"the",
"best",
"match",
"for",
"a",
"given",
"path"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/router/tree.go#L40-L62 | train |
flynn/flynn | router/tree.go | slice | func slice(path string, start int) (segment string, next int) {
if len(path) == 0 || start < 0 || start >= len(path) {
return "", -1
}
end := strings.IndexRune(path[start:], '/')
if end == -1 {
return path[start:], -1
}
if path[start:start+end] == "/" {
return "", start + end + 1
}
return path[start : start+end], start + end + 1
} | go | func slice(path string, start int) (segment string, next int) {
if len(path) == 0 || start < 0 || start >= len(path) {
return "", -1
}
end := strings.IndexRune(path[start:], '/')
if end == -1 {
return path[start:], -1
}
if path[start:start+end] == "/" {
return "", start + end + 1
}
return path[start : start+end], start + end + 1
} | [
"func",
"slice",
"(",
"path",
"string",
",",
"start",
"int",
")",
"(",
"segment",
"string",
",",
"next",
"int",
")",
"{",
"if",
"len",
"(",
"path",
")",
"==",
"0",
"||",
"start",
"<",
"0",
"||",
"start",
">=",
"len",
"(",
"path",
")",
"{",
"return",
"\"\"",
",",
"-",
"1",
"\n",
"}",
"\n",
"end",
":=",
"strings",
".",
"IndexRune",
"(",
"path",
"[",
"start",
":",
"]",
",",
"'/'",
")",
"\n",
"if",
"end",
"==",
"-",
"1",
"{",
"return",
"path",
"[",
"start",
":",
"]",
",",
"-",
"1",
"\n",
"}",
"\n",
"if",
"path",
"[",
"start",
":",
"start",
"+",
"end",
"]",
"==",
"\"/\"",
"{",
"return",
"\"\"",
",",
"start",
"+",
"end",
"+",
"1",
"\n",
"}",
"\n",
"return",
"path",
"[",
"start",
":",
"start",
"+",
"end",
"]",
",",
"start",
"+",
"end",
"+",
"1",
"\n",
"}"
] | // slices string into path segments performing 0 heap allocation | [
"slices",
"string",
"into",
"path",
"segments",
"performing",
"0",
"heap",
"allocation"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/router/tree.go#L99-L111 | train |
flynn/flynn | controller/events.go | Notify | func (e *EventSubscriber) Notify(event *ct.Event) {
if len(e.objectTypes) > 0 {
foundType := false
for _, typ := range e.objectTypes {
if typ == string(event.ObjectType) {
foundType = true
break
}
}
if !foundType {
return
}
}
if e.objectID != "" && e.objectID != event.ObjectID {
return
}
select {
case e.queue <- event:
default:
// Run in a goroutine to avoid deadlock with Notify
go e.CloseWithError(ErrEventBufferOverflow)
}
} | go | func (e *EventSubscriber) Notify(event *ct.Event) {
if len(e.objectTypes) > 0 {
foundType := false
for _, typ := range e.objectTypes {
if typ == string(event.ObjectType) {
foundType = true
break
}
}
if !foundType {
return
}
}
if e.objectID != "" && e.objectID != event.ObjectID {
return
}
select {
case e.queue <- event:
default:
// Run in a goroutine to avoid deadlock with Notify
go e.CloseWithError(ErrEventBufferOverflow)
}
} | [
"func",
"(",
"e",
"*",
"EventSubscriber",
")",
"Notify",
"(",
"event",
"*",
"ct",
".",
"Event",
")",
"{",
"if",
"len",
"(",
"e",
".",
"objectTypes",
")",
">",
"0",
"{",
"foundType",
":=",
"false",
"\n",
"for",
"_",
",",
"typ",
":=",
"range",
"e",
".",
"objectTypes",
"{",
"if",
"typ",
"==",
"string",
"(",
"event",
".",
"ObjectType",
")",
"{",
"foundType",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"foundType",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"e",
".",
"objectID",
"!=",
"\"\"",
"&&",
"e",
".",
"objectID",
"!=",
"event",
".",
"ObjectID",
"{",
"return",
"\n",
"}",
"\n",
"select",
"{",
"case",
"e",
".",
"queue",
"<-",
"event",
":",
"default",
":",
"go",
"e",
".",
"CloseWithError",
"(",
"ErrEventBufferOverflow",
")",
"\n",
"}",
"\n",
"}"
] | // Notify filters the event based on it's type and objectID and then pushes
// it to the event queue. | [
"Notify",
"filters",
"the",
"event",
"based",
"on",
"it",
"s",
"type",
"and",
"objectID",
"and",
"then",
"pushes",
"it",
"to",
"the",
"event",
"queue",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L328-L350 | train |
flynn/flynn | controller/events.go | loop | func (e *EventSubscriber) loop() {
defer close(e.Events)
for {
select {
case <-e.stop:
return
case event := <-e.queue:
e.Events <- event
}
}
} | go | func (e *EventSubscriber) loop() {
defer close(e.Events)
for {
select {
case <-e.stop:
return
case event := <-e.queue:
e.Events <- event
}
}
} | [
"func",
"(",
"e",
"*",
"EventSubscriber",
")",
"loop",
"(",
")",
"{",
"defer",
"close",
"(",
"e",
".",
"Events",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"e",
".",
"stop",
":",
"return",
"\n",
"case",
"event",
":=",
"<-",
"e",
".",
"queue",
":",
"e",
".",
"Events",
"<-",
"event",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // loop pops events off the queue and sends them to the Events channel. | [
"loop",
"pops",
"events",
"off",
"the",
"queue",
"and",
"sends",
"them",
"to",
"the",
"Events",
"channel",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L353-L363 | train |
flynn/flynn | controller/events.go | Close | func (e *EventSubscriber) Close() {
e.l.Unsubscribe(e)
e.stopOnce.Do(func() { close(e.stop) })
} | go | func (e *EventSubscriber) Close() {
e.l.Unsubscribe(e)
e.stopOnce.Do(func() { close(e.stop) })
} | [
"func",
"(",
"e",
"*",
"EventSubscriber",
")",
"Close",
"(",
")",
"{",
"e",
".",
"l",
".",
"Unsubscribe",
"(",
"e",
")",
"\n",
"e",
".",
"stopOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"e",
".",
"stop",
")",
"}",
")",
"\n",
"}"
] | // Close unsubscribes from the EventListener and stops the loop. | [
"Close",
"unsubscribes",
"from",
"the",
"EventListener",
"and",
"stops",
"the",
"loop",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L366-L369 | train |
flynn/flynn | controller/events.go | CloseWithError | func (e *EventSubscriber) CloseWithError(err error) {
e.errOnce.Do(func() { e.Err = err })
e.Close()
} | go | func (e *EventSubscriber) CloseWithError(err error) {
e.errOnce.Do(func() { e.Err = err })
e.Close()
} | [
"func",
"(",
"e",
"*",
"EventSubscriber",
")",
"CloseWithError",
"(",
"err",
"error",
")",
"{",
"e",
".",
"errOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"e",
".",
"Err",
"=",
"err",
"}",
")",
"\n",
"e",
".",
"Close",
"(",
")",
"\n",
"}"
] | // CloseWithError sets the Err field and then closes the subscriber. | [
"CloseWithError",
"sets",
"the",
"Err",
"field",
"and",
"then",
"closes",
"the",
"subscriber",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L372-L375 | train |
flynn/flynn | controller/events.go | Subscribe | func (e *EventListener) Subscribe(appID string, objectTypes []string, objectID string) (*EventSubscriber, error) {
e.subMtx.Lock()
defer e.subMtx.Unlock()
if e.IsClosed() {
return nil, errors.New("event listener closed")
}
s := &EventSubscriber{
Events: make(chan *ct.Event),
l: e,
queue: make(chan *ct.Event, eventBufferSize),
stop: make(chan struct{}),
appID: appID,
objectTypes: objectTypes,
objectID: objectID,
}
go s.loop()
if _, ok := e.subscribers[appID]; !ok {
e.subscribers[appID] = make(map[*EventSubscriber]struct{})
}
e.subscribers[appID][s] = struct{}{}
return s, nil
} | go | func (e *EventListener) Subscribe(appID string, objectTypes []string, objectID string) (*EventSubscriber, error) {
e.subMtx.Lock()
defer e.subMtx.Unlock()
if e.IsClosed() {
return nil, errors.New("event listener closed")
}
s := &EventSubscriber{
Events: make(chan *ct.Event),
l: e,
queue: make(chan *ct.Event, eventBufferSize),
stop: make(chan struct{}),
appID: appID,
objectTypes: objectTypes,
objectID: objectID,
}
go s.loop()
if _, ok := e.subscribers[appID]; !ok {
e.subscribers[appID] = make(map[*EventSubscriber]struct{})
}
e.subscribers[appID][s] = struct{}{}
return s, nil
} | [
"func",
"(",
"e",
"*",
"EventListener",
")",
"Subscribe",
"(",
"appID",
"string",
",",
"objectTypes",
"[",
"]",
"string",
",",
"objectID",
"string",
")",
"(",
"*",
"EventSubscriber",
",",
"error",
")",
"{",
"e",
".",
"subMtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"subMtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"e",
".",
"IsClosed",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"event listener closed\"",
")",
"\n",
"}",
"\n",
"s",
":=",
"&",
"EventSubscriber",
"{",
"Events",
":",
"make",
"(",
"chan",
"*",
"ct",
".",
"Event",
")",
",",
"l",
":",
"e",
",",
"queue",
":",
"make",
"(",
"chan",
"*",
"ct",
".",
"Event",
",",
"eventBufferSize",
")",
",",
"stop",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"appID",
":",
"appID",
",",
"objectTypes",
":",
"objectTypes",
",",
"objectID",
":",
"objectID",
",",
"}",
"\n",
"go",
"s",
".",
"loop",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"e",
".",
"subscribers",
"[",
"appID",
"]",
";",
"!",
"ok",
"{",
"e",
".",
"subscribers",
"[",
"appID",
"]",
"=",
"make",
"(",
"map",
"[",
"*",
"EventSubscriber",
"]",
"struct",
"{",
"}",
")",
"\n",
"}",
"\n",
"e",
".",
"subscribers",
"[",
"appID",
"]",
"[",
"s",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] | // Subscribe creates and returns an EventSubscriber for the given app, type and object.
// Using an empty string for appID subscribes to all apps | [
"Subscribe",
"creates",
"and",
"returns",
"an",
"EventSubscriber",
"for",
"the",
"given",
"app",
"type",
"and",
"object",
".",
"Using",
"an",
"empty",
"string",
"for",
"appID",
"subscribes",
"to",
"all",
"apps"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L400-L421 | train |
flynn/flynn | controller/events.go | Unsubscribe | func (e *EventListener) Unsubscribe(s *EventSubscriber) {
e.subMtx.Lock()
defer e.subMtx.Unlock()
if subs, ok := e.subscribers[s.appID]; ok {
delete(subs, s)
if len(subs) == 0 {
delete(e.subscribers, s.appID)
}
}
} | go | func (e *EventListener) Unsubscribe(s *EventSubscriber) {
e.subMtx.Lock()
defer e.subMtx.Unlock()
if subs, ok := e.subscribers[s.appID]; ok {
delete(subs, s)
if len(subs) == 0 {
delete(e.subscribers, s.appID)
}
}
} | [
"func",
"(",
"e",
"*",
"EventListener",
")",
"Unsubscribe",
"(",
"s",
"*",
"EventSubscriber",
")",
"{",
"e",
".",
"subMtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"subMtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"subs",
",",
"ok",
":=",
"e",
".",
"subscribers",
"[",
"s",
".",
"appID",
"]",
";",
"ok",
"{",
"delete",
"(",
"subs",
",",
"s",
")",
"\n",
"if",
"len",
"(",
"subs",
")",
"==",
"0",
"{",
"delete",
"(",
"e",
".",
"subscribers",
",",
"s",
".",
"appID",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Unsubscribe unsubscribes the given subscriber. | [
"Unsubscribe",
"unsubscribes",
"the",
"given",
"subscriber",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L424-L433 | train |
flynn/flynn | controller/events.go | Listen | func (e *EventListener) Listen() error {
log := logger.New("fn", "EventListener.Listen")
listener, err := e.eventRepo.db.Listen("events", log)
if err != nil {
e.CloseWithError(err)
return err
}
go func() {
for {
select {
case n, ok := <-listener.Notify:
if !ok {
e.CloseWithError(listener.Err)
return
}
idApp := strings.SplitN(n.Payload, ":", 2)
if len(idApp) < 1 {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload))
continue
}
id, err := strconv.ParseInt(idApp[0], 10, 64)
if err != nil {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload), "err", err)
continue
}
event, err := e.eventRepo.GetEvent(id)
if err != nil {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload), "err", err)
continue
}
e.Notify(event)
case <-e.doneCh:
listener.Close()
return
}
}
}()
return nil
} | go | func (e *EventListener) Listen() error {
log := logger.New("fn", "EventListener.Listen")
listener, err := e.eventRepo.db.Listen("events", log)
if err != nil {
e.CloseWithError(err)
return err
}
go func() {
for {
select {
case n, ok := <-listener.Notify:
if !ok {
e.CloseWithError(listener.Err)
return
}
idApp := strings.SplitN(n.Payload, ":", 2)
if len(idApp) < 1 {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload))
continue
}
id, err := strconv.ParseInt(idApp[0], 10, 64)
if err != nil {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload), "err", err)
continue
}
event, err := e.eventRepo.GetEvent(id)
if err != nil {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload), "err", err)
continue
}
e.Notify(event)
case <-e.doneCh:
listener.Close()
return
}
}
}()
return nil
} | [
"func",
"(",
"e",
"*",
"EventListener",
")",
"Listen",
"(",
")",
"error",
"{",
"log",
":=",
"logger",
".",
"New",
"(",
"\"fn\"",
",",
"\"EventListener.Listen\"",
")",
"\n",
"listener",
",",
"err",
":=",
"e",
".",
"eventRepo",
".",
"db",
".",
"Listen",
"(",
"\"events\"",
",",
"log",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"e",
".",
"CloseWithError",
"(",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"n",
",",
"ok",
":=",
"<-",
"listener",
".",
"Notify",
":",
"if",
"!",
"ok",
"{",
"e",
".",
"CloseWithError",
"(",
"listener",
".",
"Err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"idApp",
":=",
"strings",
".",
"SplitN",
"(",
"n",
".",
"Payload",
",",
"\":\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"idApp",
")",
"<",
"1",
"{",
"log",
".",
"Error",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"invalid event notification: %q\"",
",",
"n",
".",
"Payload",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"id",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"idApp",
"[",
"0",
"]",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"invalid event notification: %q\"",
",",
"n",
".",
"Payload",
")",
",",
"\"err\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"event",
",",
"err",
":=",
"e",
".",
"eventRepo",
".",
"GetEvent",
"(",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"invalid event notification: %q\"",
",",
"n",
".",
"Payload",
")",
",",
"\"err\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"e",
".",
"Notify",
"(",
"event",
")",
"\n",
"case",
"<-",
"e",
".",
"doneCh",
":",
"listener",
".",
"Close",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Listen creates a postgres listener for events and starts a goroutine to
// forward the events to subscribers. | [
"Listen",
"creates",
"a",
"postgres",
"listener",
"for",
"events",
"and",
"starts",
"a",
"goroutine",
"to",
"forward",
"the",
"events",
"to",
"subscribers",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L437-L475 | train |
flynn/flynn | controller/events.go | Notify | func (e *EventListener) Notify(event *ct.Event) {
e.subMtx.RLock()
defer e.subMtx.RUnlock()
if subs, ok := e.subscribers[event.AppID]; ok {
for sub := range subs {
sub.Notify(event)
}
}
if event.AppID != "" {
// Ensure subscribers not filtering by app get the event
if subs, ok := e.subscribers[""]; ok {
for sub := range subs {
sub.Notify(event)
}
}
}
} | go | func (e *EventListener) Notify(event *ct.Event) {
e.subMtx.RLock()
defer e.subMtx.RUnlock()
if subs, ok := e.subscribers[event.AppID]; ok {
for sub := range subs {
sub.Notify(event)
}
}
if event.AppID != "" {
// Ensure subscribers not filtering by app get the event
if subs, ok := e.subscribers[""]; ok {
for sub := range subs {
sub.Notify(event)
}
}
}
} | [
"func",
"(",
"e",
"*",
"EventListener",
")",
"Notify",
"(",
"event",
"*",
"ct",
".",
"Event",
")",
"{",
"e",
".",
"subMtx",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"subMtx",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"subs",
",",
"ok",
":=",
"e",
".",
"subscribers",
"[",
"event",
".",
"AppID",
"]",
";",
"ok",
"{",
"for",
"sub",
":=",
"range",
"subs",
"{",
"sub",
".",
"Notify",
"(",
"event",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"event",
".",
"AppID",
"!=",
"\"\"",
"{",
"if",
"subs",
",",
"ok",
":=",
"e",
".",
"subscribers",
"[",
"\"\"",
"]",
";",
"ok",
"{",
"for",
"sub",
":=",
"range",
"subs",
"{",
"sub",
".",
"Notify",
"(",
"event",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Notify notifies all sbscribers of the given event. | [
"Notify",
"notifies",
"all",
"sbscribers",
"of",
"the",
"given",
"event",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L478-L494 | train |
flynn/flynn | controller/events.go | IsClosed | func (e *EventListener) IsClosed() bool {
e.closedMtx.RLock()
defer e.closedMtx.RUnlock()
return e.closed
} | go | func (e *EventListener) IsClosed() bool {
e.closedMtx.RLock()
defer e.closedMtx.RUnlock()
return e.closed
} | [
"func",
"(",
"e",
"*",
"EventListener",
")",
"IsClosed",
"(",
")",
"bool",
"{",
"e",
".",
"closedMtx",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"closedMtx",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"e",
".",
"closed",
"\n",
"}"
] | // IsClosed returns whether or not the listener is closed. | [
"IsClosed",
"returns",
"whether",
"or",
"not",
"the",
"listener",
"is",
"closed",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L497-L501 | train |
flynn/flynn | controller/events.go | CloseWithError | func (e *EventListener) CloseWithError(err error) {
e.closedMtx.Lock()
if e.closed {
e.closedMtx.Unlock()
return
}
e.closed = true
e.closedMtx.Unlock()
e.subMtx.RLock()
defer e.subMtx.RUnlock()
subscribers := e.subscribers
for _, subs := range subscribers {
for sub := range subs {
go sub.CloseWithError(err)
}
}
close(e.doneCh)
} | go | func (e *EventListener) CloseWithError(err error) {
e.closedMtx.Lock()
if e.closed {
e.closedMtx.Unlock()
return
}
e.closed = true
e.closedMtx.Unlock()
e.subMtx.RLock()
defer e.subMtx.RUnlock()
subscribers := e.subscribers
for _, subs := range subscribers {
for sub := range subs {
go sub.CloseWithError(err)
}
}
close(e.doneCh)
} | [
"func",
"(",
"e",
"*",
"EventListener",
")",
"CloseWithError",
"(",
"err",
"error",
")",
"{",
"e",
".",
"closedMtx",
".",
"Lock",
"(",
")",
"\n",
"if",
"e",
".",
"closed",
"{",
"e",
".",
"closedMtx",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"e",
".",
"closed",
"=",
"true",
"\n",
"e",
".",
"closedMtx",
".",
"Unlock",
"(",
")",
"\n",
"e",
".",
"subMtx",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"subMtx",
".",
"RUnlock",
"(",
")",
"\n",
"subscribers",
":=",
"e",
".",
"subscribers",
"\n",
"for",
"_",
",",
"subs",
":=",
"range",
"subscribers",
"{",
"for",
"sub",
":=",
"range",
"subs",
"{",
"go",
"sub",
".",
"CloseWithError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"close",
"(",
"e",
".",
"doneCh",
")",
"\n",
"}"
] | // CloseWithError marks the listener as closed and closes all subscribers
// with the given error. | [
"CloseWithError",
"marks",
"the",
"listener",
"as",
"closed",
"and",
"closes",
"all",
"subscribers",
"with",
"the",
"given",
"error",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/controller/events.go#L505-L523 | train |
flynn/flynn | pkg/rpcplus/server.go | prepareMethod | func prepareMethod(method reflect.Method) *methodType {
mtype := method.Type
mname := method.Name
var replyType, argType, contextType reflect.Type
stream := false
// Method must be exported.
if method.PkgPath != "" {
return nil
}
switch mtype.NumIn() {
case 3:
// normal method
argType = mtype.In(1)
replyType = mtype.In(2)
contextType = nil
case 4:
// method that takes a context
argType = mtype.In(2)
replyType = mtype.In(3)
contextType = mtype.In(1)
default:
log.Println("method", mname, "of", mtype, "has wrong number of ins:", mtype.NumIn())
return nil
}
// First arg need not be a pointer.
if !isExportedOrBuiltinType(argType) {
log.Println(mname, "argument type not exported:", argType)
return nil
}
// the second argument will tell us if it's a streaming call
// or a regular call
if replyType == typeOfStream {
// this is a streaming call
stream = true
} else if replyType.Kind() != reflect.Ptr {
log.Println("method", mname, "reply type not a pointer:", replyType)
return nil
}
// Reply type must be exported.
if !isExportedOrBuiltinType(replyType) {
log.Println("method", mname, "reply type not exported:", replyType)
return nil
}
// Method needs one out.
if mtype.NumOut() != 1 {
log.Println("method", mname, "has wrong number of outs:", mtype.NumOut())
return nil
}
// The return type of the method must be error.
if returnType := mtype.Out(0); returnType != typeOfError {
log.Println("method", mname, "returns", returnType.String(), "not error")
return nil
}
return &methodType{method: method, ArgType: argType, ReplyType: replyType, ContextType: contextType, stream: stream}
} | go | func prepareMethod(method reflect.Method) *methodType {
mtype := method.Type
mname := method.Name
var replyType, argType, contextType reflect.Type
stream := false
// Method must be exported.
if method.PkgPath != "" {
return nil
}
switch mtype.NumIn() {
case 3:
// normal method
argType = mtype.In(1)
replyType = mtype.In(2)
contextType = nil
case 4:
// method that takes a context
argType = mtype.In(2)
replyType = mtype.In(3)
contextType = mtype.In(1)
default:
log.Println("method", mname, "of", mtype, "has wrong number of ins:", mtype.NumIn())
return nil
}
// First arg need not be a pointer.
if !isExportedOrBuiltinType(argType) {
log.Println(mname, "argument type not exported:", argType)
return nil
}
// the second argument will tell us if it's a streaming call
// or a regular call
if replyType == typeOfStream {
// this is a streaming call
stream = true
} else if replyType.Kind() != reflect.Ptr {
log.Println("method", mname, "reply type not a pointer:", replyType)
return nil
}
// Reply type must be exported.
if !isExportedOrBuiltinType(replyType) {
log.Println("method", mname, "reply type not exported:", replyType)
return nil
}
// Method needs one out.
if mtype.NumOut() != 1 {
log.Println("method", mname, "has wrong number of outs:", mtype.NumOut())
return nil
}
// The return type of the method must be error.
if returnType := mtype.Out(0); returnType != typeOfError {
log.Println("method", mname, "returns", returnType.String(), "not error")
return nil
}
return &methodType{method: method, ArgType: argType, ReplyType: replyType, ContextType: contextType, stream: stream}
} | [
"func",
"prepareMethod",
"(",
"method",
"reflect",
".",
"Method",
")",
"*",
"methodType",
"{",
"mtype",
":=",
"method",
".",
"Type",
"\n",
"mname",
":=",
"method",
".",
"Name",
"\n",
"var",
"replyType",
",",
"argType",
",",
"contextType",
"reflect",
".",
"Type",
"\n",
"stream",
":=",
"false",
"\n",
"if",
"method",
".",
"PkgPath",
"!=",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"switch",
"mtype",
".",
"NumIn",
"(",
")",
"{",
"case",
"3",
":",
"argType",
"=",
"mtype",
".",
"In",
"(",
"1",
")",
"\n",
"replyType",
"=",
"mtype",
".",
"In",
"(",
"2",
")",
"\n",
"contextType",
"=",
"nil",
"\n",
"case",
"4",
":",
"argType",
"=",
"mtype",
".",
"In",
"(",
"2",
")",
"\n",
"replyType",
"=",
"mtype",
".",
"In",
"(",
"3",
")",
"\n",
"contextType",
"=",
"mtype",
".",
"In",
"(",
"1",
")",
"\n",
"default",
":",
"log",
".",
"Println",
"(",
"\"method\"",
",",
"mname",
",",
"\"of\"",
",",
"mtype",
",",
"\"has wrong number of ins:\"",
",",
"mtype",
".",
"NumIn",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"isExportedOrBuiltinType",
"(",
"argType",
")",
"{",
"log",
".",
"Println",
"(",
"mname",
",",
"\"argument type not exported:\"",
",",
"argType",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"replyType",
"==",
"typeOfStream",
"{",
"stream",
"=",
"true",
"\n",
"}",
"else",
"if",
"replyType",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"log",
".",
"Println",
"(",
"\"method\"",
",",
"mname",
",",
"\"reply type not a pointer:\"",
",",
"replyType",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"isExportedOrBuiltinType",
"(",
"replyType",
")",
"{",
"log",
".",
"Println",
"(",
"\"method\"",
",",
"mname",
",",
"\"reply type not exported:\"",
",",
"replyType",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"mtype",
".",
"NumOut",
"(",
")",
"!=",
"1",
"{",
"log",
".",
"Println",
"(",
"\"method\"",
",",
"mname",
",",
"\"has wrong number of outs:\"",
",",
"mtype",
".",
"NumOut",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"returnType",
":=",
"mtype",
".",
"Out",
"(",
"0",
")",
";",
"returnType",
"!=",
"typeOfError",
"{",
"log",
".",
"Println",
"(",
"\"method\"",
",",
"mname",
",",
"\"returns\"",
",",
"returnType",
".",
"String",
"(",
")",
",",
"\"not error\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"methodType",
"{",
"method",
":",
"method",
",",
"ArgType",
":",
"argType",
",",
"ReplyType",
":",
"replyType",
",",
"ContextType",
":",
"contextType",
",",
"stream",
":",
"stream",
"}",
"\n",
"}"
] | // prepareMethod returns a methodType for the provided method or nil
// in case if the method was unsuitable. | [
"prepareMethod",
"returns",
"a",
"methodType",
"for",
"the",
"provided",
"method",
"or",
"nil",
"in",
"case",
"if",
"the",
"method",
"was",
"unsuitable",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/server.go#L261-L320 | train |
flynn/flynn | pkg/rpcplus/server.go | ServeConnWithContext | func (server *Server) ServeConnWithContext(conn io.ReadWriteCloser, context interface{}) {
buf := bufio.NewWriter(conn)
srv := &gobServerCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(buf), buf}
server.ServeCodecWithContext(srv, context)
} | go | func (server *Server) ServeConnWithContext(conn io.ReadWriteCloser, context interface{}) {
buf := bufio.NewWriter(conn)
srv := &gobServerCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(buf), buf}
server.ServeCodecWithContext(srv, context)
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"ServeConnWithContext",
"(",
"conn",
"io",
".",
"ReadWriteCloser",
",",
"context",
"interface",
"{",
"}",
")",
"{",
"buf",
":=",
"bufio",
".",
"NewWriter",
"(",
"conn",
")",
"\n",
"srv",
":=",
"&",
"gobServerCodec",
"{",
"conn",
",",
"gob",
".",
"NewDecoder",
"(",
"conn",
")",
",",
"gob",
".",
"NewEncoder",
"(",
"buf",
")",
",",
"buf",
"}",
"\n",
"server",
".",
"ServeCodecWithContext",
"(",
"srv",
",",
"context",
")",
"\n",
"}"
] | // ServeConnWithContext is like ServeConn but makes it possible to
// pass a connection context to the RPC methods. | [
"ServeConnWithContext",
"is",
"like",
"ServeConn",
"but",
"makes",
"it",
"possible",
"to",
"pass",
"a",
"connection",
"context",
"to",
"the",
"RPC",
"methods",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/server.go#L538-L542 | train |
flynn/flynn | pkg/rpcplus/server.go | ServeCodecWithContext | func (server *Server) ServeCodecWithContext(codec ServerCodec, context interface{}) {
sending := new(sync.Mutex)
eof := make(chan struct{})
stopChans := make(map[uint64]chan struct{})
var stopChansMtx sync.Mutex
var contextVal reflect.Value
if context != nil {
contextVal = reflect.ValueOf(context)
} else {
contextVal = reflect.New(server.contextType)
}
for {
service, mtype, req, argv, replyv, keepReading, err := server.readRequest(codec)
if err != nil {
if err == errCloseStream {
go func() {
stopChansMtx.Lock()
stop, ok := stopChans[req.Seq]
delete(stopChans, req.Seq)
stopChansMtx.Unlock()
if !ok {
return
}
close(stop)
}()
continue
}
if !keepReading {
break
}
// send a response if we actually managed to read a header.
if req != nil {
server.sendResponse(sending, req, invalidRequest, codec, err.Error(), true)
server.freeRequest(req)
}
continue
}
done := make(chan struct{})
stop := make(chan struct{})
stopChansMtx.Lock()
stopChans[req.Seq] = stop
stopChansMtx.Unlock()
go func(seq uint64) {
<-done
stopChansMtx.Lock()
delete(stopChans, seq)
stopChansMtx.Unlock()
}(req.Seq)
go service.call(call{
server: server,
sending: sending,
mtype: mtype,
req: req,
argv: argv,
replyv: replyv,
codec: codec,
context: contextVal,
eof: eof,
done: done,
stop: stop,
})
}
close(eof)
codec.Close()
} | go | func (server *Server) ServeCodecWithContext(codec ServerCodec, context interface{}) {
sending := new(sync.Mutex)
eof := make(chan struct{})
stopChans := make(map[uint64]chan struct{})
var stopChansMtx sync.Mutex
var contextVal reflect.Value
if context != nil {
contextVal = reflect.ValueOf(context)
} else {
contextVal = reflect.New(server.contextType)
}
for {
service, mtype, req, argv, replyv, keepReading, err := server.readRequest(codec)
if err != nil {
if err == errCloseStream {
go func() {
stopChansMtx.Lock()
stop, ok := stopChans[req.Seq]
delete(stopChans, req.Seq)
stopChansMtx.Unlock()
if !ok {
return
}
close(stop)
}()
continue
}
if !keepReading {
break
}
// send a response if we actually managed to read a header.
if req != nil {
server.sendResponse(sending, req, invalidRequest, codec, err.Error(), true)
server.freeRequest(req)
}
continue
}
done := make(chan struct{})
stop := make(chan struct{})
stopChansMtx.Lock()
stopChans[req.Seq] = stop
stopChansMtx.Unlock()
go func(seq uint64) {
<-done
stopChansMtx.Lock()
delete(stopChans, seq)
stopChansMtx.Unlock()
}(req.Seq)
go service.call(call{
server: server,
sending: sending,
mtype: mtype,
req: req,
argv: argv,
replyv: replyv,
codec: codec,
context: contextVal,
eof: eof,
done: done,
stop: stop,
})
}
close(eof)
codec.Close()
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"ServeCodecWithContext",
"(",
"codec",
"ServerCodec",
",",
"context",
"interface",
"{",
"}",
")",
"{",
"sending",
":=",
"new",
"(",
"sync",
".",
"Mutex",
")",
"\n",
"eof",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"stopChans",
":=",
"make",
"(",
"map",
"[",
"uint64",
"]",
"chan",
"struct",
"{",
"}",
")",
"\n",
"var",
"stopChansMtx",
"sync",
".",
"Mutex",
"\n",
"var",
"contextVal",
"reflect",
".",
"Value",
"\n",
"if",
"context",
"!=",
"nil",
"{",
"contextVal",
"=",
"reflect",
".",
"ValueOf",
"(",
"context",
")",
"\n",
"}",
"else",
"{",
"contextVal",
"=",
"reflect",
".",
"New",
"(",
"server",
".",
"contextType",
")",
"\n",
"}",
"\n",
"for",
"{",
"service",
",",
"mtype",
",",
"req",
",",
"argv",
",",
"replyv",
",",
"keepReading",
",",
"err",
":=",
"server",
".",
"readRequest",
"(",
"codec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"errCloseStream",
"{",
"go",
"func",
"(",
")",
"{",
"stopChansMtx",
".",
"Lock",
"(",
")",
"\n",
"stop",
",",
"ok",
":=",
"stopChans",
"[",
"req",
".",
"Seq",
"]",
"\n",
"delete",
"(",
"stopChans",
",",
"req",
".",
"Seq",
")",
"\n",
"stopChansMtx",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"close",
"(",
"stop",
")",
"\n",
"}",
"(",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"keepReading",
"{",
"break",
"\n",
"}",
"\n",
"if",
"req",
"!=",
"nil",
"{",
"server",
".",
"sendResponse",
"(",
"sending",
",",
"req",
",",
"invalidRequest",
",",
"codec",
",",
"err",
".",
"Error",
"(",
")",
",",
"true",
")",
"\n",
"server",
".",
"freeRequest",
"(",
"req",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"done",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"stop",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"stopChansMtx",
".",
"Lock",
"(",
")",
"\n",
"stopChans",
"[",
"req",
".",
"Seq",
"]",
"=",
"stop",
"\n",
"stopChansMtx",
".",
"Unlock",
"(",
")",
"\n",
"go",
"func",
"(",
"seq",
"uint64",
")",
"{",
"<-",
"done",
"\n",
"stopChansMtx",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"stopChans",
",",
"seq",
")",
"\n",
"stopChansMtx",
".",
"Unlock",
"(",
")",
"\n",
"}",
"(",
"req",
".",
"Seq",
")",
"\n",
"go",
"service",
".",
"call",
"(",
"call",
"{",
"server",
":",
"server",
",",
"sending",
":",
"sending",
",",
"mtype",
":",
"mtype",
",",
"req",
":",
"req",
",",
"argv",
":",
"argv",
",",
"replyv",
":",
"replyv",
",",
"codec",
":",
"codec",
",",
"context",
":",
"contextVal",
",",
"eof",
":",
"eof",
",",
"done",
":",
"done",
",",
"stop",
":",
"stop",
",",
"}",
")",
"\n",
"}",
"\n",
"close",
"(",
"eof",
")",
"\n",
"codec",
".",
"Close",
"(",
")",
"\n",
"}"
] | // ServeCodecWithContext is like ServeCodec but it makes it possible
// to pass a connection context to the RPC methods. | [
"ServeCodecWithContext",
"is",
"like",
"ServeCodec",
"but",
"it",
"makes",
"it",
"possible",
"to",
"pass",
"a",
"connection",
"context",
"to",
"the",
"RPC",
"methods",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/server.go#L552-L620 | train |
flynn/flynn | pkg/rpcplus/server.go | Accept | func (server *Server) Accept(lis net.Listener) {
for {
conn, err := lis.Accept()
if err != nil {
log.Fatal("rpc.Serve: accept:", err.Error()) // TODO(r): exit?
}
go server.ServeConn(conn)
}
} | go | func (server *Server) Accept(lis net.Listener) {
for {
conn, err := lis.Accept()
if err != nil {
log.Fatal("rpc.Serve: accept:", err.Error()) // TODO(r): exit?
}
go server.ServeConn(conn)
}
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"Accept",
"(",
"lis",
"net",
".",
"Listener",
")",
"{",
"for",
"{",
"conn",
",",
"err",
":=",
"lis",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"\"rpc.Serve: accept:\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"go",
"server",
".",
"ServeConn",
"(",
"conn",
")",
"\n",
"}",
"\n",
"}"
] | // Accept accepts connections on the listener and serves requests
// for each incoming connection. Accept blocks; the caller typically
// invokes it in a go statement. | [
"Accept",
"accepts",
"connections",
"on",
"the",
"listener",
"and",
"serves",
"requests",
"for",
"each",
"incoming",
"connection",
".",
"Accept",
"blocks",
";",
"the",
"caller",
"typically",
"invokes",
"it",
"in",
"a",
"go",
"statement",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/server.go#L742-L750 | train |
flynn/flynn | pkg/rpcplus/server.go | ServeHTTP | func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if req.Method != "CONNECT" {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusMethodNotAllowed)
io.WriteString(w, "405 must CONNECT\n")
return
}
conn, _, err := w.(http.Hijacker).Hijack()
if err != nil {
log.Print("rpc hijacking ", req.RemoteAddr, ": ", err.Error())
return
}
io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n")
server.ServeConn(conn)
} | go | func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if req.Method != "CONNECT" {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusMethodNotAllowed)
io.WriteString(w, "405 must CONNECT\n")
return
}
conn, _, err := w.(http.Hijacker).Hijack()
if err != nil {
log.Print("rpc hijacking ", req.RemoteAddr, ": ", err.Error())
return
}
io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n")
server.ServeConn(conn)
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"req",
".",
"Method",
"!=",
"\"CONNECT\"",
"{",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"text/plain; charset=utf-8\"",
")",
"\n",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusMethodNotAllowed",
")",
"\n",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"405 must CONNECT\\n\"",
")",
"\n",
"\\n",
"\n",
"}",
"\n",
"return",
"\n",
"conn",
",",
"_",
",",
"err",
":=",
"w",
".",
"(",
"http",
".",
"Hijacker",
")",
".",
"Hijack",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"\"rpc hijacking \"",
",",
"req",
".",
"RemoteAddr",
",",
"\": \"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"io",
".",
"WriteString",
"(",
"conn",
",",
"\"HTTP/1.0 \"",
"+",
"connected",
"+",
"\"\\n\\n\"",
")",
"\n",
"}"
] | // ServeHTTP implements an http.Handler that answers RPC requests. | [
"ServeHTTP",
"implements",
"an",
"http",
".",
"Handler",
"that",
"answers",
"RPC",
"requests",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/rpcplus/server.go#L812-L826 | train |
flynn/flynn | appliance/mariadb/process.go | Backup | func (p *Process) Backup() (io.ReadCloser, error) {
r := &backupReadCloser{}
cmd := exec.Command(
filepath.Join(p.BinDir, "innobackupex"),
"--defaults-file="+p.ConfigPath(),
"--host=127.0.0.1",
"--port="+p.Port,
"--user=flynn",
"--password="+p.Password,
"--socket=",
"--stream=xbstream",
".",
)
cmd.Dir = p.DataDir
cmd.Stderr = &r.stderr
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
if err := cmd.Start(); err != nil {
stdout.Close()
return nil, err
}
// Attach to reader wrapper.
r.cmd = cmd
r.stdout = stdout
return r, nil
} | go | func (p *Process) Backup() (io.ReadCloser, error) {
r := &backupReadCloser{}
cmd := exec.Command(
filepath.Join(p.BinDir, "innobackupex"),
"--defaults-file="+p.ConfigPath(),
"--host=127.0.0.1",
"--port="+p.Port,
"--user=flynn",
"--password="+p.Password,
"--socket=",
"--stream=xbstream",
".",
)
cmd.Dir = p.DataDir
cmd.Stderr = &r.stderr
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
if err := cmd.Start(); err != nil {
stdout.Close()
return nil, err
}
// Attach to reader wrapper.
r.cmd = cmd
r.stdout = stdout
return r, nil
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"Backup",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"r",
":=",
"&",
"backupReadCloser",
"{",
"}",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"filepath",
".",
"Join",
"(",
"p",
".",
"BinDir",
",",
"\"innobackupex\"",
")",
",",
"\"--defaults-file=\"",
"+",
"p",
".",
"ConfigPath",
"(",
")",
",",
"\"--host=127.0.0.1\"",
",",
"\"--port=\"",
"+",
"p",
".",
"Port",
",",
"\"--user=flynn\"",
",",
"\"--password=\"",
"+",
"p",
".",
"Password",
",",
"\"--socket=\"",
",",
"\"--stream=xbstream\"",
",",
"\".\"",
",",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"p",
".",
"DataDir",
"\n",
"cmd",
".",
"Stderr",
"=",
"&",
"r",
".",
"stderr",
"\n",
"stdout",
",",
"err",
":=",
"cmd",
".",
"StdoutPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"cmd",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"stdout",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"r",
".",
"cmd",
"=",
"cmd",
"\n",
"r",
".",
"stdout",
"=",
"stdout",
"\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] | // Backup returns a reader for streaming a backup in xbstream format. | [
"Backup",
"returns",
"a",
"reader",
"for",
"streaming",
"a",
"backup",
"in",
"xbstream",
"format",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/process.go#L289-L320 | train |
flynn/flynn | appliance/mariadb/process.go | Restore | func (p *Process) Restore(r io.Reader) (*BackupInfo, error) {
if err := p.writeConfig(configData{}); err != nil {
return nil, err
}
if err := p.unpackXbstream(r); err != nil {
return nil, err
}
backupInfo, err := p.extractBackupInfo()
if err != nil {
return nil, err
}
if err := p.restoreApplyLog(); err != nil {
return nil, err
}
return backupInfo, nil
} | go | func (p *Process) Restore(r io.Reader) (*BackupInfo, error) {
if err := p.writeConfig(configData{}); err != nil {
return nil, err
}
if err := p.unpackXbstream(r); err != nil {
return nil, err
}
backupInfo, err := p.extractBackupInfo()
if err != nil {
return nil, err
}
if err := p.restoreApplyLog(); err != nil {
return nil, err
}
return backupInfo, nil
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"Restore",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"BackupInfo",
",",
"error",
")",
"{",
"if",
"err",
":=",
"p",
".",
"writeConfig",
"(",
"configData",
"{",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"p",
".",
"unpackXbstream",
"(",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"backupInfo",
",",
"err",
":=",
"p",
".",
"extractBackupInfo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"p",
".",
"restoreApplyLog",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"backupInfo",
",",
"nil",
"\n",
"}"
] | // Restore restores the database from an xbstream backup. | [
"Restore",
"restores",
"the",
"database",
"from",
"an",
"xbstream",
"backup",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/process.go#L341-L356 | train |
flynn/flynn | appliance/mariadb/process.go | DSN | func (p *Process) DSN() *DSN {
return &DSN{
Host: "127.0.0.1:" + p.Port,
User: "flynn",
Password: p.Password,
Timeout: p.OpTimeout,
}
} | go | func (p *Process) DSN() *DSN {
return &DSN{
Host: "127.0.0.1:" + p.Port,
User: "flynn",
Password: p.Password,
Timeout: p.OpTimeout,
}
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"DSN",
"(",
")",
"*",
"DSN",
"{",
"return",
"&",
"DSN",
"{",
"Host",
":",
"\"127.0.0.1:\"",
"+",
"p",
".",
"Port",
",",
"User",
":",
"\"flynn\"",
",",
"Password",
":",
"p",
".",
"Password",
",",
"Timeout",
":",
"p",
".",
"OpTimeout",
",",
"}",
"\n",
"}"
] | // DSN returns the data source name for connecting to the local process as the "flynn" user. | [
"DSN",
"returns",
"the",
"data",
"source",
"name",
"for",
"connecting",
"to",
"the",
"local",
"process",
"as",
"the",
"flynn",
"user",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/process.go#L890-L897 | train |
flynn/flynn | appliance/mariadb/process.go | nodeXLogPosition | func (p *Process) nodeXLogPosition(dsn *DSN) (xlog.Position, error) {
db, err := sql.Open("mysql", dsn.String())
if err != nil {
return p.XLog().Zero(), err
}
defer db.Close()
var gtid string
if err := db.QueryRow(`SELECT @@gtid_current_pos`).Scan(>id); err != nil {
return p.XLog().Zero(), err
}
return xlog.Position(gtid), nil
} | go | func (p *Process) nodeXLogPosition(dsn *DSN) (xlog.Position, error) {
db, err := sql.Open("mysql", dsn.String())
if err != nil {
return p.XLog().Zero(), err
}
defer db.Close()
var gtid string
if err := db.QueryRow(`SELECT @@gtid_current_pos`).Scan(>id); err != nil {
return p.XLog().Zero(), err
}
return xlog.Position(gtid), nil
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"nodeXLogPosition",
"(",
"dsn",
"*",
"DSN",
")",
"(",
"xlog",
".",
"Position",
",",
"error",
")",
"{",
"db",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"\"mysql\"",
",",
"dsn",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"p",
".",
"XLog",
"(",
")",
".",
"Zero",
"(",
")",
",",
"err",
"\n",
"}",
"\n",
"defer",
"db",
".",
"Close",
"(",
")",
"\n",
"var",
"gtid",
"string",
"\n",
"if",
"err",
":=",
"db",
".",
"QueryRow",
"(",
"`SELECT @@gtid_current_pos`",
")",
".",
"Scan",
"(",
"&",
"gtid",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"p",
".",
"XLog",
"(",
")",
".",
"Zero",
"(",
")",
",",
"err",
"\n",
"}",
"\n",
"return",
"xlog",
".",
"Position",
"(",
"gtid",
")",
",",
"nil",
"\n",
"}"
] | // XLogPosition returns the current XLogPosition of node specified by DSN. | [
"XLogPosition",
"returns",
"the",
"current",
"XLogPosition",
"of",
"node",
"specified",
"by",
"DSN",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/process.go#L904-L917 | train |
flynn/flynn | appliance/mariadb/process.go | installDB | func (p *Process) installDB() error {
logger := p.Logger.New("fn", "installDB", "data_dir", p.DataDir)
logger.Debug("starting installDB")
// Ignore errors, since the db could be already initialized
p.runCmd(exec.Command(
filepath.Join(p.BinDir, "mysql_install_db"),
"--defaults-extra-file="+p.ConfigPath(),
))
return nil
} | go | func (p *Process) installDB() error {
logger := p.Logger.New("fn", "installDB", "data_dir", p.DataDir)
logger.Debug("starting installDB")
// Ignore errors, since the db could be already initialized
p.runCmd(exec.Command(
filepath.Join(p.BinDir, "mysql_install_db"),
"--defaults-extra-file="+p.ConfigPath(),
))
return nil
} | [
"func",
"(",
"p",
"*",
"Process",
")",
"installDB",
"(",
")",
"error",
"{",
"logger",
":=",
"p",
".",
"Logger",
".",
"New",
"(",
"\"fn\"",
",",
"\"installDB\"",
",",
"\"data_dir\"",
",",
"p",
".",
"DataDir",
")",
"\n",
"logger",
".",
"Debug",
"(",
"\"starting installDB\"",
")",
"\n",
"p",
".",
"runCmd",
"(",
"exec",
".",
"Command",
"(",
"filepath",
".",
"Join",
"(",
"p",
".",
"BinDir",
",",
"\"mysql_install_db\"",
")",
",",
"\"--defaults-extra-file=\"",
"+",
"p",
".",
"ConfigPath",
"(",
")",
",",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // installDB initializes the data directory for a new database. | [
"installDB",
"initializes",
"the",
"data",
"directory",
"for",
"a",
"new",
"database",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/process.go#L920-L931 | train |
flynn/flynn | appliance/mariadb/process.go | Close | func (r *backupReadCloser) Close() error {
defer r.stdout.Close()
if err := r.cmd.Wait(); err != nil {
return err
}
// Verify that innobackupex prints "completed OK!" at the end of STDERR.
if !strings.HasSuffix(strings.TrimSpace(r.stderr.String()), "completed OK!") {
r.stderr.WriteTo(os.Stderr)
return errors.New("innobackupex did not complete ok")
}
return nil
} | go | func (r *backupReadCloser) Close() error {
defer r.stdout.Close()
if err := r.cmd.Wait(); err != nil {
return err
}
// Verify that innobackupex prints "completed OK!" at the end of STDERR.
if !strings.HasSuffix(strings.TrimSpace(r.stderr.String()), "completed OK!") {
r.stderr.WriteTo(os.Stderr)
return errors.New("innobackupex did not complete ok")
}
return nil
} | [
"func",
"(",
"r",
"*",
"backupReadCloser",
")",
"Close",
"(",
")",
"error",
"{",
"defer",
"r",
".",
"stdout",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"cmd",
".",
"Wait",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"strings",
".",
"TrimSpace",
"(",
"r",
".",
"stderr",
".",
"String",
"(",
")",
")",
",",
"\"completed OK!\"",
")",
"{",
"r",
".",
"stderr",
".",
"WriteTo",
"(",
"os",
".",
"Stderr",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"innobackupex did not complete ok\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close waits for the backup command to finish and verifies that the backup completed successfully. | [
"Close",
"waits",
"for",
"the",
"backup",
"command",
"to",
"finish",
"and",
"verifies",
"that",
"the",
"backup",
"completed",
"successfully",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/process.go#L1002-L1016 | train |
flynn/flynn | appliance/mariadb/process.go | Read | func (r *backupReadCloser) Read(p []byte) (n int, err error) {
return r.stdout.Read(p)
} | go | func (r *backupReadCloser) Read(p []byte) (n int, err error) {
return r.stdout.Read(p)
} | [
"func",
"(",
"r",
"*",
"backupReadCloser",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"r",
".",
"stdout",
".",
"Read",
"(",
"p",
")",
"\n",
"}"
] | // Read reads n bytes of backup data into p. | [
"Read",
"reads",
"n",
"bytes",
"of",
"backup",
"data",
"into",
"p",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/mariadb/process.go#L1019-L1021 | train |
flynn/flynn | host/libcontainer_backend.go | discoverdDial | func (l *LibcontainerBackend) discoverdDial(network, addr string) (net.Conn, error) {
host, _, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
if strings.HasSuffix(host, ".discoverd") {
// ensure discoverd is configured
<-l.discoverdConfigured
// lookup the service and pick a random address
service := strings.TrimSuffix(host, ".discoverd")
addrs, err := l.discoverdClient.Service(service).Addrs()
if err != nil {
return nil, err
} else if len(addrs) == 0 {
return nil, fmt.Errorf("lookup %s: no such host", host)
}
addr = addrs[random.Math.Intn(len(addrs))]
}
return dialer.Default.Dial(network, addr)
} | go | func (l *LibcontainerBackend) discoverdDial(network, addr string) (net.Conn, error) {
host, _, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
if strings.HasSuffix(host, ".discoverd") {
// ensure discoverd is configured
<-l.discoverdConfigured
// lookup the service and pick a random address
service := strings.TrimSuffix(host, ".discoverd")
addrs, err := l.discoverdClient.Service(service).Addrs()
if err != nil {
return nil, err
} else if len(addrs) == 0 {
return nil, fmt.Errorf("lookup %s: no such host", host)
}
addr = addrs[random.Math.Intn(len(addrs))]
}
return dialer.Default.Dial(network, addr)
} | [
"func",
"(",
"l",
"*",
"LibcontainerBackend",
")",
"discoverdDial",
"(",
"network",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"host",
",",
"\".discoverd\"",
")",
"{",
"<-",
"l",
".",
"discoverdConfigured",
"\n",
"service",
":=",
"strings",
".",
"TrimSuffix",
"(",
"host",
",",
"\".discoverd\"",
")",
"\n",
"addrs",
",",
"err",
":=",
"l",
".",
"discoverdClient",
".",
"Service",
"(",
"service",
")",
".",
"Addrs",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"addrs",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"lookup %s: no such host\"",
",",
"host",
")",
"\n",
"}",
"\n",
"addr",
"=",
"addrs",
"[",
"random",
".",
"Math",
".",
"Intn",
"(",
"len",
"(",
"addrs",
")",
")",
"]",
"\n",
"}",
"\n",
"return",
"dialer",
".",
"Default",
".",
"Dial",
"(",
"network",
",",
"addr",
")",
"\n",
"}"
] | // discoverdDial is a discoverd aware dialer which resolves a discoverd host to
// an address using the configured discoverd client as the host is likely not
// using discoverd to resolve DNS queries | [
"discoverdDial",
"is",
"a",
"discoverd",
"aware",
"dialer",
"which",
"resolves",
"a",
"discoverd",
"host",
"to",
"an",
"address",
"using",
"the",
"configured",
"discoverd",
"client",
"as",
"the",
"host",
"is",
"likely",
"not",
"using",
"discoverd",
"to",
"resolve",
"DNS",
"queries"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/host/libcontainer_backend.go#L940-L959 | train |
flynn/flynn | router/data_store.go | NewPostgresDataStore | func NewPostgresDataStore(routeType string, pgx *pgx.ConnPool) *pgDataStore {
tableName := ""
switch routeType {
case routeTypeHTTP:
tableName = tableNameHTTP
case routeTypeTCP:
tableName = tableNameTCP
default:
panic(fmt.Sprintf("unknown routeType: %q", routeType))
}
return &pgDataStore{
pgx: pgx,
routeType: routeType,
tableName: tableName,
}
} | go | func NewPostgresDataStore(routeType string, pgx *pgx.ConnPool) *pgDataStore {
tableName := ""
switch routeType {
case routeTypeHTTP:
tableName = tableNameHTTP
case routeTypeTCP:
tableName = tableNameTCP
default:
panic(fmt.Sprintf("unknown routeType: %q", routeType))
}
return &pgDataStore{
pgx: pgx,
routeType: routeType,
tableName: tableName,
}
} | [
"func",
"NewPostgresDataStore",
"(",
"routeType",
"string",
",",
"pgx",
"*",
"pgx",
".",
"ConnPool",
")",
"*",
"pgDataStore",
"{",
"tableName",
":=",
"\"\"",
"\n",
"switch",
"routeType",
"{",
"case",
"routeTypeHTTP",
":",
"tableName",
"=",
"tableNameHTTP",
"\n",
"case",
"routeTypeTCP",
":",
"tableName",
"=",
"tableNameTCP",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"unknown routeType: %q\"",
",",
"routeType",
")",
")",
"\n",
"}",
"\n",
"return",
"&",
"pgDataStore",
"{",
"pgx",
":",
"pgx",
",",
"routeType",
":",
"routeType",
",",
"tableName",
":",
"tableName",
",",
"}",
"\n",
"}"
] | // NewPostgresDataStore returns a DataStore that stores route information in a
// Postgres database. It uses pg_notify and a listener connection to watch for
// route changes. | [
"NewPostgresDataStore",
"returns",
"a",
"DataStore",
"that",
"stores",
"route",
"information",
"in",
"a",
"Postgres",
"database",
".",
"It",
"uses",
"pg_notify",
"and",
"a",
"listener",
"connection",
"to",
"watch",
"for",
"route",
"changes",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/router/data_store.go#L69-L84 | train |
flynn/flynn | updater/updater.go | updateImageIDs | func updateImageIDs(env map[string]string) bool {
updated := false
for prefix, newID := range map[string]string{
"REDIS": redisImage.ID,
"SLUGBUILDER": slugBuilder.ID,
"SLUGRUNNER": slugRunner.ID,
} {
idKey := prefix + "_IMAGE_ID"
if id, ok := env[idKey]; ok && id != newID {
env[idKey] = newID
updated = true
}
uriKey := prefix + "_IMAGE_URI"
if _, ok := env[uriKey]; ok {
delete(env, uriKey)
env[idKey] = newID
updated = true
}
}
return updated
} | go | func updateImageIDs(env map[string]string) bool {
updated := false
for prefix, newID := range map[string]string{
"REDIS": redisImage.ID,
"SLUGBUILDER": slugBuilder.ID,
"SLUGRUNNER": slugRunner.ID,
} {
idKey := prefix + "_IMAGE_ID"
if id, ok := env[idKey]; ok && id != newID {
env[idKey] = newID
updated = true
}
uriKey := prefix + "_IMAGE_URI"
if _, ok := env[uriKey]; ok {
delete(env, uriKey)
env[idKey] = newID
updated = true
}
}
return updated
} | [
"func",
"updateImageIDs",
"(",
"env",
"map",
"[",
"string",
"]",
"string",
")",
"bool",
"{",
"updated",
":=",
"false",
"\n",
"for",
"prefix",
",",
"newID",
":=",
"range",
"map",
"[",
"string",
"]",
"string",
"{",
"\"REDIS\"",
":",
"redisImage",
".",
"ID",
",",
"\"SLUGBUILDER\"",
":",
"slugBuilder",
".",
"ID",
",",
"\"SLUGRUNNER\"",
":",
"slugRunner",
".",
"ID",
",",
"}",
"{",
"idKey",
":=",
"prefix",
"+",
"\"_IMAGE_ID\"",
"\n",
"if",
"id",
",",
"ok",
":=",
"env",
"[",
"idKey",
"]",
";",
"ok",
"&&",
"id",
"!=",
"newID",
"{",
"env",
"[",
"idKey",
"]",
"=",
"newID",
"\n",
"updated",
"=",
"true",
"\n",
"}",
"\n",
"uriKey",
":=",
"prefix",
"+",
"\"_IMAGE_URI\"",
"\n",
"if",
"_",
",",
"ok",
":=",
"env",
"[",
"uriKey",
"]",
";",
"ok",
"{",
"delete",
"(",
"env",
",",
"uriKey",
")",
"\n",
"env",
"[",
"idKey",
"]",
"=",
"newID",
"\n",
"updated",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"updated",
"\n",
"}"
] | // updateImageIDs updates REDIS_IMAGE_ID, SLUGBUILDER_IMAGE_ID and
// SLUGRUNNER_IMAGE_ID if they are set and have an old ID, and also
// replaces the legacy REDIS_IMAGE_URI, SLUGBUILDER_IMAGE_URI and
// SLUGRUNNER_IMAGE_URI | [
"updateImageIDs",
"updates",
"REDIS_IMAGE_ID",
"SLUGBUILDER_IMAGE_ID",
"and",
"SLUGRUNNER_IMAGE_ID",
"if",
"they",
"are",
"set",
"and",
"have",
"an",
"old",
"ID",
"and",
"also",
"replaces",
"the",
"legacy",
"REDIS_IMAGE_URI",
"SLUGBUILDER_IMAGE_URI",
"and",
"SLUGRUNNER_IMAGE_URI"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/updater/updater.go#L253-L274 | train |
flynn/flynn | appliance/postgresql/pgxlog/pgxlog.go | Increment | func (p PgXLog) Increment(pos xlog.Position, increment int) (xlog.Position, error) {
parts, err := parse(pos)
if err != nil {
return "", err
}
return makePosition(parts[0], parts[1]+increment), nil
} | go | func (p PgXLog) Increment(pos xlog.Position, increment int) (xlog.Position, error) {
parts, err := parse(pos)
if err != nil {
return "", err
}
return makePosition(parts[0], parts[1]+increment), nil
} | [
"func",
"(",
"p",
"PgXLog",
")",
"Increment",
"(",
"pos",
"xlog",
".",
"Position",
",",
"increment",
"int",
")",
"(",
"xlog",
".",
"Position",
",",
"error",
")",
"{",
"parts",
",",
"err",
":=",
"parse",
"(",
"pos",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"makePosition",
"(",
"parts",
"[",
"0",
"]",
",",
"parts",
"[",
"1",
"]",
"+",
"increment",
")",
",",
"nil",
"\n",
"}"
] | // Increment increments an xlog position by the given number. | [
"Increment",
"increments",
"an",
"xlog",
"position",
"by",
"the",
"given",
"number",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/postgresql/pgxlog/pgxlog.go#L53-L59 | train |
flynn/flynn | appliance/postgresql/pgxlog/pgxlog.go | parse | func parse(xlog xlog.Position) (res [2]int, err error) {
parts := strings.SplitN(string(xlog), "/", 2)
if len(parts) != 2 {
err = fmt.Errorf("malformed xlog position %q", xlog)
return
}
res[0], err = parseHex(parts[0])
if err != nil {
return
}
res[1], err = parseHex(parts[1])
return
} | go | func parse(xlog xlog.Position) (res [2]int, err error) {
parts := strings.SplitN(string(xlog), "/", 2)
if len(parts) != 2 {
err = fmt.Errorf("malformed xlog position %q", xlog)
return
}
res[0], err = parseHex(parts[0])
if err != nil {
return
}
res[1], err = parseHex(parts[1])
return
} | [
"func",
"parse",
"(",
"xlog",
"xlog",
".",
"Position",
")",
"(",
"res",
"[",
"2",
"]",
"int",
",",
"err",
"error",
")",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"string",
"(",
"xlog",
")",
",",
"\"/\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"malformed xlog position %q\"",
",",
"xlog",
")",
"\n",
"return",
"\n",
"}",
"\n",
"res",
"[",
"0",
"]",
",",
"err",
"=",
"parseHex",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"res",
"[",
"1",
"]",
",",
"err",
"=",
"parseHex",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"return",
"\n",
"}"
] | // parse takes an xlog position emitted by postgres and returns an array of two
// integers representing the filepart and offset components of the xlog
// position. This is an internal representation that should not be exposed
// outside of this package. | [
"parse",
"takes",
"an",
"xlog",
"position",
"emitted",
"by",
"postgres",
"and",
"returns",
"an",
"array",
"of",
"two",
"integers",
"representing",
"the",
"filepart",
"and",
"offset",
"components",
"of",
"the",
"xlog",
"position",
".",
"This",
"is",
"an",
"internal",
"representation",
"that",
"should",
"not",
"be",
"exposed",
"outside",
"of",
"this",
"package",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/postgresql/pgxlog/pgxlog.go#L86-L100 | train |
flynn/flynn | appliance/postgresql/pgxlog/pgxlog.go | makePosition | func makePosition(filepart int, offset int) xlog.Position {
return xlog.Position(fmt.Sprintf("%X/%08X", filepart, offset))
} | go | func makePosition(filepart int, offset int) xlog.Position {
return xlog.Position(fmt.Sprintf("%X/%08X", filepart, offset))
} | [
"func",
"makePosition",
"(",
"filepart",
"int",
",",
"offset",
"int",
")",
"xlog",
".",
"Position",
"{",
"return",
"xlog",
".",
"Position",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%X/%08X\"",
",",
"filepart",
",",
"offset",
")",
")",
"\n",
"}"
] | // MakePosition constructs an xlog position string from a numeric file part and
// offset. | [
"MakePosition",
"constructs",
"an",
"xlog",
"position",
"string",
"from",
"a",
"numeric",
"file",
"part",
"and",
"offset",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/appliance/postgresql/pgxlog/pgxlog.go#L104-L106 | train |
flynn/flynn | host/logmux/sink.go | parseProcID | func parseProcID(procID []byte) (string, string) {
procTypeID := strings.SplitN(string(procID), ".", 2)
if len(procTypeID) == 2 {
return procTypeID[1], procTypeID[0]
}
return procTypeID[0], ""
} | go | func parseProcID(procID []byte) (string, string) {
procTypeID := strings.SplitN(string(procID), ".", 2)
if len(procTypeID) == 2 {
return procTypeID[1], procTypeID[0]
}
return procTypeID[0], ""
} | [
"func",
"parseProcID",
"(",
"procID",
"[",
"]",
"byte",
")",
"(",
"string",
",",
"string",
")",
"{",
"procTypeID",
":=",
"strings",
".",
"SplitN",
"(",
"string",
"(",
"procID",
")",
",",
"\".\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"procTypeID",
")",
"==",
"2",
"{",
"return",
"procTypeID",
"[",
"1",
"]",
",",
"procTypeID",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"procTypeID",
"[",
"0",
"]",
",",
"\"\"",
"\n",
"}"
] | // Parses JobID and ProcType from header ProcID field
// Always returns JobID, returns ProcType if available | [
"Parses",
"JobID",
"and",
"ProcType",
"from",
"header",
"ProcID",
"field",
"Always",
"returns",
"JobID",
"returns",
"ProcType",
"if",
"available"
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/host/logmux/sink.go#L571-L577 | train |
flynn/flynn | pkg/sirenia/scale/scale.go | CheckScale | func CheckScale(app, controllerKey, procName string, logger log15.Logger) (bool, error) {
logger = logger.New("fn", "CheckScale")
// Connect to controller.
logger.Info("connecting to controller")
client, err := controller.NewClient("", controllerKey)
if err != nil {
logger.Error("controller client error", "err", err)
return false, err
}
// Retrieve app release.
logger.Info("retrieving app release", "app", app)
release, err := client.GetAppRelease(app)
if err == controller.ErrNotFound {
logger.Error("release not found", "app", app)
return false, err
} else if err != nil {
logger.Error("get release error", "app", app, "err", err)
return false, err
}
// Retrieve current formation.
logger.Info("retrieving formation", "app", app, "release_id", release.ID)
formation, err := client.GetFormation(app, release.ID)
if err == controller.ErrNotFound {
logger.Error("formation not found", "app", app, "release_id", release.ID)
return false, err
} else if err != nil {
logger.Error("formation error", "app", app, "release_id", release.ID, "err", err)
return false, err
}
// Database hasn't been scaled up yet
if formation.Processes[procName] == 0 {
return false, nil
}
return true, nil
} | go | func CheckScale(app, controllerKey, procName string, logger log15.Logger) (bool, error) {
logger = logger.New("fn", "CheckScale")
// Connect to controller.
logger.Info("connecting to controller")
client, err := controller.NewClient("", controllerKey)
if err != nil {
logger.Error("controller client error", "err", err)
return false, err
}
// Retrieve app release.
logger.Info("retrieving app release", "app", app)
release, err := client.GetAppRelease(app)
if err == controller.ErrNotFound {
logger.Error("release not found", "app", app)
return false, err
} else if err != nil {
logger.Error("get release error", "app", app, "err", err)
return false, err
}
// Retrieve current formation.
logger.Info("retrieving formation", "app", app, "release_id", release.ID)
formation, err := client.GetFormation(app, release.ID)
if err == controller.ErrNotFound {
logger.Error("formation not found", "app", app, "release_id", release.ID)
return false, err
} else if err != nil {
logger.Error("formation error", "app", app, "release_id", release.ID, "err", err)
return false, err
}
// Database hasn't been scaled up yet
if formation.Processes[procName] == 0 {
return false, nil
}
return true, nil
} | [
"func",
"CheckScale",
"(",
"app",
",",
"controllerKey",
",",
"procName",
"string",
",",
"logger",
"log15",
".",
"Logger",
")",
"(",
"bool",
",",
"error",
")",
"{",
"logger",
"=",
"logger",
".",
"New",
"(",
"\"fn\"",
",",
"\"CheckScale\"",
")",
"\n",
"logger",
".",
"Info",
"(",
"\"connecting to controller\"",
")",
"\n",
"client",
",",
"err",
":=",
"controller",
".",
"NewClient",
"(",
"\"\"",
",",
"controllerKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Error",
"(",
"\"controller client error\"",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"logger",
".",
"Info",
"(",
"\"retrieving app release\"",
",",
"\"app\"",
",",
"app",
")",
"\n",
"release",
",",
"err",
":=",
"client",
".",
"GetAppRelease",
"(",
"app",
")",
"\n",
"if",
"err",
"==",
"controller",
".",
"ErrNotFound",
"{",
"logger",
".",
"Error",
"(",
"\"release not found\"",
",",
"\"app\"",
",",
"app",
")",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Error",
"(",
"\"get release error\"",
",",
"\"app\"",
",",
"app",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"logger",
".",
"Info",
"(",
"\"retrieving formation\"",
",",
"\"app\"",
",",
"app",
",",
"\"release_id\"",
",",
"release",
".",
"ID",
")",
"\n",
"formation",
",",
"err",
":=",
"client",
".",
"GetFormation",
"(",
"app",
",",
"release",
".",
"ID",
")",
"\n",
"if",
"err",
"==",
"controller",
".",
"ErrNotFound",
"{",
"logger",
".",
"Error",
"(",
"\"formation not found\"",
",",
"\"app\"",
",",
"app",
",",
"\"release_id\"",
",",
"release",
".",
"ID",
")",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Error",
"(",
"\"formation error\"",
",",
"\"app\"",
",",
"app",
",",
"\"release_id\"",
",",
"release",
".",
"ID",
",",
"\"err\"",
",",
"err",
")",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"formation",
".",
"Processes",
"[",
"procName",
"]",
"==",
"0",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // CheckScale examines sirenia cluster formation to check if cluster
// has been scaled up yet.
// Returns true if scaled, false if not. | [
"CheckScale",
"examines",
"sirenia",
"cluster",
"formation",
"to",
"check",
"if",
"cluster",
"has",
"been",
"scaled",
"up",
"yet",
".",
"Returns",
"true",
"if",
"scaled",
"false",
"if",
"not",
"."
] | b4b05fce92da5fbc53b272362d87b994b88a3869 | https://github.com/flynn/flynn/blob/b4b05fce92da5fbc53b272362d87b994b88a3869/pkg/sirenia/scale/scale.go#L103-L142 | train |
RichardKnop/machinery | v1/worker.go | Launch | func (worker *Worker) Launch() error {
errorsChan := make(chan error)
worker.LaunchAsync(errorsChan)
return <-errorsChan
} | go | func (worker *Worker) Launch() error {
errorsChan := make(chan error)
worker.LaunchAsync(errorsChan)
return <-errorsChan
} | [
"func",
"(",
"worker",
"*",
"Worker",
")",
"Launch",
"(",
")",
"error",
"{",
"errorsChan",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"worker",
".",
"LaunchAsync",
"(",
"errorsChan",
")",
"\n",
"return",
"<-",
"errorsChan",
"\n",
"}"
] | // Launch starts a new worker process. The worker subscribes
// to the default queue and processes incoming registered tasks | [
"Launch",
"starts",
"a",
"new",
"worker",
"process",
".",
"The",
"worker",
"subscribes",
"to",
"the",
"default",
"queue",
"and",
"processes",
"incoming",
"registered",
"tasks"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/worker.go#L32-L38 | train |
RichardKnop/machinery | v1/worker.go | LaunchAsync | func (worker *Worker) LaunchAsync(errorsChan chan<- error) {
cnf := worker.server.GetConfig()
broker := worker.server.GetBroker()
// Log some useful information about worker configuration
log.INFO.Printf("Launching a worker with the following settings:")
log.INFO.Printf("- Broker: %s", cnf.Broker)
if worker.Queue == "" {
log.INFO.Printf("- DefaultQueue: %s", cnf.DefaultQueue)
} else {
log.INFO.Printf("- CustomQueue: %s", worker.Queue)
}
log.INFO.Printf("- ResultBackend: %s", cnf.ResultBackend)
if cnf.AMQP != nil {
log.INFO.Printf("- AMQP: %s", cnf.AMQP.Exchange)
log.INFO.Printf(" - Exchange: %s", cnf.AMQP.Exchange)
log.INFO.Printf(" - ExchangeType: %s", cnf.AMQP.ExchangeType)
log.INFO.Printf(" - BindingKey: %s", cnf.AMQP.BindingKey)
log.INFO.Printf(" - PrefetchCount: %d", cnf.AMQP.PrefetchCount)
}
// Goroutine to start broker consumption and handle retries when broker connection dies
go func() {
for {
retry, err := broker.StartConsuming(worker.ConsumerTag, worker.Concurrency, worker)
if retry {
if worker.errorHandler != nil {
worker.errorHandler(err)
} else {
log.WARNING.Printf("Broker failed with error: %s", err)
}
} else {
errorsChan <- err // stop the goroutine
return
}
}
}()
if !cnf.NoUnixSignals {
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
var signalsReceived uint
// Goroutine Handle SIGINT and SIGTERM signals
go func() {
for {
select {
case s := <-sig:
log.WARNING.Printf("Signal received: %v", s)
signalsReceived++
if signalsReceived < 2 {
// After first Ctrl+C start quitting the worker gracefully
log.WARNING.Print("Waiting for running tasks to finish before shutting down")
go func() {
worker.Quit()
errorsChan <- errors.New("Worker quit gracefully")
}()
} else {
// Abort the program when user hits Ctrl+C second time in a row
errorsChan <- errors.New("Worker quit abruptly")
}
}
}
}()
}
} | go | func (worker *Worker) LaunchAsync(errorsChan chan<- error) {
cnf := worker.server.GetConfig()
broker := worker.server.GetBroker()
// Log some useful information about worker configuration
log.INFO.Printf("Launching a worker with the following settings:")
log.INFO.Printf("- Broker: %s", cnf.Broker)
if worker.Queue == "" {
log.INFO.Printf("- DefaultQueue: %s", cnf.DefaultQueue)
} else {
log.INFO.Printf("- CustomQueue: %s", worker.Queue)
}
log.INFO.Printf("- ResultBackend: %s", cnf.ResultBackend)
if cnf.AMQP != nil {
log.INFO.Printf("- AMQP: %s", cnf.AMQP.Exchange)
log.INFO.Printf(" - Exchange: %s", cnf.AMQP.Exchange)
log.INFO.Printf(" - ExchangeType: %s", cnf.AMQP.ExchangeType)
log.INFO.Printf(" - BindingKey: %s", cnf.AMQP.BindingKey)
log.INFO.Printf(" - PrefetchCount: %d", cnf.AMQP.PrefetchCount)
}
// Goroutine to start broker consumption and handle retries when broker connection dies
go func() {
for {
retry, err := broker.StartConsuming(worker.ConsumerTag, worker.Concurrency, worker)
if retry {
if worker.errorHandler != nil {
worker.errorHandler(err)
} else {
log.WARNING.Printf("Broker failed with error: %s", err)
}
} else {
errorsChan <- err // stop the goroutine
return
}
}
}()
if !cnf.NoUnixSignals {
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
var signalsReceived uint
// Goroutine Handle SIGINT and SIGTERM signals
go func() {
for {
select {
case s := <-sig:
log.WARNING.Printf("Signal received: %v", s)
signalsReceived++
if signalsReceived < 2 {
// After first Ctrl+C start quitting the worker gracefully
log.WARNING.Print("Waiting for running tasks to finish before shutting down")
go func() {
worker.Quit()
errorsChan <- errors.New("Worker quit gracefully")
}()
} else {
// Abort the program when user hits Ctrl+C second time in a row
errorsChan <- errors.New("Worker quit abruptly")
}
}
}
}()
}
} | [
"func",
"(",
"worker",
"*",
"Worker",
")",
"LaunchAsync",
"(",
"errorsChan",
"chan",
"<-",
"error",
")",
"{",
"cnf",
":=",
"worker",
".",
"server",
".",
"GetConfig",
"(",
")",
"\n",
"broker",
":=",
"worker",
".",
"server",
".",
"GetBroker",
"(",
")",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\"Launching a worker with the following settings:\"",
")",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\"- Broker: %s\"",
",",
"cnf",
".",
"Broker",
")",
"\n",
"if",
"worker",
".",
"Queue",
"==",
"\"\"",
"{",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\"- DefaultQueue: %s\"",
",",
"cnf",
".",
"DefaultQueue",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\"- CustomQueue: %s\"",
",",
"worker",
".",
"Queue",
")",
"\n",
"}",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\"- ResultBackend: %s\"",
",",
"cnf",
".",
"ResultBackend",
")",
"\n",
"if",
"cnf",
".",
"AMQP",
"!=",
"nil",
"{",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\"- AMQP: %s\"",
",",
"cnf",
".",
"AMQP",
".",
"Exchange",
")",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\" - Exchange: %s\"",
",",
"cnf",
".",
"AMQP",
".",
"Exchange",
")",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\" - ExchangeType: %s\"",
",",
"cnf",
".",
"AMQP",
".",
"ExchangeType",
")",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\" - BindingKey: %s\"",
",",
"cnf",
".",
"AMQP",
".",
"BindingKey",
")",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\" - PrefetchCount: %d\"",
",",
"cnf",
".",
"AMQP",
".",
"PrefetchCount",
")",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"retry",
",",
"err",
":=",
"broker",
".",
"StartConsuming",
"(",
"worker",
".",
"ConsumerTag",
",",
"worker",
".",
"Concurrency",
",",
"worker",
")",
"\n",
"if",
"retry",
"{",
"if",
"worker",
".",
"errorHandler",
"!=",
"nil",
"{",
"worker",
".",
"errorHandler",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"WARNING",
".",
"Printf",
"(",
"\"Broker failed with error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"errorsChan",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"if",
"!",
"cnf",
".",
"NoUnixSignals",
"{",
"sig",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"sig",
",",
"os",
".",
"Interrupt",
",",
"syscall",
".",
"SIGTERM",
")",
"\n",
"var",
"signalsReceived",
"uint",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"s",
":=",
"<-",
"sig",
":",
"log",
".",
"WARNING",
".",
"Printf",
"(",
"\"Signal received: %v\"",
",",
"s",
")",
"\n",
"signalsReceived",
"++",
"\n",
"if",
"signalsReceived",
"<",
"2",
"{",
"log",
".",
"WARNING",
".",
"Print",
"(",
"\"Waiting for running tasks to finish before shutting down\"",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"worker",
".",
"Quit",
"(",
")",
"\n",
"errorsChan",
"<-",
"errors",
".",
"New",
"(",
"\"Worker quit gracefully\"",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"else",
"{",
"errorsChan",
"<-",
"errors",
".",
"New",
"(",
"\"Worker quit abruptly\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // LaunchAsync is a non blocking version of Launch | [
"LaunchAsync",
"is",
"a",
"non",
"blocking",
"version",
"of",
"Launch"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/worker.go#L41-L107 | train |
RichardKnop/machinery | v1/worker.go | taskRetry | func (worker *Worker) taskRetry(signature *tasks.Signature) error {
// Update task state to RETRY
if err := worker.server.GetBackend().SetStateRetry(signature); err != nil {
return fmt.Errorf("Set state to 'retry' for task %s returned error: %s", signature.UUID, err)
}
// Decrement the retry counter, when it reaches 0, we won't retry again
signature.RetryCount--
// Increase retry timeout
signature.RetryTimeout = retry.FibonacciNext(signature.RetryTimeout)
// Delay task by signature.RetryTimeout seconds
eta := time.Now().UTC().Add(time.Second * time.Duration(signature.RetryTimeout))
signature.ETA = &eta
log.WARNING.Printf("Task %s failed. Going to retry in %d seconds.", signature.UUID, signature.RetryTimeout)
// Send the task back to the queue
_, err := worker.server.SendTask(signature)
return err
} | go | func (worker *Worker) taskRetry(signature *tasks.Signature) error {
// Update task state to RETRY
if err := worker.server.GetBackend().SetStateRetry(signature); err != nil {
return fmt.Errorf("Set state to 'retry' for task %s returned error: %s", signature.UUID, err)
}
// Decrement the retry counter, when it reaches 0, we won't retry again
signature.RetryCount--
// Increase retry timeout
signature.RetryTimeout = retry.FibonacciNext(signature.RetryTimeout)
// Delay task by signature.RetryTimeout seconds
eta := time.Now().UTC().Add(time.Second * time.Duration(signature.RetryTimeout))
signature.ETA = &eta
log.WARNING.Printf("Task %s failed. Going to retry in %d seconds.", signature.UUID, signature.RetryTimeout)
// Send the task back to the queue
_, err := worker.server.SendTask(signature)
return err
} | [
"func",
"(",
"worker",
"*",
"Worker",
")",
"taskRetry",
"(",
"signature",
"*",
"tasks",
".",
"Signature",
")",
"error",
"{",
"if",
"err",
":=",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"SetStateRetry",
"(",
"signature",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Set state to 'retry' for task %s returned error: %s\"",
",",
"signature",
".",
"UUID",
",",
"err",
")",
"\n",
"}",
"\n",
"signature",
".",
"RetryCount",
"--",
"\n",
"signature",
".",
"RetryTimeout",
"=",
"retry",
".",
"FibonacciNext",
"(",
"signature",
".",
"RetryTimeout",
")",
"\n",
"eta",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"time",
".",
"Second",
"*",
"time",
".",
"Duration",
"(",
"signature",
".",
"RetryTimeout",
")",
")",
"\n",
"signature",
".",
"ETA",
"=",
"&",
"eta",
"\n",
"log",
".",
"WARNING",
".",
"Printf",
"(",
"\"Task %s failed. Going to retry in %d seconds.\"",
",",
"signature",
".",
"UUID",
",",
"signature",
".",
"RetryTimeout",
")",
"\n",
"_",
",",
"err",
":=",
"worker",
".",
"server",
".",
"SendTask",
"(",
"signature",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // retryTask decrements RetryCount counter and republishes the task to the queue | [
"retryTask",
"decrements",
"RetryCount",
"counter",
"and",
"republishes",
"the",
"task",
"to",
"the",
"queue"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/worker.go#L191-L212 | train |
RichardKnop/machinery | v1/worker.go | taskSucceeded | func (worker *Worker) taskSucceeded(signature *tasks.Signature, taskResults []*tasks.TaskResult) error {
// Update task state to SUCCESS
if err := worker.server.GetBackend().SetStateSuccess(signature, taskResults); err != nil {
return fmt.Errorf("Set state to 'success' for task %s returned error: %s", signature.UUID, err)
}
// Log human readable results of the processed task
var debugResults = "[]"
results, err := tasks.ReflectTaskResults(taskResults)
if err != nil {
log.WARNING.Print(err)
} else {
debugResults = tasks.HumanReadableResults(results)
}
log.DEBUG.Printf("Processed task %s. Results = %s", signature.UUID, debugResults)
// Trigger success callbacks
for _, successTask := range signature.OnSuccess {
if signature.Immutable == false {
// Pass results of the task to success callbacks
for _, taskResult := range taskResults {
successTask.Args = append(successTask.Args, tasks.Arg{
Type: taskResult.Type,
Value: taskResult.Value,
})
}
}
worker.server.SendTask(successTask)
}
// If the task was not part of a group, just return
if signature.GroupUUID == "" {
return nil
}
// Check if all task in the group has completed
groupCompleted, err := worker.server.GetBackend().GroupCompleted(
signature.GroupUUID,
signature.GroupTaskCount,
)
if err != nil {
return fmt.Errorf("Completed check for group %s returned error: %s", signature.GroupUUID, err)
}
// If the group has not yet completed, just return
if !groupCompleted {
return nil
}
// Defer purging of group meta queue if we are using AMQP backend
if worker.hasAMQPBackend() {
defer worker.server.GetBackend().PurgeGroupMeta(signature.GroupUUID)
}
// There is no chord callback, just return
if signature.ChordCallback == nil {
return nil
}
// Trigger chord callback
shouldTrigger, err := worker.server.GetBackend().TriggerChord(signature.GroupUUID)
if err != nil {
return fmt.Errorf("Triggering chord for group %s returned error: %s", signature.GroupUUID, err)
}
// Chord has already been triggered
if !shouldTrigger {
return nil
}
// Get task states
taskStates, err := worker.server.GetBackend().GroupTaskStates(
signature.GroupUUID,
signature.GroupTaskCount,
)
if err != nil {
return nil
}
// Append group tasks' return values to chord task if it's not immutable
for _, taskState := range taskStates {
if !taskState.IsSuccess() {
return nil
}
if signature.ChordCallback.Immutable == false {
// Pass results of the task to the chord callback
for _, taskResult := range taskState.Results {
signature.ChordCallback.Args = append(signature.ChordCallback.Args, tasks.Arg{
Type: taskResult.Type,
Value: taskResult.Value,
})
}
}
}
// Send the chord task
_, err = worker.server.SendTask(signature.ChordCallback)
if err != nil {
return err
}
return nil
} | go | func (worker *Worker) taskSucceeded(signature *tasks.Signature, taskResults []*tasks.TaskResult) error {
// Update task state to SUCCESS
if err := worker.server.GetBackend().SetStateSuccess(signature, taskResults); err != nil {
return fmt.Errorf("Set state to 'success' for task %s returned error: %s", signature.UUID, err)
}
// Log human readable results of the processed task
var debugResults = "[]"
results, err := tasks.ReflectTaskResults(taskResults)
if err != nil {
log.WARNING.Print(err)
} else {
debugResults = tasks.HumanReadableResults(results)
}
log.DEBUG.Printf("Processed task %s. Results = %s", signature.UUID, debugResults)
// Trigger success callbacks
for _, successTask := range signature.OnSuccess {
if signature.Immutable == false {
// Pass results of the task to success callbacks
for _, taskResult := range taskResults {
successTask.Args = append(successTask.Args, tasks.Arg{
Type: taskResult.Type,
Value: taskResult.Value,
})
}
}
worker.server.SendTask(successTask)
}
// If the task was not part of a group, just return
if signature.GroupUUID == "" {
return nil
}
// Check if all task in the group has completed
groupCompleted, err := worker.server.GetBackend().GroupCompleted(
signature.GroupUUID,
signature.GroupTaskCount,
)
if err != nil {
return fmt.Errorf("Completed check for group %s returned error: %s", signature.GroupUUID, err)
}
// If the group has not yet completed, just return
if !groupCompleted {
return nil
}
// Defer purging of group meta queue if we are using AMQP backend
if worker.hasAMQPBackend() {
defer worker.server.GetBackend().PurgeGroupMeta(signature.GroupUUID)
}
// There is no chord callback, just return
if signature.ChordCallback == nil {
return nil
}
// Trigger chord callback
shouldTrigger, err := worker.server.GetBackend().TriggerChord(signature.GroupUUID)
if err != nil {
return fmt.Errorf("Triggering chord for group %s returned error: %s", signature.GroupUUID, err)
}
// Chord has already been triggered
if !shouldTrigger {
return nil
}
// Get task states
taskStates, err := worker.server.GetBackend().GroupTaskStates(
signature.GroupUUID,
signature.GroupTaskCount,
)
if err != nil {
return nil
}
// Append group tasks' return values to chord task if it's not immutable
for _, taskState := range taskStates {
if !taskState.IsSuccess() {
return nil
}
if signature.ChordCallback.Immutable == false {
// Pass results of the task to the chord callback
for _, taskResult := range taskState.Results {
signature.ChordCallback.Args = append(signature.ChordCallback.Args, tasks.Arg{
Type: taskResult.Type,
Value: taskResult.Value,
})
}
}
}
// Send the chord task
_, err = worker.server.SendTask(signature.ChordCallback)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"worker",
"*",
"Worker",
")",
"taskSucceeded",
"(",
"signature",
"*",
"tasks",
".",
"Signature",
",",
"taskResults",
"[",
"]",
"*",
"tasks",
".",
"TaskResult",
")",
"error",
"{",
"if",
"err",
":=",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"SetStateSuccess",
"(",
"signature",
",",
"taskResults",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Set state to 'success' for task %s returned error: %s\"",
",",
"signature",
".",
"UUID",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"debugResults",
"=",
"\"[]\"",
"\n",
"results",
",",
"err",
":=",
"tasks",
".",
"ReflectTaskResults",
"(",
"taskResults",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"WARNING",
".",
"Print",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"debugResults",
"=",
"tasks",
".",
"HumanReadableResults",
"(",
"results",
")",
"\n",
"}",
"\n",
"log",
".",
"DEBUG",
".",
"Printf",
"(",
"\"Processed task %s. Results = %s\"",
",",
"signature",
".",
"UUID",
",",
"debugResults",
")",
"\n",
"for",
"_",
",",
"successTask",
":=",
"range",
"signature",
".",
"OnSuccess",
"{",
"if",
"signature",
".",
"Immutable",
"==",
"false",
"{",
"for",
"_",
",",
"taskResult",
":=",
"range",
"taskResults",
"{",
"successTask",
".",
"Args",
"=",
"append",
"(",
"successTask",
".",
"Args",
",",
"tasks",
".",
"Arg",
"{",
"Type",
":",
"taskResult",
".",
"Type",
",",
"Value",
":",
"taskResult",
".",
"Value",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"worker",
".",
"server",
".",
"SendTask",
"(",
"successTask",
")",
"\n",
"}",
"\n",
"if",
"signature",
".",
"GroupUUID",
"==",
"\"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"groupCompleted",
",",
"err",
":=",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"GroupCompleted",
"(",
"signature",
".",
"GroupUUID",
",",
"signature",
".",
"GroupTaskCount",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Completed check for group %s returned error: %s\"",
",",
"signature",
".",
"GroupUUID",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"groupCompleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"worker",
".",
"hasAMQPBackend",
"(",
")",
"{",
"defer",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"PurgeGroupMeta",
"(",
"signature",
".",
"GroupUUID",
")",
"\n",
"}",
"\n",
"if",
"signature",
".",
"ChordCallback",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"shouldTrigger",
",",
"err",
":=",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"TriggerChord",
"(",
"signature",
".",
"GroupUUID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Triggering chord for group %s returned error: %s\"",
",",
"signature",
".",
"GroupUUID",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"shouldTrigger",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"taskStates",
",",
"err",
":=",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"GroupTaskStates",
"(",
"signature",
".",
"GroupUUID",
",",
"signature",
".",
"GroupTaskCount",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"taskState",
":=",
"range",
"taskStates",
"{",
"if",
"!",
"taskState",
".",
"IsSuccess",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"signature",
".",
"ChordCallback",
".",
"Immutable",
"==",
"false",
"{",
"for",
"_",
",",
"taskResult",
":=",
"range",
"taskState",
".",
"Results",
"{",
"signature",
".",
"ChordCallback",
".",
"Args",
"=",
"append",
"(",
"signature",
".",
"ChordCallback",
".",
"Args",
",",
"tasks",
".",
"Arg",
"{",
"Type",
":",
"taskResult",
".",
"Type",
",",
"Value",
":",
"taskResult",
".",
"Value",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"worker",
".",
"server",
".",
"SendTask",
"(",
"signature",
".",
"ChordCallback",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // taskSucceeded updates the task state and triggers success callbacks or a
// chord callback if this was the last task of a group with a chord callback | [
"taskSucceeded",
"updates",
"the",
"task",
"state",
"and",
"triggers",
"success",
"callbacks",
"or",
"a",
"chord",
"callback",
"if",
"this",
"was",
"the",
"last",
"task",
"of",
"a",
"group",
"with",
"a",
"chord",
"callback"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/worker.go#L234-L339 | train |
RichardKnop/machinery | v1/worker.go | taskFailed | func (worker *Worker) taskFailed(signature *tasks.Signature, taskErr error) error {
// Update task state to FAILURE
if err := worker.server.GetBackend().SetStateFailure(signature, taskErr.Error()); err != nil {
return fmt.Errorf("Set state to 'failure' for task %s returned error: %s", signature.UUID, err)
}
if worker.errorHandler != nil {
worker.errorHandler(taskErr)
} else {
log.ERROR.Printf("Failed processing task %s. Error = %v", signature.UUID, taskErr)
}
// Trigger error callbacks
for _, errorTask := range signature.OnError {
// Pass error as a first argument to error callbacks
args := append([]tasks.Arg{{
Type: "string",
Value: taskErr.Error(),
}}, errorTask.Args...)
errorTask.Args = args
worker.server.SendTask(errorTask)
}
return nil
} | go | func (worker *Worker) taskFailed(signature *tasks.Signature, taskErr error) error {
// Update task state to FAILURE
if err := worker.server.GetBackend().SetStateFailure(signature, taskErr.Error()); err != nil {
return fmt.Errorf("Set state to 'failure' for task %s returned error: %s", signature.UUID, err)
}
if worker.errorHandler != nil {
worker.errorHandler(taskErr)
} else {
log.ERROR.Printf("Failed processing task %s. Error = %v", signature.UUID, taskErr)
}
// Trigger error callbacks
for _, errorTask := range signature.OnError {
// Pass error as a first argument to error callbacks
args := append([]tasks.Arg{{
Type: "string",
Value: taskErr.Error(),
}}, errorTask.Args...)
errorTask.Args = args
worker.server.SendTask(errorTask)
}
return nil
} | [
"func",
"(",
"worker",
"*",
"Worker",
")",
"taskFailed",
"(",
"signature",
"*",
"tasks",
".",
"Signature",
",",
"taskErr",
"error",
")",
"error",
"{",
"if",
"err",
":=",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"SetStateFailure",
"(",
"signature",
",",
"taskErr",
".",
"Error",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Set state to 'failure' for task %s returned error: %s\"",
",",
"signature",
".",
"UUID",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"worker",
".",
"errorHandler",
"!=",
"nil",
"{",
"worker",
".",
"errorHandler",
"(",
"taskErr",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"ERROR",
".",
"Printf",
"(",
"\"Failed processing task %s. Error = %v\"",
",",
"signature",
".",
"UUID",
",",
"taskErr",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"errorTask",
":=",
"range",
"signature",
".",
"OnError",
"{",
"args",
":=",
"append",
"(",
"[",
"]",
"tasks",
".",
"Arg",
"{",
"{",
"Type",
":",
"\"string\"",
",",
"Value",
":",
"taskErr",
".",
"Error",
"(",
")",
",",
"}",
"}",
",",
"errorTask",
".",
"Args",
"...",
")",
"\n",
"errorTask",
".",
"Args",
"=",
"args",
"\n",
"worker",
".",
"server",
".",
"SendTask",
"(",
"errorTask",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // taskFailed updates the task state and triggers error callbacks | [
"taskFailed",
"updates",
"the",
"task",
"state",
"and",
"triggers",
"error",
"callbacks"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/worker.go#L342-L366 | train |
RichardKnop/machinery | v1/worker.go | hasAMQPBackend | func (worker *Worker) hasAMQPBackend() bool {
_, ok := worker.server.GetBackend().(*amqp.Backend)
return ok
} | go | func (worker *Worker) hasAMQPBackend() bool {
_, ok := worker.server.GetBackend().(*amqp.Backend)
return ok
} | [
"func",
"(",
"worker",
"*",
"Worker",
")",
"hasAMQPBackend",
"(",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"worker",
".",
"server",
".",
"GetBackend",
"(",
")",
".",
"(",
"*",
"amqp",
".",
"Backend",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // Returns true if the worker uses AMQP backend | [
"Returns",
"true",
"if",
"the",
"worker",
"uses",
"AMQP",
"backend"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/worker.go#L369-L372 | train |
RichardKnop/machinery | v1/common/amqp.go | Connect | func (ac *AMQPConnector) Connect(url string, tlsConfig *tls.Config, exchange, exchangeType, queueName string, queueDurable, queueDelete bool, queueBindingKey string, exchangeDeclareArgs, queueDeclareArgs, queueBindingArgs amqp.Table) (*amqp.Connection, *amqp.Channel, amqp.Queue, <-chan amqp.Confirmation, <-chan *amqp.Error, error) {
// Connect to server
conn, channel, err := ac.Open(url, tlsConfig)
if err != nil {
return nil, nil, amqp.Queue{}, nil, nil, err
}
if exchange != "" {
// Declare an exchange
if err = channel.ExchangeDeclare(
exchange, // name of the exchange
exchangeType, // type
true, // durable
false, // delete when complete
false, // internal
false, // noWait
exchangeDeclareArgs, // arguments
); err != nil {
return conn, channel, amqp.Queue{}, nil, nil, fmt.Errorf("Exchange declare error: %s", err)
}
}
var queue amqp.Queue
if queueName != "" {
// Declare a queue
queue, err = channel.QueueDeclare(
queueName, // name
queueDurable, // durable
queueDelete, // delete when unused
false, // exclusive
false, // no-wait
queueDeclareArgs, // arguments
)
if err != nil {
return conn, channel, amqp.Queue{}, nil, nil, fmt.Errorf("Queue declare error: %s", err)
}
// Bind the queue
if err = channel.QueueBind(
queue.Name, // name of the queue
queueBindingKey, // binding key
exchange, // source exchange
false, // noWait
queueBindingArgs, // arguments
); err != nil {
return conn, channel, queue, nil, nil, fmt.Errorf("Queue bind error: %s", err)
}
}
// Enable publish confirmations
if err = channel.Confirm(false); err != nil {
return conn, channel, queue, nil, nil, fmt.Errorf("Channel could not be put into confirm mode: %s", err)
}
return conn, channel, queue, channel.NotifyPublish(make(chan amqp.Confirmation, 1)), conn.NotifyClose(make(chan *amqp.Error, 1)), nil
} | go | func (ac *AMQPConnector) Connect(url string, tlsConfig *tls.Config, exchange, exchangeType, queueName string, queueDurable, queueDelete bool, queueBindingKey string, exchangeDeclareArgs, queueDeclareArgs, queueBindingArgs amqp.Table) (*amqp.Connection, *amqp.Channel, amqp.Queue, <-chan amqp.Confirmation, <-chan *amqp.Error, error) {
// Connect to server
conn, channel, err := ac.Open(url, tlsConfig)
if err != nil {
return nil, nil, amqp.Queue{}, nil, nil, err
}
if exchange != "" {
// Declare an exchange
if err = channel.ExchangeDeclare(
exchange, // name of the exchange
exchangeType, // type
true, // durable
false, // delete when complete
false, // internal
false, // noWait
exchangeDeclareArgs, // arguments
); err != nil {
return conn, channel, amqp.Queue{}, nil, nil, fmt.Errorf("Exchange declare error: %s", err)
}
}
var queue amqp.Queue
if queueName != "" {
// Declare a queue
queue, err = channel.QueueDeclare(
queueName, // name
queueDurable, // durable
queueDelete, // delete when unused
false, // exclusive
false, // no-wait
queueDeclareArgs, // arguments
)
if err != nil {
return conn, channel, amqp.Queue{}, nil, nil, fmt.Errorf("Queue declare error: %s", err)
}
// Bind the queue
if err = channel.QueueBind(
queue.Name, // name of the queue
queueBindingKey, // binding key
exchange, // source exchange
false, // noWait
queueBindingArgs, // arguments
); err != nil {
return conn, channel, queue, nil, nil, fmt.Errorf("Queue bind error: %s", err)
}
}
// Enable publish confirmations
if err = channel.Confirm(false); err != nil {
return conn, channel, queue, nil, nil, fmt.Errorf("Channel could not be put into confirm mode: %s", err)
}
return conn, channel, queue, channel.NotifyPublish(make(chan amqp.Confirmation, 1)), conn.NotifyClose(make(chan *amqp.Error, 1)), nil
} | [
"func",
"(",
"ac",
"*",
"AMQPConnector",
")",
"Connect",
"(",
"url",
"string",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
",",
"exchange",
",",
"exchangeType",
",",
"queueName",
"string",
",",
"queueDurable",
",",
"queueDelete",
"bool",
",",
"queueBindingKey",
"string",
",",
"exchangeDeclareArgs",
",",
"queueDeclareArgs",
",",
"queueBindingArgs",
"amqp",
".",
"Table",
")",
"(",
"*",
"amqp",
".",
"Connection",
",",
"*",
"amqp",
".",
"Channel",
",",
"amqp",
".",
"Queue",
",",
"<-",
"chan",
"amqp",
".",
"Confirmation",
",",
"<-",
"chan",
"*",
"amqp",
".",
"Error",
",",
"error",
")",
"{",
"conn",
",",
"channel",
",",
"err",
":=",
"ac",
".",
"Open",
"(",
"url",
",",
"tlsConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"amqp",
".",
"Queue",
"{",
"}",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"exchange",
"!=",
"\"\"",
"{",
"if",
"err",
"=",
"channel",
".",
"ExchangeDeclare",
"(",
"exchange",
",",
"exchangeType",
",",
"true",
",",
"false",
",",
"false",
",",
"false",
",",
"exchangeDeclareArgs",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"conn",
",",
"channel",
",",
"amqp",
".",
"Queue",
"{",
"}",
",",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Exchange declare error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"queue",
"amqp",
".",
"Queue",
"\n",
"if",
"queueName",
"!=",
"\"\"",
"{",
"queue",
",",
"err",
"=",
"channel",
".",
"QueueDeclare",
"(",
"queueName",
",",
"queueDurable",
",",
"queueDelete",
",",
"false",
",",
"false",
",",
"queueDeclareArgs",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
",",
"channel",
",",
"amqp",
".",
"Queue",
"{",
"}",
",",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Queue declare error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"channel",
".",
"QueueBind",
"(",
"queue",
".",
"Name",
",",
"queueBindingKey",
",",
"exchange",
",",
"false",
",",
"queueBindingArgs",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"conn",
",",
"channel",
",",
"queue",
",",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Queue bind error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"=",
"channel",
".",
"Confirm",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"conn",
",",
"channel",
",",
"queue",
",",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Channel could not be put into confirm mode: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"channel",
",",
"queue",
",",
"channel",
".",
"NotifyPublish",
"(",
"make",
"(",
"chan",
"amqp",
".",
"Confirmation",
",",
"1",
")",
")",
",",
"conn",
".",
"NotifyClose",
"(",
"make",
"(",
"chan",
"*",
"amqp",
".",
"Error",
",",
"1",
")",
")",
",",
"nil",
"\n",
"}"
] | // Connect opens a connection to RabbitMQ, declares an exchange, opens a channel,
// declares and binds the queue and enables publish notifications | [
"Connect",
"opens",
"a",
"connection",
"to",
"RabbitMQ",
"declares",
"an",
"exchange",
"opens",
"a",
"channel",
"declares",
"and",
"binds",
"the",
"queue",
"and",
"enables",
"publish",
"notifications"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/amqp.go#L15-L70 | train |
RichardKnop/machinery | v1/common/amqp.go | DeleteQueue | func (ac *AMQPConnector) DeleteQueue(channel *amqp.Channel, queueName string) error {
// First return value is number of messages removed
_, err := channel.QueueDelete(
queueName, // name
false, // ifUnused
false, // ifEmpty
false, // noWait
)
return err
} | go | func (ac *AMQPConnector) DeleteQueue(channel *amqp.Channel, queueName string) error {
// First return value is number of messages removed
_, err := channel.QueueDelete(
queueName, // name
false, // ifUnused
false, // ifEmpty
false, // noWait
)
return err
} | [
"func",
"(",
"ac",
"*",
"AMQPConnector",
")",
"DeleteQueue",
"(",
"channel",
"*",
"amqp",
".",
"Channel",
",",
"queueName",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"channel",
".",
"QueueDelete",
"(",
"queueName",
",",
"false",
",",
"false",
",",
"false",
",",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteQueue deletes a queue by name | [
"DeleteQueue",
"deletes",
"a",
"queue",
"by",
"name"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/amqp.go#L73-L83 | train |
RichardKnop/machinery | v1/common/amqp.go | InspectQueue | func (*AMQPConnector) InspectQueue(channel *amqp.Channel, queueName string) (*amqp.Queue, error) {
queueState, err := channel.QueueInspect(queueName)
if err != nil {
return nil, fmt.Errorf("Queue inspect error: %s", err)
}
return &queueState, nil
} | go | func (*AMQPConnector) InspectQueue(channel *amqp.Channel, queueName string) (*amqp.Queue, error) {
queueState, err := channel.QueueInspect(queueName)
if err != nil {
return nil, fmt.Errorf("Queue inspect error: %s", err)
}
return &queueState, nil
} | [
"func",
"(",
"*",
"AMQPConnector",
")",
"InspectQueue",
"(",
"channel",
"*",
"amqp",
".",
"Channel",
",",
"queueName",
"string",
")",
"(",
"*",
"amqp",
".",
"Queue",
",",
"error",
")",
"{",
"queueState",
",",
"err",
":=",
"channel",
".",
"QueueInspect",
"(",
"queueName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Queue inspect error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"queueState",
",",
"nil",
"\n",
"}"
] | // InspectQueue provides information about a specific queue | [
"InspectQueue",
"provides",
"information",
"about",
"a",
"specific",
"queue"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/amqp.go#L86-L93 | train |
RichardKnop/machinery | v1/common/amqp.go | Open | func (ac *AMQPConnector) Open(url string, tlsConfig *tls.Config) (*amqp.Connection, *amqp.Channel, error) {
// Connect
// From amqp docs: DialTLS will use the provided tls.Config when it encounters an amqps:// scheme
// and will dial a plain connection when it encounters an amqp:// scheme.
conn, err := amqp.DialTLS(url, tlsConfig)
if err != nil {
return nil, nil, fmt.Errorf("Dial error: %s", err)
}
// Open a channel
channel, err := conn.Channel()
if err != nil {
return nil, nil, fmt.Errorf("Open channel error: %s", err)
}
return conn, channel, nil
} | go | func (ac *AMQPConnector) Open(url string, tlsConfig *tls.Config) (*amqp.Connection, *amqp.Channel, error) {
// Connect
// From amqp docs: DialTLS will use the provided tls.Config when it encounters an amqps:// scheme
// and will dial a plain connection when it encounters an amqp:// scheme.
conn, err := amqp.DialTLS(url, tlsConfig)
if err != nil {
return nil, nil, fmt.Errorf("Dial error: %s", err)
}
// Open a channel
channel, err := conn.Channel()
if err != nil {
return nil, nil, fmt.Errorf("Open channel error: %s", err)
}
return conn, channel, nil
} | [
"func",
"(",
"ac",
"*",
"AMQPConnector",
")",
"Open",
"(",
"url",
"string",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
")",
"(",
"*",
"amqp",
".",
"Connection",
",",
"*",
"amqp",
".",
"Channel",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"amqp",
".",
"DialTLS",
"(",
"url",
",",
"tlsConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Dial error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"channel",
",",
"err",
":=",
"conn",
".",
"Channel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Open channel error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"channel",
",",
"nil",
"\n",
"}"
] | // Open new RabbitMQ connection | [
"Open",
"new",
"RabbitMQ",
"connection"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/amqp.go#L96-L112 | train |
RichardKnop/machinery | v1/tasks/task.go | SignatureFromContext | func SignatureFromContext(ctx context.Context) *Signature {
if ctx == nil {
return nil
}
v := ctx.Value(signatureCtx)
if v == nil {
return nil
}
signature, _ := v.(*Signature)
return signature
} | go | func SignatureFromContext(ctx context.Context) *Signature {
if ctx == nil {
return nil
}
v := ctx.Value(signatureCtx)
if v == nil {
return nil
}
signature, _ := v.(*Signature)
return signature
} | [
"func",
"SignatureFromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"Signature",
"{",
"if",
"ctx",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"v",
":=",
"ctx",
".",
"Value",
"(",
"signatureCtx",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"signature",
",",
"_",
":=",
"v",
".",
"(",
"*",
"Signature",
")",
"\n",
"return",
"signature",
"\n",
"}"
] | // SignatureFromContext gets the signature from the context | [
"SignatureFromContext",
"gets",
"the",
"signature",
"from",
"the",
"context"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/task.go#L34-L46 | train |
RichardKnop/machinery | v1/tasks/task.go | NewWithSignature | func NewWithSignature(taskFunc interface{}, signature *Signature) (*Task, error) {
args := signature.Args
ctx := context.Background()
ctx = context.WithValue(ctx, signatureCtx, signature)
task := &Task{
TaskFunc: reflect.ValueOf(taskFunc),
Context: ctx,
}
taskFuncType := reflect.TypeOf(taskFunc)
if taskFuncType.NumIn() > 0 {
arg0Type := taskFuncType.In(0)
if IsContextType(arg0Type) {
task.UseContext = true
}
}
if err := task.ReflectArgs(args); err != nil {
return nil, fmt.Errorf("Reflect task args error: %s", err)
}
return task, nil
} | go | func NewWithSignature(taskFunc interface{}, signature *Signature) (*Task, error) {
args := signature.Args
ctx := context.Background()
ctx = context.WithValue(ctx, signatureCtx, signature)
task := &Task{
TaskFunc: reflect.ValueOf(taskFunc),
Context: ctx,
}
taskFuncType := reflect.TypeOf(taskFunc)
if taskFuncType.NumIn() > 0 {
arg0Type := taskFuncType.In(0)
if IsContextType(arg0Type) {
task.UseContext = true
}
}
if err := task.ReflectArgs(args); err != nil {
return nil, fmt.Errorf("Reflect task args error: %s", err)
}
return task, nil
} | [
"func",
"NewWithSignature",
"(",
"taskFunc",
"interface",
"{",
"}",
",",
"signature",
"*",
"Signature",
")",
"(",
"*",
"Task",
",",
"error",
")",
"{",
"args",
":=",
"signature",
".",
"Args",
"\n",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"ctx",
"=",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"signatureCtx",
",",
"signature",
")",
"\n",
"task",
":=",
"&",
"Task",
"{",
"TaskFunc",
":",
"reflect",
".",
"ValueOf",
"(",
"taskFunc",
")",
",",
"Context",
":",
"ctx",
",",
"}",
"\n",
"taskFuncType",
":=",
"reflect",
".",
"TypeOf",
"(",
"taskFunc",
")",
"\n",
"if",
"taskFuncType",
".",
"NumIn",
"(",
")",
">",
"0",
"{",
"arg0Type",
":=",
"taskFuncType",
".",
"In",
"(",
"0",
")",
"\n",
"if",
"IsContextType",
"(",
"arg0Type",
")",
"{",
"task",
".",
"UseContext",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"task",
".",
"ReflectArgs",
"(",
"args",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Reflect task args error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"task",
",",
"nil",
"\n",
"}"
] | // NewWithSignature is the same as New but injects the signature | [
"NewWithSignature",
"is",
"the",
"same",
"as",
"New",
"but",
"injects",
"the",
"signature"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/task.go#L49-L71 | train |
RichardKnop/machinery | v1/tasks/task.go | New | func New(taskFunc interface{}, args []Arg) (*Task, error) {
task := &Task{
TaskFunc: reflect.ValueOf(taskFunc),
Context: context.Background(),
}
taskFuncType := reflect.TypeOf(taskFunc)
if taskFuncType.NumIn() > 0 {
arg0Type := taskFuncType.In(0)
if IsContextType(arg0Type) {
task.UseContext = true
}
}
if err := task.ReflectArgs(args); err != nil {
return nil, fmt.Errorf("Reflect task args error: %s", err)
}
return task, nil
} | go | func New(taskFunc interface{}, args []Arg) (*Task, error) {
task := &Task{
TaskFunc: reflect.ValueOf(taskFunc),
Context: context.Background(),
}
taskFuncType := reflect.TypeOf(taskFunc)
if taskFuncType.NumIn() > 0 {
arg0Type := taskFuncType.In(0)
if IsContextType(arg0Type) {
task.UseContext = true
}
}
if err := task.ReflectArgs(args); err != nil {
return nil, fmt.Errorf("Reflect task args error: %s", err)
}
return task, nil
} | [
"func",
"New",
"(",
"taskFunc",
"interface",
"{",
"}",
",",
"args",
"[",
"]",
"Arg",
")",
"(",
"*",
"Task",
",",
"error",
")",
"{",
"task",
":=",
"&",
"Task",
"{",
"TaskFunc",
":",
"reflect",
".",
"ValueOf",
"(",
"taskFunc",
")",
",",
"Context",
":",
"context",
".",
"Background",
"(",
")",
",",
"}",
"\n",
"taskFuncType",
":=",
"reflect",
".",
"TypeOf",
"(",
"taskFunc",
")",
"\n",
"if",
"taskFuncType",
".",
"NumIn",
"(",
")",
">",
"0",
"{",
"arg0Type",
":=",
"taskFuncType",
".",
"In",
"(",
"0",
")",
"\n",
"if",
"IsContextType",
"(",
"arg0Type",
")",
"{",
"task",
".",
"UseContext",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"task",
".",
"ReflectArgs",
"(",
"args",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Reflect task args error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"task",
",",
"nil",
"\n",
"}"
] | // New tries to use reflection to convert the function and arguments
// into a reflect.Value and prepare it for invocation | [
"New",
"tries",
"to",
"use",
"reflection",
"to",
"convert",
"the",
"function",
"and",
"arguments",
"into",
"a",
"reflect",
".",
"Value",
"and",
"prepare",
"it",
"for",
"invocation"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/task.go#L75-L94 | train |
RichardKnop/machinery | v1/tracing/tracing.go | StartSpanFromHeaders | func StartSpanFromHeaders(headers tasks.Headers, operationName string) opentracing.Span {
// Try to extract the span context from the carrier.
spanContext, err := opentracing.GlobalTracer().Extract(opentracing.TextMap, headers)
// Create a new span from the span context if found or start a new trace with the function name.
// For clarity add the machinery component tag.
span := opentracing.StartSpan(
operationName,
ConsumerOption(spanContext),
MachineryTag,
)
// Log any error but don't fail
if err != nil {
span.LogFields(opentracing_log.Error(err))
}
return span
} | go | func StartSpanFromHeaders(headers tasks.Headers, operationName string) opentracing.Span {
// Try to extract the span context from the carrier.
spanContext, err := opentracing.GlobalTracer().Extract(opentracing.TextMap, headers)
// Create a new span from the span context if found or start a new trace with the function name.
// For clarity add the machinery component tag.
span := opentracing.StartSpan(
operationName,
ConsumerOption(spanContext),
MachineryTag,
)
// Log any error but don't fail
if err != nil {
span.LogFields(opentracing_log.Error(err))
}
return span
} | [
"func",
"StartSpanFromHeaders",
"(",
"headers",
"tasks",
".",
"Headers",
",",
"operationName",
"string",
")",
"opentracing",
".",
"Span",
"{",
"spanContext",
",",
"err",
":=",
"opentracing",
".",
"GlobalTracer",
"(",
")",
".",
"Extract",
"(",
"opentracing",
".",
"TextMap",
",",
"headers",
")",
"\n",
"span",
":=",
"opentracing",
".",
"StartSpan",
"(",
"operationName",
",",
"ConsumerOption",
"(",
"spanContext",
")",
",",
"MachineryTag",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"span",
".",
"LogFields",
"(",
"opentracing_log",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"span",
"\n",
"}"
] | // StartSpanFromHeaders will extract a span from the signature headers
// and start a new span with the given operation name. | [
"StartSpanFromHeaders",
"will",
"extract",
"a",
"span",
"from",
"the",
"signature",
"headers",
"and",
"start",
"a",
"new",
"span",
"with",
"the",
"given",
"operation",
"name",
"."
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tracing/tracing.go#L23-L41 | train |
RichardKnop/machinery | v1/tracing/tracing.go | HeadersWithSpan | func HeadersWithSpan(headers tasks.Headers, span opentracing.Span) tasks.Headers {
// check if the headers aren't nil
if headers == nil {
headers = make(tasks.Headers)
}
if err := opentracing.GlobalTracer().Inject(span.Context(), opentracing.TextMap, headers); err != nil {
span.LogFields(opentracing_log.Error(err))
}
return headers
} | go | func HeadersWithSpan(headers tasks.Headers, span opentracing.Span) tasks.Headers {
// check if the headers aren't nil
if headers == nil {
headers = make(tasks.Headers)
}
if err := opentracing.GlobalTracer().Inject(span.Context(), opentracing.TextMap, headers); err != nil {
span.LogFields(opentracing_log.Error(err))
}
return headers
} | [
"func",
"HeadersWithSpan",
"(",
"headers",
"tasks",
".",
"Headers",
",",
"span",
"opentracing",
".",
"Span",
")",
"tasks",
".",
"Headers",
"{",
"if",
"headers",
"==",
"nil",
"{",
"headers",
"=",
"make",
"(",
"tasks",
".",
"Headers",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"opentracing",
".",
"GlobalTracer",
"(",
")",
".",
"Inject",
"(",
"span",
".",
"Context",
"(",
")",
",",
"opentracing",
".",
"TextMap",
",",
"headers",
")",
";",
"err",
"!=",
"nil",
"{",
"span",
".",
"LogFields",
"(",
"opentracing_log",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"headers",
"\n",
"}"
] | // HeadersWithSpan will inject a span into the signature headers | [
"HeadersWithSpan",
"will",
"inject",
"a",
"span",
"into",
"the",
"signature",
"headers"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tracing/tracing.go#L44-L55 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | consume | func (b *Broker) consume(deliveries <-chan *awssqs.ReceiveMessageOutput, concurrency int, taskProcessor iface.TaskProcessor) error {
pool := make(chan struct{}, concurrency)
// initialize worker pool with maxWorkers workers
go func() {
b.initializePool(pool, concurrency)
}()
errorsChan := make(chan error)
for {
whetherContinue, err := b.consumeDeliveries(deliveries, concurrency, taskProcessor, pool, errorsChan)
if err != nil {
return err
}
if whetherContinue == false {
return nil
}
}
} | go | func (b *Broker) consume(deliveries <-chan *awssqs.ReceiveMessageOutput, concurrency int, taskProcessor iface.TaskProcessor) error {
pool := make(chan struct{}, concurrency)
// initialize worker pool with maxWorkers workers
go func() {
b.initializePool(pool, concurrency)
}()
errorsChan := make(chan error)
for {
whetherContinue, err := b.consumeDeliveries(deliveries, concurrency, taskProcessor, pool, errorsChan)
if err != nil {
return err
}
if whetherContinue == false {
return nil
}
}
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"consume",
"(",
"deliveries",
"<-",
"chan",
"*",
"awssqs",
".",
"ReceiveMessageOutput",
",",
"concurrency",
"int",
",",
"taskProcessor",
"iface",
".",
"TaskProcessor",
")",
"error",
"{",
"pool",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"concurrency",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"b",
".",
"initializePool",
"(",
"pool",
",",
"concurrency",
")",
"\n",
"}",
"(",
")",
"\n",
"errorsChan",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"for",
"{",
"whetherContinue",
",",
"err",
":=",
"b",
".",
"consumeDeliveries",
"(",
"deliveries",
",",
"concurrency",
",",
"taskProcessor",
",",
"pool",
",",
"errorsChan",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"whetherContinue",
"==",
"false",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // consume is a method which keeps consuming deliveries from a channel, until there is an error or a stop signal | [
"consume",
"is",
"a",
"method",
"which",
"keeps",
"consuming",
"deliveries",
"from",
"a",
"channel",
"until",
"there",
"is",
"an",
"error",
"or",
"a",
"stop",
"signal"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L184-L203 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | consumeOne | func (b *Broker) consumeOne(delivery *awssqs.ReceiveMessageOutput, taskProcessor iface.TaskProcessor) error {
if len(delivery.Messages) == 0 {
log.ERROR.Printf("received an empty message, the delivery was %v", delivery)
return errors.New("received empty message, the delivery is " + delivery.GoString())
}
sig := new(tasks.Signature)
decoder := json.NewDecoder(strings.NewReader(*delivery.Messages[0].Body))
decoder.UseNumber()
if err := decoder.Decode(sig); err != nil {
log.ERROR.Printf("unmarshal error. the delivery is %v", delivery)
return err
}
// If the task is not registered return an error
// and leave the message in the queue
if !b.IsTaskRegistered(sig.Name) {
return fmt.Errorf("task %s is not registered", sig.Name)
}
err := taskProcessor.Process(sig)
if err != nil {
return err
}
// Delete message after successfully consuming and processing the message
if err = b.deleteOne(delivery); err != nil {
log.ERROR.Printf("error when deleting the delivery. delivery is %v, Error=%s", delivery, err)
}
return err
} | go | func (b *Broker) consumeOne(delivery *awssqs.ReceiveMessageOutput, taskProcessor iface.TaskProcessor) error {
if len(delivery.Messages) == 0 {
log.ERROR.Printf("received an empty message, the delivery was %v", delivery)
return errors.New("received empty message, the delivery is " + delivery.GoString())
}
sig := new(tasks.Signature)
decoder := json.NewDecoder(strings.NewReader(*delivery.Messages[0].Body))
decoder.UseNumber()
if err := decoder.Decode(sig); err != nil {
log.ERROR.Printf("unmarshal error. the delivery is %v", delivery)
return err
}
// If the task is not registered return an error
// and leave the message in the queue
if !b.IsTaskRegistered(sig.Name) {
return fmt.Errorf("task %s is not registered", sig.Name)
}
err := taskProcessor.Process(sig)
if err != nil {
return err
}
// Delete message after successfully consuming and processing the message
if err = b.deleteOne(delivery); err != nil {
log.ERROR.Printf("error when deleting the delivery. delivery is %v, Error=%s", delivery, err)
}
return err
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"consumeOne",
"(",
"delivery",
"*",
"awssqs",
".",
"ReceiveMessageOutput",
",",
"taskProcessor",
"iface",
".",
"TaskProcessor",
")",
"error",
"{",
"if",
"len",
"(",
"delivery",
".",
"Messages",
")",
"==",
"0",
"{",
"log",
".",
"ERROR",
".",
"Printf",
"(",
"\"received an empty message, the delivery was %v\"",
",",
"delivery",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"received empty message, the delivery is \"",
"+",
"delivery",
".",
"GoString",
"(",
")",
")",
"\n",
"}",
"\n",
"sig",
":=",
"new",
"(",
"tasks",
".",
"Signature",
")",
"\n",
"decoder",
":=",
"json",
".",
"NewDecoder",
"(",
"strings",
".",
"NewReader",
"(",
"*",
"delivery",
".",
"Messages",
"[",
"0",
"]",
".",
"Body",
")",
")",
"\n",
"decoder",
".",
"UseNumber",
"(",
")",
"\n",
"if",
"err",
":=",
"decoder",
".",
"Decode",
"(",
"sig",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"ERROR",
".",
"Printf",
"(",
"\"unmarshal error. the delivery is %v\"",
",",
"delivery",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"b",
".",
"IsTaskRegistered",
"(",
"sig",
".",
"Name",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"task %s is not registered\"",
",",
"sig",
".",
"Name",
")",
"\n",
"}",
"\n",
"err",
":=",
"taskProcessor",
".",
"Process",
"(",
"sig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"b",
".",
"deleteOne",
"(",
"delivery",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"ERROR",
".",
"Printf",
"(",
"\"error when deleting the delivery. delivery is %v, Error=%s\"",
",",
"delivery",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // consumeOne is a method consumes a delivery. If a delivery was consumed successfully, it will be deleted from AWS SQS | [
"consumeOne",
"is",
"a",
"method",
"consumes",
"a",
"delivery",
".",
"If",
"a",
"delivery",
"was",
"consumed",
"successfully",
"it",
"will",
"be",
"deleted",
"from",
"AWS",
"SQS"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L206-L235 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | deleteOne | func (b *Broker) deleteOne(delivery *awssqs.ReceiveMessageOutput) error {
qURL := b.defaultQueueURL()
_, err := b.service.DeleteMessage(&awssqs.DeleteMessageInput{
QueueUrl: qURL,
ReceiptHandle: delivery.Messages[0].ReceiptHandle,
})
if err != nil {
return err
}
return nil
} | go | func (b *Broker) deleteOne(delivery *awssqs.ReceiveMessageOutput) error {
qURL := b.defaultQueueURL()
_, err := b.service.DeleteMessage(&awssqs.DeleteMessageInput{
QueueUrl: qURL,
ReceiptHandle: delivery.Messages[0].ReceiptHandle,
})
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"deleteOne",
"(",
"delivery",
"*",
"awssqs",
".",
"ReceiveMessageOutput",
")",
"error",
"{",
"qURL",
":=",
"b",
".",
"defaultQueueURL",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"b",
".",
"service",
".",
"DeleteMessage",
"(",
"&",
"awssqs",
".",
"DeleteMessageInput",
"{",
"QueueUrl",
":",
"qURL",
",",
"ReceiptHandle",
":",
"delivery",
".",
"Messages",
"[",
"0",
"]",
".",
"ReceiptHandle",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // deleteOne is a method delete a delivery from AWS SQS | [
"deleteOne",
"is",
"a",
"method",
"delete",
"a",
"delivery",
"from",
"AWS",
"SQS"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L238-L249 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | defaultQueueURL | func (b *Broker) defaultQueueURL() *string {
if b.queueUrl != nil {
return b.queueUrl
} else {
return aws.String(b.GetConfig().Broker + "/" + b.GetConfig().DefaultQueue)
}
} | go | func (b *Broker) defaultQueueURL() *string {
if b.queueUrl != nil {
return b.queueUrl
} else {
return aws.String(b.GetConfig().Broker + "/" + b.GetConfig().DefaultQueue)
}
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"defaultQueueURL",
"(",
")",
"*",
"string",
"{",
"if",
"b",
".",
"queueUrl",
"!=",
"nil",
"{",
"return",
"b",
".",
"queueUrl",
"\n",
"}",
"else",
"{",
"return",
"aws",
".",
"String",
"(",
"b",
".",
"GetConfig",
"(",
")",
".",
"Broker",
"+",
"\"/\"",
"+",
"b",
".",
"GetConfig",
"(",
")",
".",
"DefaultQueue",
")",
"\n",
"}",
"\n",
"}"
] | // defaultQueueURL is a method returns the default queue url | [
"defaultQueueURL",
"is",
"a",
"method",
"returns",
"the",
"default",
"queue",
"url"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L252-L259 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | receiveMessage | func (b *Broker) receiveMessage(qURL *string) (*awssqs.ReceiveMessageOutput, error) {
var waitTimeSeconds int
var visibilityTimeout *int
if b.GetConfig().SQS != nil {
waitTimeSeconds = b.GetConfig().SQS.WaitTimeSeconds
visibilityTimeout = b.GetConfig().SQS.VisibilityTimeout
} else {
waitTimeSeconds = 0
}
input := &awssqs.ReceiveMessageInput{
AttributeNames: []*string{
aws.String(awssqs.MessageSystemAttributeNameSentTimestamp),
},
MessageAttributeNames: []*string{
aws.String(awssqs.QueueAttributeNameAll),
},
QueueUrl: qURL,
MaxNumberOfMessages: aws.Int64(1),
WaitTimeSeconds: aws.Int64(int64(waitTimeSeconds)),
}
if visibilityTimeout != nil {
input.VisibilityTimeout = aws.Int64(int64(*visibilityTimeout))
}
result, err := b.service.ReceiveMessage(input)
if err != nil {
return nil, err
}
return result, err
} | go | func (b *Broker) receiveMessage(qURL *string) (*awssqs.ReceiveMessageOutput, error) {
var waitTimeSeconds int
var visibilityTimeout *int
if b.GetConfig().SQS != nil {
waitTimeSeconds = b.GetConfig().SQS.WaitTimeSeconds
visibilityTimeout = b.GetConfig().SQS.VisibilityTimeout
} else {
waitTimeSeconds = 0
}
input := &awssqs.ReceiveMessageInput{
AttributeNames: []*string{
aws.String(awssqs.MessageSystemAttributeNameSentTimestamp),
},
MessageAttributeNames: []*string{
aws.String(awssqs.QueueAttributeNameAll),
},
QueueUrl: qURL,
MaxNumberOfMessages: aws.Int64(1),
WaitTimeSeconds: aws.Int64(int64(waitTimeSeconds)),
}
if visibilityTimeout != nil {
input.VisibilityTimeout = aws.Int64(int64(*visibilityTimeout))
}
result, err := b.service.ReceiveMessage(input)
if err != nil {
return nil, err
}
return result, err
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"receiveMessage",
"(",
"qURL",
"*",
"string",
")",
"(",
"*",
"awssqs",
".",
"ReceiveMessageOutput",
",",
"error",
")",
"{",
"var",
"waitTimeSeconds",
"int",
"\n",
"var",
"visibilityTimeout",
"*",
"int",
"\n",
"if",
"b",
".",
"GetConfig",
"(",
")",
".",
"SQS",
"!=",
"nil",
"{",
"waitTimeSeconds",
"=",
"b",
".",
"GetConfig",
"(",
")",
".",
"SQS",
".",
"WaitTimeSeconds",
"\n",
"visibilityTimeout",
"=",
"b",
".",
"GetConfig",
"(",
")",
".",
"SQS",
".",
"VisibilityTimeout",
"\n",
"}",
"else",
"{",
"waitTimeSeconds",
"=",
"0",
"\n",
"}",
"\n",
"input",
":=",
"&",
"awssqs",
".",
"ReceiveMessageInput",
"{",
"AttributeNames",
":",
"[",
"]",
"*",
"string",
"{",
"aws",
".",
"String",
"(",
"awssqs",
".",
"MessageSystemAttributeNameSentTimestamp",
")",
",",
"}",
",",
"MessageAttributeNames",
":",
"[",
"]",
"*",
"string",
"{",
"aws",
".",
"String",
"(",
"awssqs",
".",
"QueueAttributeNameAll",
")",
",",
"}",
",",
"QueueUrl",
":",
"qURL",
",",
"MaxNumberOfMessages",
":",
"aws",
".",
"Int64",
"(",
"1",
")",
",",
"WaitTimeSeconds",
":",
"aws",
".",
"Int64",
"(",
"int64",
"(",
"waitTimeSeconds",
")",
")",
",",
"}",
"\n",
"if",
"visibilityTimeout",
"!=",
"nil",
"{",
"input",
".",
"VisibilityTimeout",
"=",
"aws",
".",
"Int64",
"(",
"int64",
"(",
"*",
"visibilityTimeout",
")",
")",
"\n",
"}",
"\n",
"result",
",",
"err",
":=",
"b",
".",
"service",
".",
"ReceiveMessage",
"(",
"input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"result",
",",
"err",
"\n",
"}"
] | // receiveMessage is a method receives a message from specified queue url | [
"receiveMessage",
"is",
"a",
"method",
"receives",
"a",
"message",
"from",
"specified",
"queue",
"url"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L262-L290 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | initializePool | func (b *Broker) initializePool(pool chan struct{}, concurrency int) {
for i := 0; i < concurrency; i++ {
pool <- struct{}{}
}
} | go | func (b *Broker) initializePool(pool chan struct{}, concurrency int) {
for i := 0; i < concurrency; i++ {
pool <- struct{}{}
}
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"initializePool",
"(",
"pool",
"chan",
"struct",
"{",
"}",
",",
"concurrency",
"int",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"concurrency",
";",
"i",
"++",
"{",
"pool",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}"
] | // initializePool is a method which initializes concurrency pool | [
"initializePool",
"is",
"a",
"method",
"which",
"initializes",
"concurrency",
"pool"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L293-L297 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | consumeDeliveries | func (b *Broker) consumeDeliveries(deliveries <-chan *awssqs.ReceiveMessageOutput, concurrency int, taskProcessor iface.TaskProcessor, pool chan struct{}, errorsChan chan error) (bool, error) {
select {
case err := <-errorsChan:
return false, err
case d := <-deliveries:
if concurrency > 0 {
// get worker from pool (blocks until one is available)
<-pool
}
b.processingWG.Add(1)
// Consume the task inside a goroutine so multiple tasks
// can be processed concurrently
go func() {
if err := b.consumeOne(d, taskProcessor); err != nil {
errorsChan <- err
}
b.processingWG.Done()
if concurrency > 0 {
// give worker back to pool
pool <- struct{}{}
}
}()
case <-b.GetStopChan():
return false, nil
}
return true, nil
} | go | func (b *Broker) consumeDeliveries(deliveries <-chan *awssqs.ReceiveMessageOutput, concurrency int, taskProcessor iface.TaskProcessor, pool chan struct{}, errorsChan chan error) (bool, error) {
select {
case err := <-errorsChan:
return false, err
case d := <-deliveries:
if concurrency > 0 {
// get worker from pool (blocks until one is available)
<-pool
}
b.processingWG.Add(1)
// Consume the task inside a goroutine so multiple tasks
// can be processed concurrently
go func() {
if err := b.consumeOne(d, taskProcessor); err != nil {
errorsChan <- err
}
b.processingWG.Done()
if concurrency > 0 {
// give worker back to pool
pool <- struct{}{}
}
}()
case <-b.GetStopChan():
return false, nil
}
return true, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"consumeDeliveries",
"(",
"deliveries",
"<-",
"chan",
"*",
"awssqs",
".",
"ReceiveMessageOutput",
",",
"concurrency",
"int",
",",
"taskProcessor",
"iface",
".",
"TaskProcessor",
",",
"pool",
"chan",
"struct",
"{",
"}",
",",
"errorsChan",
"chan",
"error",
")",
"(",
"bool",
",",
"error",
")",
"{",
"select",
"{",
"case",
"err",
":=",
"<-",
"errorsChan",
":",
"return",
"false",
",",
"err",
"\n",
"case",
"d",
":=",
"<-",
"deliveries",
":",
"if",
"concurrency",
">",
"0",
"{",
"<-",
"pool",
"\n",
"}",
"\n",
"b",
".",
"processingWG",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"b",
".",
"consumeOne",
"(",
"d",
",",
"taskProcessor",
")",
";",
"err",
"!=",
"nil",
"{",
"errorsChan",
"<-",
"err",
"\n",
"}",
"\n",
"b",
".",
"processingWG",
".",
"Done",
"(",
")",
"\n",
"if",
"concurrency",
">",
"0",
"{",
"pool",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"case",
"<-",
"b",
".",
"GetStopChan",
"(",
")",
":",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // consumeDeliveries is a method consuming deliveries from deliveries channel | [
"consumeDeliveries",
"is",
"a",
"method",
"consuming",
"deliveries",
"from",
"deliveries",
"channel"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L300-L331 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | continueReceivingMessages | func (b *Broker) continueReceivingMessages(qURL *string, deliveries chan *awssqs.ReceiveMessageOutput) (bool, error) {
select {
// A way to stop this goroutine from b.StopConsuming
case <-b.stopReceivingChan:
return false, nil
default:
output, err := b.receiveMessage(qURL)
if err != nil {
return true, err
}
if len(output.Messages) == 0 {
return true, nil
}
go func() { deliveries <- output }()
}
return true, nil
} | go | func (b *Broker) continueReceivingMessages(qURL *string, deliveries chan *awssqs.ReceiveMessageOutput) (bool, error) {
select {
// A way to stop this goroutine from b.StopConsuming
case <-b.stopReceivingChan:
return false, nil
default:
output, err := b.receiveMessage(qURL)
if err != nil {
return true, err
}
if len(output.Messages) == 0 {
return true, nil
}
go func() { deliveries <- output }()
}
return true, nil
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"continueReceivingMessages",
"(",
"qURL",
"*",
"string",
",",
"deliveries",
"chan",
"*",
"awssqs",
".",
"ReceiveMessageOutput",
")",
"(",
"bool",
",",
"error",
")",
"{",
"select",
"{",
"case",
"<-",
"b",
".",
"stopReceivingChan",
":",
"return",
"false",
",",
"nil",
"\n",
"default",
":",
"output",
",",
"err",
":=",
"b",
".",
"receiveMessage",
"(",
"qURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"true",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"output",
".",
"Messages",
")",
"==",
"0",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"deliveries",
"<-",
"output",
"}",
"(",
")",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // continueReceivingMessages is a method returns a continue signal | [
"continueReceivingMessages",
"is",
"a",
"method",
"returns",
"a",
"continue",
"signal"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L334-L350 | train |
RichardKnop/machinery | v1/brokers/sqs/sqs.go | getQueueURL | func (b *Broker) getQueueURL(taskProcessor iface.TaskProcessor) *string {
queueName := b.GetConfig().DefaultQueue
if taskProcessor.CustomQueue() != "" {
queueName = taskProcessor.CustomQueue()
}
return aws.String(b.GetConfig().Broker + "/" + queueName)
} | go | func (b *Broker) getQueueURL(taskProcessor iface.TaskProcessor) *string {
queueName := b.GetConfig().DefaultQueue
if taskProcessor.CustomQueue() != "" {
queueName = taskProcessor.CustomQueue()
}
return aws.String(b.GetConfig().Broker + "/" + queueName)
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"getQueueURL",
"(",
"taskProcessor",
"iface",
".",
"TaskProcessor",
")",
"*",
"string",
"{",
"queueName",
":=",
"b",
".",
"GetConfig",
"(",
")",
".",
"DefaultQueue",
"\n",
"if",
"taskProcessor",
".",
"CustomQueue",
"(",
")",
"!=",
"\"\"",
"{",
"queueName",
"=",
"taskProcessor",
".",
"CustomQueue",
"(",
")",
"\n",
"}",
"\n",
"return",
"aws",
".",
"String",
"(",
"b",
".",
"GetConfig",
"(",
")",
".",
"Broker",
"+",
"\"/\"",
"+",
"queueName",
")",
"\n",
"}"
] | // getQueueURL is a method returns that returns queueURL first by checking if custom queue was set and usign it
// otherwise using default queueName from config | [
"getQueueURL",
"is",
"a",
"method",
"returns",
"that",
"returns",
"queueURL",
"first",
"by",
"checking",
"if",
"custom",
"queue",
"was",
"set",
"and",
"usign",
"it",
"otherwise",
"using",
"default",
"queueName",
"from",
"config"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/brokers/sqs/sqs.go#L360-L367 | train |
RichardKnop/machinery | v1/tasks/workflow.go | GetUUIDs | func (group *Group) GetUUIDs() []string {
taskUUIDs := make([]string, len(group.Tasks))
for i, signature := range group.Tasks {
taskUUIDs[i] = signature.UUID
}
return taskUUIDs
} | go | func (group *Group) GetUUIDs() []string {
taskUUIDs := make([]string, len(group.Tasks))
for i, signature := range group.Tasks {
taskUUIDs[i] = signature.UUID
}
return taskUUIDs
} | [
"func",
"(",
"group",
"*",
"Group",
")",
"GetUUIDs",
"(",
")",
"[",
"]",
"string",
"{",
"taskUUIDs",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"group",
".",
"Tasks",
")",
")",
"\n",
"for",
"i",
",",
"signature",
":=",
"range",
"group",
".",
"Tasks",
"{",
"taskUUIDs",
"[",
"i",
"]",
"=",
"signature",
".",
"UUID",
"\n",
"}",
"\n",
"return",
"taskUUIDs",
"\n",
"}"
] | // GetUUIDs returns slice of task UUIDS | [
"GetUUIDs",
"returns",
"slice",
"of",
"task",
"UUIDS"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/workflow.go#L28-L34 | train |
RichardKnop/machinery | v1/tasks/workflow.go | NewChain | func NewChain(signatures ...*Signature) (*Chain, error) {
// Auto generate task UUIDs if needed
for _, signature := range signatures {
if signature.UUID == "" {
signatureID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", signatureID)
}
}
for i := len(signatures) - 1; i > 0; i-- {
if i > 0 {
signatures[i-1].OnSuccess = []*Signature{signatures[i]}
}
}
chain := &Chain{Tasks: signatures}
return chain, nil
} | go | func NewChain(signatures ...*Signature) (*Chain, error) {
// Auto generate task UUIDs if needed
for _, signature := range signatures {
if signature.UUID == "" {
signatureID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", signatureID)
}
}
for i := len(signatures) - 1; i > 0; i-- {
if i > 0 {
signatures[i-1].OnSuccess = []*Signature{signatures[i]}
}
}
chain := &Chain{Tasks: signatures}
return chain, nil
} | [
"func",
"NewChain",
"(",
"signatures",
"...",
"*",
"Signature",
")",
"(",
"*",
"Chain",
",",
"error",
")",
"{",
"for",
"_",
",",
"signature",
":=",
"range",
"signatures",
"{",
"if",
"signature",
".",
"UUID",
"==",
"\"\"",
"{",
"signatureID",
":=",
"uuid",
".",
"New",
"(",
")",
".",
"String",
"(",
")",
"\n",
"signature",
".",
"UUID",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"task_%v\"",
",",
"signatureID",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"i",
":=",
"len",
"(",
"signatures",
")",
"-",
"1",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"if",
"i",
">",
"0",
"{",
"signatures",
"[",
"i",
"-",
"1",
"]",
".",
"OnSuccess",
"=",
"[",
"]",
"*",
"Signature",
"{",
"signatures",
"[",
"i",
"]",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"chain",
":=",
"&",
"Chain",
"{",
"Tasks",
":",
"signatures",
"}",
"\n",
"return",
"chain",
",",
"nil",
"\n",
"}"
] | // NewChain creates a new chain of tasks to be processed one by one, passing
// results unless task signatures are set to be immutable | [
"NewChain",
"creates",
"a",
"new",
"chain",
"of",
"tasks",
"to",
"be",
"processed",
"one",
"by",
"one",
"passing",
"results",
"unless",
"task",
"signatures",
"are",
"set",
"to",
"be",
"immutable"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/workflow.go#L38-L56 | train |
RichardKnop/machinery | v1/tasks/workflow.go | NewGroup | func NewGroup(signatures ...*Signature) (*Group, error) {
// Generate a group UUID
groupUUID := uuid.New().String()
groupID := fmt.Sprintf("group_%v", groupUUID)
// Auto generate task UUIDs if needed, group tasks by common group UUID
for _, signature := range signatures {
if signature.UUID == "" {
signatureID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", signatureID)
}
signature.GroupUUID = groupID
signature.GroupTaskCount = len(signatures)
}
return &Group{
GroupUUID: groupID,
Tasks: signatures,
}, nil
} | go | func NewGroup(signatures ...*Signature) (*Group, error) {
// Generate a group UUID
groupUUID := uuid.New().String()
groupID := fmt.Sprintf("group_%v", groupUUID)
// Auto generate task UUIDs if needed, group tasks by common group UUID
for _, signature := range signatures {
if signature.UUID == "" {
signatureID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", signatureID)
}
signature.GroupUUID = groupID
signature.GroupTaskCount = len(signatures)
}
return &Group{
GroupUUID: groupID,
Tasks: signatures,
}, nil
} | [
"func",
"NewGroup",
"(",
"signatures",
"...",
"*",
"Signature",
")",
"(",
"*",
"Group",
",",
"error",
")",
"{",
"groupUUID",
":=",
"uuid",
".",
"New",
"(",
")",
".",
"String",
"(",
")",
"\n",
"groupID",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"group_%v\"",
",",
"groupUUID",
")",
"\n",
"for",
"_",
",",
"signature",
":=",
"range",
"signatures",
"{",
"if",
"signature",
".",
"UUID",
"==",
"\"\"",
"{",
"signatureID",
":=",
"uuid",
".",
"New",
"(",
")",
".",
"String",
"(",
")",
"\n",
"signature",
".",
"UUID",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"task_%v\"",
",",
"signatureID",
")",
"\n",
"}",
"\n",
"signature",
".",
"GroupUUID",
"=",
"groupID",
"\n",
"signature",
".",
"GroupTaskCount",
"=",
"len",
"(",
"signatures",
")",
"\n",
"}",
"\n",
"return",
"&",
"Group",
"{",
"GroupUUID",
":",
"groupID",
",",
"Tasks",
":",
"signatures",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewGroup creates a new group of tasks to be processed in parallel | [
"NewGroup",
"creates",
"a",
"new",
"group",
"of",
"tasks",
"to",
"be",
"processed",
"in",
"parallel"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/workflow.go#L59-L78 | train |
RichardKnop/machinery | v1/backends/amqp/amqp.go | GetState | func (b *Backend) GetState(taskUUID string) (*tasks.TaskState, error) {
declareQueueArgs := amqp.Table{
// Time in milliseconds
// after that message will expire
"x-message-ttl": int32(b.getExpiresIn()),
// Time after that the queue will be deleted.
"x-expires": int32(b.getExpiresIn()),
}
conn, channel, _, _, _, err := b.Connect(
b.GetConfig().Broker,
b.GetConfig().TLSConfig,
b.GetConfig().AMQP.Exchange, // exchange name
b.GetConfig().AMQP.ExchangeType, // exchange type
taskUUID, // queue name
false, // queue durable
true, // queue delete when unused
taskUUID, // queue binding key
nil, // exchange declare args
declareQueueArgs, // queue declare args
nil, // queue binding args
)
if err != nil {
return nil, err
}
defer b.Close(channel, conn)
d, ok, err := channel.Get(
taskUUID, // queue name
false, // multiple
)
if err != nil {
return nil, err
}
if !ok {
return nil, errors.New("No state ready")
}
d.Ack(false)
state := new(tasks.TaskState)
decoder := json.NewDecoder(bytes.NewReader([]byte(d.Body)))
decoder.UseNumber()
if err := decoder.Decode(state); err != nil {
log.ERROR.Printf("Failed to unmarshal task state: %s", string(d.Body))
log.ERROR.Print(err)
return nil, err
}
return state, nil
} | go | func (b *Backend) GetState(taskUUID string) (*tasks.TaskState, error) {
declareQueueArgs := amqp.Table{
// Time in milliseconds
// after that message will expire
"x-message-ttl": int32(b.getExpiresIn()),
// Time after that the queue will be deleted.
"x-expires": int32(b.getExpiresIn()),
}
conn, channel, _, _, _, err := b.Connect(
b.GetConfig().Broker,
b.GetConfig().TLSConfig,
b.GetConfig().AMQP.Exchange, // exchange name
b.GetConfig().AMQP.ExchangeType, // exchange type
taskUUID, // queue name
false, // queue durable
true, // queue delete when unused
taskUUID, // queue binding key
nil, // exchange declare args
declareQueueArgs, // queue declare args
nil, // queue binding args
)
if err != nil {
return nil, err
}
defer b.Close(channel, conn)
d, ok, err := channel.Get(
taskUUID, // queue name
false, // multiple
)
if err != nil {
return nil, err
}
if !ok {
return nil, errors.New("No state ready")
}
d.Ack(false)
state := new(tasks.TaskState)
decoder := json.NewDecoder(bytes.NewReader([]byte(d.Body)))
decoder.UseNumber()
if err := decoder.Decode(state); err != nil {
log.ERROR.Printf("Failed to unmarshal task state: %s", string(d.Body))
log.ERROR.Print(err)
return nil, err
}
return state, nil
} | [
"func",
"(",
"b",
"*",
"Backend",
")",
"GetState",
"(",
"taskUUID",
"string",
")",
"(",
"*",
"tasks",
".",
"TaskState",
",",
"error",
")",
"{",
"declareQueueArgs",
":=",
"amqp",
".",
"Table",
"{",
"\"x-message-ttl\"",
":",
"int32",
"(",
"b",
".",
"getExpiresIn",
"(",
")",
")",
",",
"\"x-expires\"",
":",
"int32",
"(",
"b",
".",
"getExpiresIn",
"(",
")",
")",
",",
"}",
"\n",
"conn",
",",
"channel",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"b",
".",
"Connect",
"(",
"b",
".",
"GetConfig",
"(",
")",
".",
"Broker",
",",
"b",
".",
"GetConfig",
"(",
")",
".",
"TLSConfig",
",",
"b",
".",
"GetConfig",
"(",
")",
".",
"AMQP",
".",
"Exchange",
",",
"b",
".",
"GetConfig",
"(",
")",
".",
"AMQP",
".",
"ExchangeType",
",",
"taskUUID",
",",
"false",
",",
"true",
",",
"taskUUID",
",",
"nil",
",",
"declareQueueArgs",
",",
"nil",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"b",
".",
"Close",
"(",
"channel",
",",
"conn",
")",
"\n",
"d",
",",
"ok",
",",
"err",
":=",
"channel",
".",
"Get",
"(",
"taskUUID",
",",
"false",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"No state ready\"",
")",
"\n",
"}",
"\n",
"d",
".",
"Ack",
"(",
"false",
")",
"\n",
"state",
":=",
"new",
"(",
"tasks",
".",
"TaskState",
")",
"\n",
"decoder",
":=",
"json",
".",
"NewDecoder",
"(",
"bytes",
".",
"NewReader",
"(",
"[",
"]",
"byte",
"(",
"d",
".",
"Body",
")",
")",
")",
"\n",
"decoder",
".",
"UseNumber",
"(",
")",
"\n",
"if",
"err",
":=",
"decoder",
".",
"Decode",
"(",
"state",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"ERROR",
".",
"Printf",
"(",
"\"Failed to unmarshal task state: %s\"",
",",
"string",
"(",
"d",
".",
"Body",
")",
")",
"\n",
"log",
".",
"ERROR",
".",
"Print",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"state",
",",
"nil",
"\n",
"}"
] | // GetState returns the latest task state. It will only return the status once
// as the message will get consumed and removed from the queue. | [
"GetState",
"returns",
"the",
"latest",
"task",
"state",
".",
"It",
"will",
"only",
"return",
"the",
"status",
"once",
"as",
"the",
"message",
"will",
"get",
"consumed",
"and",
"removed",
"from",
"the",
"queue",
"."
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/amqp/amqp.go#L190-L239 | train |
RichardKnop/machinery | v1/backends/amqp/amqp.go | getExpiresIn | func (b *Backend) getExpiresIn() int {
resultsExpireIn := b.GetConfig().ResultsExpireIn * 1000
if resultsExpireIn == 0 {
// // expire results after 1 hour by default
resultsExpireIn = config.DefaultResultsExpireIn * 1000
}
return resultsExpireIn
} | go | func (b *Backend) getExpiresIn() int {
resultsExpireIn := b.GetConfig().ResultsExpireIn * 1000
if resultsExpireIn == 0 {
// // expire results after 1 hour by default
resultsExpireIn = config.DefaultResultsExpireIn * 1000
}
return resultsExpireIn
} | [
"func",
"(",
"b",
"*",
"Backend",
")",
"getExpiresIn",
"(",
")",
"int",
"{",
"resultsExpireIn",
":=",
"b",
".",
"GetConfig",
"(",
")",
".",
"ResultsExpireIn",
"*",
"1000",
"\n",
"if",
"resultsExpireIn",
"==",
"0",
"{",
"resultsExpireIn",
"=",
"config",
".",
"DefaultResultsExpireIn",
"*",
"1000",
"\n",
"}",
"\n",
"return",
"resultsExpireIn",
"\n",
"}"
] | // getExpiresIn returns expiration time | [
"getExpiresIn",
"returns",
"expiration",
"time"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/amqp/amqp.go#L321-L328 | train |
RichardKnop/machinery | v1/common/redis.go | NewPool | func (rc *RedisConnector) NewPool(socketPath, host, password string, db int, cnf *config.RedisConfig, tlsConfig *tls.Config) *redis.Pool {
if cnf == nil {
cnf = defaultConfig
}
return &redis.Pool{
MaxIdle: cnf.MaxIdle,
IdleTimeout: time.Duration(cnf.IdleTimeout) * time.Second,
MaxActive: cnf.MaxActive,
Wait: cnf.Wait,
Dial: func() (redis.Conn, error) {
c, err := rc.open(socketPath, host, password, db, cnf, tlsConfig)
if err != nil {
return nil, err
}
if db != 0 {
_, err = c.Do("SELECT", db)
if err != nil {
return nil, err
}
}
return c, err
},
// PINGs connections that have been idle more than 10 seconds
TestOnBorrow: func(c redis.Conn, t time.Time) error {
if time.Since(t) < time.Duration(10*time.Second) {
return nil
}
_, err := c.Do("PING")
return err
},
}
} | go | func (rc *RedisConnector) NewPool(socketPath, host, password string, db int, cnf *config.RedisConfig, tlsConfig *tls.Config) *redis.Pool {
if cnf == nil {
cnf = defaultConfig
}
return &redis.Pool{
MaxIdle: cnf.MaxIdle,
IdleTimeout: time.Duration(cnf.IdleTimeout) * time.Second,
MaxActive: cnf.MaxActive,
Wait: cnf.Wait,
Dial: func() (redis.Conn, error) {
c, err := rc.open(socketPath, host, password, db, cnf, tlsConfig)
if err != nil {
return nil, err
}
if db != 0 {
_, err = c.Do("SELECT", db)
if err != nil {
return nil, err
}
}
return c, err
},
// PINGs connections that have been idle more than 10 seconds
TestOnBorrow: func(c redis.Conn, t time.Time) error {
if time.Since(t) < time.Duration(10*time.Second) {
return nil
}
_, err := c.Do("PING")
return err
},
}
} | [
"func",
"(",
"rc",
"*",
"RedisConnector",
")",
"NewPool",
"(",
"socketPath",
",",
"host",
",",
"password",
"string",
",",
"db",
"int",
",",
"cnf",
"*",
"config",
".",
"RedisConfig",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
")",
"*",
"redis",
".",
"Pool",
"{",
"if",
"cnf",
"==",
"nil",
"{",
"cnf",
"=",
"defaultConfig",
"\n",
"}",
"\n",
"return",
"&",
"redis",
".",
"Pool",
"{",
"MaxIdle",
":",
"cnf",
".",
"MaxIdle",
",",
"IdleTimeout",
":",
"time",
".",
"Duration",
"(",
"cnf",
".",
"IdleTimeout",
")",
"*",
"time",
".",
"Second",
",",
"MaxActive",
":",
"cnf",
".",
"MaxActive",
",",
"Wait",
":",
"cnf",
".",
"Wait",
",",
"Dial",
":",
"func",
"(",
")",
"(",
"redis",
".",
"Conn",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"rc",
".",
"open",
"(",
"socketPath",
",",
"host",
",",
"password",
",",
"db",
",",
"cnf",
",",
"tlsConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"db",
"!=",
"0",
"{",
"_",
",",
"err",
"=",
"c",
".",
"Do",
"(",
"\"SELECT\"",
",",
"db",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"c",
",",
"err",
"\n",
"}",
",",
"TestOnBorrow",
":",
"func",
"(",
"c",
"redis",
".",
"Conn",
",",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"if",
"time",
".",
"Since",
"(",
"t",
")",
"<",
"time",
".",
"Duration",
"(",
"10",
"*",
"time",
".",
"Second",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"Do",
"(",
"\"PING\"",
")",
"\n",
"return",
"err",
"\n",
"}",
",",
"}",
"\n",
"}"
] | // NewPool returns a new pool of Redis connections | [
"NewPool",
"returns",
"a",
"new",
"pool",
"of",
"Redis",
"connections"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/redis.go#L26-L59 | train |
RichardKnop/machinery | v1/common/redis.go | open | func (rc *RedisConnector) open(socketPath, host, password string, db int, cnf *config.RedisConfig, tlsConfig *tls.Config) (redis.Conn, error) {
var opts = []redis.DialOption{
redis.DialDatabase(db),
redis.DialReadTimeout(time.Duration(cnf.ReadTimeout) * time.Second),
redis.DialWriteTimeout(time.Duration(cnf.WriteTimeout) * time.Second),
redis.DialConnectTimeout(time.Duration(cnf.ConnectTimeout) * time.Second),
}
if tlsConfig != nil {
opts = append(opts, redis.DialTLSConfig(tlsConfig), redis.DialUseTLS(true))
}
if password != "" {
opts = append(opts, redis.DialPassword(password))
}
if socketPath != "" {
return redis.Dial("unix", socketPath, opts...)
}
return redis.Dial("tcp", host, opts...)
} | go | func (rc *RedisConnector) open(socketPath, host, password string, db int, cnf *config.RedisConfig, tlsConfig *tls.Config) (redis.Conn, error) {
var opts = []redis.DialOption{
redis.DialDatabase(db),
redis.DialReadTimeout(time.Duration(cnf.ReadTimeout) * time.Second),
redis.DialWriteTimeout(time.Duration(cnf.WriteTimeout) * time.Second),
redis.DialConnectTimeout(time.Duration(cnf.ConnectTimeout) * time.Second),
}
if tlsConfig != nil {
opts = append(opts, redis.DialTLSConfig(tlsConfig), redis.DialUseTLS(true))
}
if password != "" {
opts = append(opts, redis.DialPassword(password))
}
if socketPath != "" {
return redis.Dial("unix", socketPath, opts...)
}
return redis.Dial("tcp", host, opts...)
} | [
"func",
"(",
"rc",
"*",
"RedisConnector",
")",
"open",
"(",
"socketPath",
",",
"host",
",",
"password",
"string",
",",
"db",
"int",
",",
"cnf",
"*",
"config",
".",
"RedisConfig",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
")",
"(",
"redis",
".",
"Conn",
",",
"error",
")",
"{",
"var",
"opts",
"=",
"[",
"]",
"redis",
".",
"DialOption",
"{",
"redis",
".",
"DialDatabase",
"(",
"db",
")",
",",
"redis",
".",
"DialReadTimeout",
"(",
"time",
".",
"Duration",
"(",
"cnf",
".",
"ReadTimeout",
")",
"*",
"time",
".",
"Second",
")",
",",
"redis",
".",
"DialWriteTimeout",
"(",
"time",
".",
"Duration",
"(",
"cnf",
".",
"WriteTimeout",
")",
"*",
"time",
".",
"Second",
")",
",",
"redis",
".",
"DialConnectTimeout",
"(",
"time",
".",
"Duration",
"(",
"cnf",
".",
"ConnectTimeout",
")",
"*",
"time",
".",
"Second",
")",
",",
"}",
"\n",
"if",
"tlsConfig",
"!=",
"nil",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"redis",
".",
"DialTLSConfig",
"(",
"tlsConfig",
")",
",",
"redis",
".",
"DialUseTLS",
"(",
"true",
")",
")",
"\n",
"}",
"\n",
"if",
"password",
"!=",
"\"\"",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"redis",
".",
"DialPassword",
"(",
"password",
")",
")",
"\n",
"}",
"\n",
"if",
"socketPath",
"!=",
"\"\"",
"{",
"return",
"redis",
".",
"Dial",
"(",
"\"unix\"",
",",
"socketPath",
",",
"opts",
"...",
")",
"\n",
"}",
"\n",
"return",
"redis",
".",
"Dial",
"(",
"\"tcp\"",
",",
"host",
",",
"opts",
"...",
")",
"\n",
"}"
] | // Open a new Redis connection | [
"Open",
"a",
"new",
"Redis",
"connection"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/redis.go#L62-L83 | train |
RichardKnop/machinery | v1/backends/result/async_result.go | NewAsyncResult | func NewAsyncResult(signature *tasks.Signature, backend iface.Backend) *AsyncResult {
return &AsyncResult{
Signature: signature,
taskState: new(tasks.TaskState),
backend: backend,
}
} | go | func NewAsyncResult(signature *tasks.Signature, backend iface.Backend) *AsyncResult {
return &AsyncResult{
Signature: signature,
taskState: new(tasks.TaskState),
backend: backend,
}
} | [
"func",
"NewAsyncResult",
"(",
"signature",
"*",
"tasks",
".",
"Signature",
",",
"backend",
"iface",
".",
"Backend",
")",
"*",
"AsyncResult",
"{",
"return",
"&",
"AsyncResult",
"{",
"Signature",
":",
"signature",
",",
"taskState",
":",
"new",
"(",
"tasks",
".",
"TaskState",
")",
",",
"backend",
":",
"backend",
",",
"}",
"\n",
"}"
] | // NewAsyncResult creates AsyncResult instance | [
"NewAsyncResult",
"creates",
"AsyncResult",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/result/async_result.go#L40-L46 | train |
RichardKnop/machinery | v1/backends/result/async_result.go | NewChordAsyncResult | func NewChordAsyncResult(groupTasks []*tasks.Signature, chordCallback *tasks.Signature, backend iface.Backend) *ChordAsyncResult {
asyncResults := make([]*AsyncResult, len(groupTasks))
for i, task := range groupTasks {
asyncResults[i] = NewAsyncResult(task, backend)
}
return &ChordAsyncResult{
groupAsyncResults: asyncResults,
chordAsyncResult: NewAsyncResult(chordCallback, backend),
backend: backend,
}
} | go | func NewChordAsyncResult(groupTasks []*tasks.Signature, chordCallback *tasks.Signature, backend iface.Backend) *ChordAsyncResult {
asyncResults := make([]*AsyncResult, len(groupTasks))
for i, task := range groupTasks {
asyncResults[i] = NewAsyncResult(task, backend)
}
return &ChordAsyncResult{
groupAsyncResults: asyncResults,
chordAsyncResult: NewAsyncResult(chordCallback, backend),
backend: backend,
}
} | [
"func",
"NewChordAsyncResult",
"(",
"groupTasks",
"[",
"]",
"*",
"tasks",
".",
"Signature",
",",
"chordCallback",
"*",
"tasks",
".",
"Signature",
",",
"backend",
"iface",
".",
"Backend",
")",
"*",
"ChordAsyncResult",
"{",
"asyncResults",
":=",
"make",
"(",
"[",
"]",
"*",
"AsyncResult",
",",
"len",
"(",
"groupTasks",
")",
")",
"\n",
"for",
"i",
",",
"task",
":=",
"range",
"groupTasks",
"{",
"asyncResults",
"[",
"i",
"]",
"=",
"NewAsyncResult",
"(",
"task",
",",
"backend",
")",
"\n",
"}",
"\n",
"return",
"&",
"ChordAsyncResult",
"{",
"groupAsyncResults",
":",
"asyncResults",
",",
"chordAsyncResult",
":",
"NewAsyncResult",
"(",
"chordCallback",
",",
"backend",
")",
",",
"backend",
":",
"backend",
",",
"}",
"\n",
"}"
] | // NewChordAsyncResult creates ChordAsyncResult instance | [
"NewChordAsyncResult",
"creates",
"ChordAsyncResult",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/result/async_result.go#L49-L59 | train |
RichardKnop/machinery | v1/backends/result/async_result.go | NewChainAsyncResult | func NewChainAsyncResult(tasks []*tasks.Signature, backend iface.Backend) *ChainAsyncResult {
asyncResults := make([]*AsyncResult, len(tasks))
for i, task := range tasks {
asyncResults[i] = NewAsyncResult(task, backend)
}
return &ChainAsyncResult{
asyncResults: asyncResults,
backend: backend,
}
} | go | func NewChainAsyncResult(tasks []*tasks.Signature, backend iface.Backend) *ChainAsyncResult {
asyncResults := make([]*AsyncResult, len(tasks))
for i, task := range tasks {
asyncResults[i] = NewAsyncResult(task, backend)
}
return &ChainAsyncResult{
asyncResults: asyncResults,
backend: backend,
}
} | [
"func",
"NewChainAsyncResult",
"(",
"tasks",
"[",
"]",
"*",
"tasks",
".",
"Signature",
",",
"backend",
"iface",
".",
"Backend",
")",
"*",
"ChainAsyncResult",
"{",
"asyncResults",
":=",
"make",
"(",
"[",
"]",
"*",
"AsyncResult",
",",
"len",
"(",
"tasks",
")",
")",
"\n",
"for",
"i",
",",
"task",
":=",
"range",
"tasks",
"{",
"asyncResults",
"[",
"i",
"]",
"=",
"NewAsyncResult",
"(",
"task",
",",
"backend",
")",
"\n",
"}",
"\n",
"return",
"&",
"ChainAsyncResult",
"{",
"asyncResults",
":",
"asyncResults",
",",
"backend",
":",
"backend",
",",
"}",
"\n",
"}"
] | // NewChainAsyncResult creates ChainAsyncResult instance | [
"NewChainAsyncResult",
"creates",
"ChainAsyncResult",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/result/async_result.go#L62-L71 | train |
RichardKnop/machinery | v1/backends/result/async_result.go | Touch | func (asyncResult *AsyncResult) Touch() ([]reflect.Value, error) {
if asyncResult.backend == nil {
return nil, ErrBackendNotConfigured
}
asyncResult.GetState()
// Purge state if we are using AMQP backend
if asyncResult.backend.IsAMQP() && asyncResult.taskState.IsCompleted() {
asyncResult.backend.PurgeState(asyncResult.taskState.TaskUUID)
}
if asyncResult.taskState.IsFailure() {
return nil, errors.New(asyncResult.taskState.Error)
}
if asyncResult.taskState.IsSuccess() {
return tasks.ReflectTaskResults(asyncResult.taskState.Results)
}
return nil, nil
} | go | func (asyncResult *AsyncResult) Touch() ([]reflect.Value, error) {
if asyncResult.backend == nil {
return nil, ErrBackendNotConfigured
}
asyncResult.GetState()
// Purge state if we are using AMQP backend
if asyncResult.backend.IsAMQP() && asyncResult.taskState.IsCompleted() {
asyncResult.backend.PurgeState(asyncResult.taskState.TaskUUID)
}
if asyncResult.taskState.IsFailure() {
return nil, errors.New(asyncResult.taskState.Error)
}
if asyncResult.taskState.IsSuccess() {
return tasks.ReflectTaskResults(asyncResult.taskState.Results)
}
return nil, nil
} | [
"func",
"(",
"asyncResult",
"*",
"AsyncResult",
")",
"Touch",
"(",
")",
"(",
"[",
"]",
"reflect",
".",
"Value",
",",
"error",
")",
"{",
"if",
"asyncResult",
".",
"backend",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrBackendNotConfigured",
"\n",
"}",
"\n",
"asyncResult",
".",
"GetState",
"(",
")",
"\n",
"if",
"asyncResult",
".",
"backend",
".",
"IsAMQP",
"(",
")",
"&&",
"asyncResult",
".",
"taskState",
".",
"IsCompleted",
"(",
")",
"{",
"asyncResult",
".",
"backend",
".",
"PurgeState",
"(",
"asyncResult",
".",
"taskState",
".",
"TaskUUID",
")",
"\n",
"}",
"\n",
"if",
"asyncResult",
".",
"taskState",
".",
"IsFailure",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"asyncResult",
".",
"taskState",
".",
"Error",
")",
"\n",
"}",
"\n",
"if",
"asyncResult",
".",
"taskState",
".",
"IsSuccess",
"(",
")",
"{",
"return",
"tasks",
".",
"ReflectTaskResults",
"(",
"asyncResult",
".",
"taskState",
".",
"Results",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // Touch the state and don't wait | [
"Touch",
"the",
"state",
"and",
"don",
"t",
"wait"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/result/async_result.go#L74-L95 | train |
RichardKnop/machinery | v1/backends/result/async_result.go | GetState | func (asyncResult *AsyncResult) GetState() *tasks.TaskState {
if asyncResult.taskState.IsCompleted() {
return asyncResult.taskState
}
taskState, err := asyncResult.backend.GetState(asyncResult.Signature.UUID)
if err == nil {
asyncResult.taskState = taskState
}
return asyncResult.taskState
} | go | func (asyncResult *AsyncResult) GetState() *tasks.TaskState {
if asyncResult.taskState.IsCompleted() {
return asyncResult.taskState
}
taskState, err := asyncResult.backend.GetState(asyncResult.Signature.UUID)
if err == nil {
asyncResult.taskState = taskState
}
return asyncResult.taskState
} | [
"func",
"(",
"asyncResult",
"*",
"AsyncResult",
")",
"GetState",
"(",
")",
"*",
"tasks",
".",
"TaskState",
"{",
"if",
"asyncResult",
".",
"taskState",
".",
"IsCompleted",
"(",
")",
"{",
"return",
"asyncResult",
".",
"taskState",
"\n",
"}",
"\n",
"taskState",
",",
"err",
":=",
"asyncResult",
".",
"backend",
".",
"GetState",
"(",
"asyncResult",
".",
"Signature",
".",
"UUID",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"asyncResult",
".",
"taskState",
"=",
"taskState",
"\n",
"}",
"\n",
"return",
"asyncResult",
".",
"taskState",
"\n",
"}"
] | // GetState returns latest task state | [
"GetState",
"returns",
"latest",
"task",
"state"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/result/async_result.go#L131-L142 | train |
RichardKnop/machinery | v1/tasks/validate.go | ValidateTask | func ValidateTask(task interface{}) error {
v := reflect.ValueOf(task)
t := v.Type()
// Task must be a function
if t.Kind() != reflect.Func {
return ErrTaskMustBeFunc
}
// Task must return at least a single value
if t.NumOut() < 1 {
return ErrTaskReturnsNoValue
}
// Last return value must be error
lastReturnType := t.Out(t.NumOut() - 1)
errorInterface := reflect.TypeOf((*error)(nil)).Elem()
if !lastReturnType.Implements(errorInterface) {
return ErrLastReturnValueMustBeError
}
return nil
} | go | func ValidateTask(task interface{}) error {
v := reflect.ValueOf(task)
t := v.Type()
// Task must be a function
if t.Kind() != reflect.Func {
return ErrTaskMustBeFunc
}
// Task must return at least a single value
if t.NumOut() < 1 {
return ErrTaskReturnsNoValue
}
// Last return value must be error
lastReturnType := t.Out(t.NumOut() - 1)
errorInterface := reflect.TypeOf((*error)(nil)).Elem()
if !lastReturnType.Implements(errorInterface) {
return ErrLastReturnValueMustBeError
}
return nil
} | [
"func",
"ValidateTask",
"(",
"task",
"interface",
"{",
"}",
")",
"error",
"{",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"task",
")",
"\n",
"t",
":=",
"v",
".",
"Type",
"(",
")",
"\n",
"if",
"t",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Func",
"{",
"return",
"ErrTaskMustBeFunc",
"\n",
"}",
"\n",
"if",
"t",
".",
"NumOut",
"(",
")",
"<",
"1",
"{",
"return",
"ErrTaskReturnsNoValue",
"\n",
"}",
"\n",
"lastReturnType",
":=",
"t",
".",
"Out",
"(",
"t",
".",
"NumOut",
"(",
")",
"-",
"1",
")",
"\n",
"errorInterface",
":=",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"error",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"!",
"lastReturnType",
".",
"Implements",
"(",
"errorInterface",
")",
"{",
"return",
"ErrLastReturnValueMustBeError",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ValidateTask validates task function using reflection and makes sure
// it has a proper signature. Functions used as tasks must return at least a
// single value and the last return type must be error | [
"ValidateTask",
"validates",
"task",
"function",
"using",
"reflection",
"and",
"makes",
"sure",
"it",
"has",
"a",
"proper",
"signature",
".",
"Functions",
"used",
"as",
"tasks",
"must",
"return",
"at",
"least",
"a",
"single",
"value",
"and",
"the",
"last",
"return",
"type",
"must",
"be",
"error"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/validate.go#L20-L42 | train |
RichardKnop/machinery | v1/backends/dynamodb/dynamodb.go | New | func New(cnf *config.Config) iface.Backend {
backend := &Backend{Backend: common.NewBackend(cnf), cnf: cnf}
if cnf.DynamoDB != nil && cnf.DynamoDB.Client != nil {
backend.client = cnf.DynamoDB.Client
} else {
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
}))
backend.client = dynamodb.New(sess)
}
// Check if needed tables exist
err := backend.checkRequiredTablesIfExist()
if err != nil {
log.FATAL.Printf("Failed to prepare tables. Error: %v", err)
}
return backend
} | go | func New(cnf *config.Config) iface.Backend {
backend := &Backend{Backend: common.NewBackend(cnf), cnf: cnf}
if cnf.DynamoDB != nil && cnf.DynamoDB.Client != nil {
backend.client = cnf.DynamoDB.Client
} else {
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
}))
backend.client = dynamodb.New(sess)
}
// Check if needed tables exist
err := backend.checkRequiredTablesIfExist()
if err != nil {
log.FATAL.Printf("Failed to prepare tables. Error: %v", err)
}
return backend
} | [
"func",
"New",
"(",
"cnf",
"*",
"config",
".",
"Config",
")",
"iface",
".",
"Backend",
"{",
"backend",
":=",
"&",
"Backend",
"{",
"Backend",
":",
"common",
".",
"NewBackend",
"(",
"cnf",
")",
",",
"cnf",
":",
"cnf",
"}",
"\n",
"if",
"cnf",
".",
"DynamoDB",
"!=",
"nil",
"&&",
"cnf",
".",
"DynamoDB",
".",
"Client",
"!=",
"nil",
"{",
"backend",
".",
"client",
"=",
"cnf",
".",
"DynamoDB",
".",
"Client",
"\n",
"}",
"else",
"{",
"sess",
":=",
"session",
".",
"Must",
"(",
"session",
".",
"NewSessionWithOptions",
"(",
"session",
".",
"Options",
"{",
"SharedConfigState",
":",
"session",
".",
"SharedConfigEnable",
",",
"}",
")",
")",
"\n",
"backend",
".",
"client",
"=",
"dynamodb",
".",
"New",
"(",
"sess",
")",
"\n",
"}",
"\n",
"err",
":=",
"backend",
".",
"checkRequiredTablesIfExist",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"FATAL",
".",
"Printf",
"(",
"\"Failed to prepare tables. Error: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"backend",
"\n",
"}"
] | // New creates a Backend instance | [
"New",
"creates",
"a",
"Backend",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/dynamodb/dynamodb.go#L29-L47 | train |
RichardKnop/machinery | v1/config/env.go | NewFromEnvironment | func NewFromEnvironment(keepReloading bool) (*Config, error) {
cnf, err := fromEnvironment()
if err != nil {
return nil, err
}
log.INFO.Print("Successfully loaded config from the environment")
if keepReloading {
// Open a goroutine to watch remote changes forever
go func() {
for {
// Delay after each request
time.Sleep(reloadDelay)
// Attempt to reload the config
newCnf, newErr := fromEnvironment()
if newErr != nil {
log.WARNING.Printf("Failed to reload config from the environment: %v", newErr)
continue
}
*cnf = *newCnf
// log.INFO.Printf("Successfully reloaded config from the environment")
}
}()
}
return cnf, nil
} | go | func NewFromEnvironment(keepReloading bool) (*Config, error) {
cnf, err := fromEnvironment()
if err != nil {
return nil, err
}
log.INFO.Print("Successfully loaded config from the environment")
if keepReloading {
// Open a goroutine to watch remote changes forever
go func() {
for {
// Delay after each request
time.Sleep(reloadDelay)
// Attempt to reload the config
newCnf, newErr := fromEnvironment()
if newErr != nil {
log.WARNING.Printf("Failed to reload config from the environment: %v", newErr)
continue
}
*cnf = *newCnf
// log.INFO.Printf("Successfully reloaded config from the environment")
}
}()
}
return cnf, nil
} | [
"func",
"NewFromEnvironment",
"(",
"keepReloading",
"bool",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"cnf",
",",
"err",
":=",
"fromEnvironment",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"log",
".",
"INFO",
".",
"Print",
"(",
"\"Successfully loaded config from the environment\"",
")",
"\n",
"if",
"keepReloading",
"{",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"time",
".",
"Sleep",
"(",
"reloadDelay",
")",
"\n",
"newCnf",
",",
"newErr",
":=",
"fromEnvironment",
"(",
")",
"\n",
"if",
"newErr",
"!=",
"nil",
"{",
"log",
".",
"WARNING",
".",
"Printf",
"(",
"\"Failed to reload config from the environment: %v\"",
",",
"newErr",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"*",
"cnf",
"=",
"*",
"newCnf",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"return",
"cnf",
",",
"nil",
"\n",
"}"
] | // NewFromEnvironment creates a config object from environment variables | [
"NewFromEnvironment",
"creates",
"a",
"config",
"object",
"from",
"environment",
"variables"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/config/env.go#L11-L40 | train |
RichardKnop/machinery | v1/common/broker.go | NewBroker | func NewBroker(cnf *config.Config) Broker {
return Broker{cnf: cnf, retry: true}
} | go | func NewBroker(cnf *config.Config) Broker {
return Broker{cnf: cnf, retry: true}
} | [
"func",
"NewBroker",
"(",
"cnf",
"*",
"config",
".",
"Config",
")",
"Broker",
"{",
"return",
"Broker",
"{",
"cnf",
":",
"cnf",
",",
"retry",
":",
"true",
"}",
"\n",
"}"
] | // NewBroker creates new Broker instance | [
"NewBroker",
"creates",
"new",
"Broker",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/broker.go#L24-L26 | train |
RichardKnop/machinery | v1/common/broker.go | IsTaskRegistered | func (b *Broker) IsTaskRegistered(name string) bool {
for _, registeredTaskName := range b.registeredTaskNames {
if registeredTaskName == name {
return true
}
}
return false
} | go | func (b *Broker) IsTaskRegistered(name string) bool {
for _, registeredTaskName := range b.registeredTaskNames {
if registeredTaskName == name {
return true
}
}
return false
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"IsTaskRegistered",
"(",
"name",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"registeredTaskName",
":=",
"range",
"b",
".",
"registeredTaskNames",
"{",
"if",
"registeredTaskName",
"==",
"name",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsTaskRegistered returns true if the task is registered with this broker | [
"IsTaskRegistered",
"returns",
"true",
"if",
"the",
"task",
"is",
"registered",
"with",
"this",
"broker"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/broker.go#L64-L71 | train |
RichardKnop/machinery | v1/common/broker.go | StartConsuming | func (b *Broker) StartConsuming(consumerTag string, concurrency int, taskProcessor iface.TaskProcessor) {
if b.retryFunc == nil {
b.retryFunc = retry.Closure()
}
b.stopChan = make(chan int)
b.retryStopChan = make(chan int)
} | go | func (b *Broker) StartConsuming(consumerTag string, concurrency int, taskProcessor iface.TaskProcessor) {
if b.retryFunc == nil {
b.retryFunc = retry.Closure()
}
b.stopChan = make(chan int)
b.retryStopChan = make(chan int)
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"StartConsuming",
"(",
"consumerTag",
"string",
",",
"concurrency",
"int",
",",
"taskProcessor",
"iface",
".",
"TaskProcessor",
")",
"{",
"if",
"b",
".",
"retryFunc",
"==",
"nil",
"{",
"b",
".",
"retryFunc",
"=",
"retry",
".",
"Closure",
"(",
")",
"\n",
"}",
"\n",
"b",
".",
"stopChan",
"=",
"make",
"(",
"chan",
"int",
")",
"\n",
"b",
".",
"retryStopChan",
"=",
"make",
"(",
"chan",
"int",
")",
"\n",
"}"
] | // StartConsuming is a common part of StartConsuming method | [
"StartConsuming",
"is",
"a",
"common",
"part",
"of",
"StartConsuming",
"method"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/broker.go#L79-L86 | train |
RichardKnop/machinery | v1/common/broker.go | StopConsuming | func (b *Broker) StopConsuming() {
// Do not retry from now on
b.retry = false
// Stop the retry closure earlier
select {
case b.retryStopChan <- 1:
log.WARNING.Print("Stopping retry closure.")
default:
}
// Notifying the stop channel stops consuming of messages
select {
case b.stopChan <- 1:
log.WARNING.Print("Stop channel")
default:
}
} | go | func (b *Broker) StopConsuming() {
// Do not retry from now on
b.retry = false
// Stop the retry closure earlier
select {
case b.retryStopChan <- 1:
log.WARNING.Print("Stopping retry closure.")
default:
}
// Notifying the stop channel stops consuming of messages
select {
case b.stopChan <- 1:
log.WARNING.Print("Stop channel")
default:
}
} | [
"func",
"(",
"b",
"*",
"Broker",
")",
"StopConsuming",
"(",
")",
"{",
"b",
".",
"retry",
"=",
"false",
"\n",
"select",
"{",
"case",
"b",
".",
"retryStopChan",
"<-",
"1",
":",
"log",
".",
"WARNING",
".",
"Print",
"(",
"\"Stopping retry closure.\"",
")",
"\n",
"default",
":",
"}",
"\n",
"select",
"{",
"case",
"b",
".",
"stopChan",
"<-",
"1",
":",
"log",
".",
"WARNING",
".",
"Print",
"(",
"\"Stop channel\"",
")",
"\n",
"default",
":",
"}",
"\n",
"}"
] | // StopConsuming is a common part of StopConsuming | [
"StopConsuming",
"is",
"a",
"common",
"part",
"of",
"StopConsuming"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/common/broker.go#L89-L104 | train |
RichardKnop/machinery | v1/backends/memcache/memcache.go | lockGroupMeta | func (b *Backend) lockGroupMeta(groupMeta *tasks.GroupMeta) error {
groupMeta.Lock = true
encoded, err := json.Marshal(groupMeta)
if err != nil {
return err
}
return b.getClient().Set(&gomemcache.Item{
Key: groupMeta.GroupUUID,
Value: encoded,
Expiration: b.getExpirationTimestamp(),
})
} | go | func (b *Backend) lockGroupMeta(groupMeta *tasks.GroupMeta) error {
groupMeta.Lock = true
encoded, err := json.Marshal(groupMeta)
if err != nil {
return err
}
return b.getClient().Set(&gomemcache.Item{
Key: groupMeta.GroupUUID,
Value: encoded,
Expiration: b.getExpirationTimestamp(),
})
} | [
"func",
"(",
"b",
"*",
"Backend",
")",
"lockGroupMeta",
"(",
"groupMeta",
"*",
"tasks",
".",
"GroupMeta",
")",
"error",
"{",
"groupMeta",
".",
"Lock",
"=",
"true",
"\n",
"encoded",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"groupMeta",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"b",
".",
"getClient",
"(",
")",
".",
"Set",
"(",
"&",
"gomemcache",
".",
"Item",
"{",
"Key",
":",
"groupMeta",
".",
"GroupUUID",
",",
"Value",
":",
"encoded",
",",
"Expiration",
":",
"b",
".",
"getExpirationTimestamp",
"(",
")",
",",
"}",
")",
"\n",
"}"
] | // lockGroupMeta acquires lock on group meta data | [
"lockGroupMeta",
"acquires",
"lock",
"on",
"group",
"meta",
"data"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/memcache/memcache.go#L207-L219 | train |
RichardKnop/machinery | v1/backends/memcache/memcache.go | getExpirationTimestamp | func (b *Backend) getExpirationTimestamp() int32 {
expiresIn := b.GetConfig().ResultsExpireIn
if expiresIn == 0 {
// // expire results after 1 hour by default
expiresIn = config.DefaultResultsExpireIn
}
return int32(time.Now().Unix() + int64(expiresIn))
} | go | func (b *Backend) getExpirationTimestamp() int32 {
expiresIn := b.GetConfig().ResultsExpireIn
if expiresIn == 0 {
// // expire results after 1 hour by default
expiresIn = config.DefaultResultsExpireIn
}
return int32(time.Now().Unix() + int64(expiresIn))
} | [
"func",
"(",
"b",
"*",
"Backend",
")",
"getExpirationTimestamp",
"(",
")",
"int32",
"{",
"expiresIn",
":=",
"b",
".",
"GetConfig",
"(",
")",
".",
"ResultsExpireIn",
"\n",
"if",
"expiresIn",
"==",
"0",
"{",
"expiresIn",
"=",
"config",
".",
"DefaultResultsExpireIn",
"\n",
"}",
"\n",
"return",
"int32",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"+",
"int64",
"(",
"expiresIn",
")",
")",
"\n",
"}"
] | // getExpirationTimestamp returns expiration timestamp | [
"getExpirationTimestamp",
"returns",
"expiration",
"timestamp"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/memcache/memcache.go#L277-L284 | train |
RichardKnop/machinery | v1/backends/memcache/memcache.go | getClient | func (b *Backend) getClient() *gomemcache.Client {
if b.client == nil {
b.client = gomemcache.New(b.servers...)
}
return b.client
} | go | func (b *Backend) getClient() *gomemcache.Client {
if b.client == nil {
b.client = gomemcache.New(b.servers...)
}
return b.client
} | [
"func",
"(",
"b",
"*",
"Backend",
")",
"getClient",
"(",
")",
"*",
"gomemcache",
".",
"Client",
"{",
"if",
"b",
".",
"client",
"==",
"nil",
"{",
"b",
".",
"client",
"=",
"gomemcache",
".",
"New",
"(",
"b",
".",
"servers",
"...",
")",
"\n",
"}",
"\n",
"return",
"b",
".",
"client",
"\n",
"}"
] | // getClient returns or creates instance of Memcache client | [
"getClient",
"returns",
"or",
"creates",
"instance",
"of",
"Memcache",
"client"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/memcache/memcache.go#L287-L292 | train |
RichardKnop/machinery | v1/backends/eager/eager.go | New | func New() iface.Backend {
return &Backend{
Backend: common.NewBackend(new(config.Config)),
groups: make(map[string][]string),
tasks: make(map[string][]byte),
}
} | go | func New() iface.Backend {
return &Backend{
Backend: common.NewBackend(new(config.Config)),
groups: make(map[string][]string),
tasks: make(map[string][]byte),
}
} | [
"func",
"New",
"(",
")",
"iface",
".",
"Backend",
"{",
"return",
"&",
"Backend",
"{",
"Backend",
":",
"common",
".",
"NewBackend",
"(",
"new",
"(",
"config",
".",
"Config",
")",
")",
",",
"groups",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
",",
"tasks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
")",
",",
"}",
"\n",
"}"
] | // New creates EagerBackend instance | [
"New",
"creates",
"EagerBackend",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/backends/eager/eager.go#L54-L60 | train |
RichardKnop/machinery | v1/config/file.go | NewFromYaml | func NewFromYaml(cnfPath string, keepReloading bool) (*Config, error) {
cnf, err := fromFile(cnfPath)
if err != nil {
return nil, err
}
log.INFO.Printf("Successfully loaded config from file %s", cnfPath)
if keepReloading {
// Open a goroutine to watch remote changes forever
go func() {
for {
// Delay after each request
time.Sleep(reloadDelay)
// Attempt to reload the config
newCnf, newErr := fromFile(cnfPath)
if newErr != nil {
log.WARNING.Printf("Failed to reload config from file %s: %v", cnfPath, newErr)
continue
}
*cnf = *newCnf
// log.INFO.Printf("Successfully reloaded config from file %s", cnfPath)
}
}()
}
return cnf, nil
} | go | func NewFromYaml(cnfPath string, keepReloading bool) (*Config, error) {
cnf, err := fromFile(cnfPath)
if err != nil {
return nil, err
}
log.INFO.Printf("Successfully loaded config from file %s", cnfPath)
if keepReloading {
// Open a goroutine to watch remote changes forever
go func() {
for {
// Delay after each request
time.Sleep(reloadDelay)
// Attempt to reload the config
newCnf, newErr := fromFile(cnfPath)
if newErr != nil {
log.WARNING.Printf("Failed to reload config from file %s: %v", cnfPath, newErr)
continue
}
*cnf = *newCnf
// log.INFO.Printf("Successfully reloaded config from file %s", cnfPath)
}
}()
}
return cnf, nil
} | [
"func",
"NewFromYaml",
"(",
"cnfPath",
"string",
",",
"keepReloading",
"bool",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"cnf",
",",
"err",
":=",
"fromFile",
"(",
"cnfPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"log",
".",
"INFO",
".",
"Printf",
"(",
"\"Successfully loaded config from file %s\"",
",",
"cnfPath",
")",
"\n",
"if",
"keepReloading",
"{",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"time",
".",
"Sleep",
"(",
"reloadDelay",
")",
"\n",
"newCnf",
",",
"newErr",
":=",
"fromFile",
"(",
"cnfPath",
")",
"\n",
"if",
"newErr",
"!=",
"nil",
"{",
"log",
".",
"WARNING",
".",
"Printf",
"(",
"\"Failed to reload config from file %s: %v\"",
",",
"cnfPath",
",",
"newErr",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"*",
"cnf",
"=",
"*",
"newCnf",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"return",
"cnf",
",",
"nil",
"\n",
"}"
] | // NewFromYaml creates a config object from YAML file | [
"NewFromYaml",
"creates",
"a",
"config",
"object",
"from",
"YAML",
"file"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/config/file.go#L13-L42 | train |
RichardKnop/machinery | v1/config/file.go | ReadFromFile | func ReadFromFile(cnfPath string) ([]byte, error) {
file, err := os.Open(cnfPath)
// Config file not found
if err != nil {
return nil, fmt.Errorf("Open file error: %s", err)
}
// Config file found, let's try to read it
data := make([]byte, 1000)
count, err := file.Read(data)
if err != nil {
return nil, fmt.Errorf("Read from file error: %s", err)
}
return data[:count], nil
} | go | func ReadFromFile(cnfPath string) ([]byte, error) {
file, err := os.Open(cnfPath)
// Config file not found
if err != nil {
return nil, fmt.Errorf("Open file error: %s", err)
}
// Config file found, let's try to read it
data := make([]byte, 1000)
count, err := file.Read(data)
if err != nil {
return nil, fmt.Errorf("Read from file error: %s", err)
}
return data[:count], nil
} | [
"func",
"ReadFromFile",
"(",
"cnfPath",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"cnfPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Open file error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"data",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1000",
")",
"\n",
"count",
",",
"err",
":=",
"file",
".",
"Read",
"(",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Read from file error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"data",
"[",
":",
"count",
"]",
",",
"nil",
"\n",
"}"
] | // ReadFromFile reads data from a file | [
"ReadFromFile",
"reads",
"data",
"from",
"a",
"file"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/config/file.go#L45-L61 | train |
RichardKnop/machinery | v1/tasks/signature.go | NewSignature | func NewSignature(name string, args []Arg) (*Signature, error) {
signatureID := uuid.New().String()
return &Signature{
UUID: fmt.Sprintf("task_%v", signatureID),
Name: name,
Args: args,
}, nil
} | go | func NewSignature(name string, args []Arg) (*Signature, error) {
signatureID := uuid.New().String()
return &Signature{
UUID: fmt.Sprintf("task_%v", signatureID),
Name: name,
Args: args,
}, nil
} | [
"func",
"NewSignature",
"(",
"name",
"string",
",",
"args",
"[",
"]",
"Arg",
")",
"(",
"*",
"Signature",
",",
"error",
")",
"{",
"signatureID",
":=",
"uuid",
".",
"New",
"(",
")",
".",
"String",
"(",
")",
"\n",
"return",
"&",
"Signature",
"{",
"UUID",
":",
"fmt",
".",
"Sprintf",
"(",
"\"task_%v\"",
",",
"signatureID",
")",
",",
"Name",
":",
"name",
",",
"Args",
":",
"args",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewSignature creates a new task signature | [
"NewSignature",
"creates",
"a",
"new",
"task",
"signature"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/tasks/signature.go#L65-L72 | train |
RichardKnop/machinery | v1/server.go | NewServer | func NewServer(cnf *config.Config) (*Server, error) {
broker, err := BrokerFactory(cnf)
if err != nil {
return nil, err
}
// Backend is optional so we ignore the error
backend, _ := BackendFactory(cnf)
srv := NewServerWithBrokerBackend(cnf, broker, backend)
// init for eager-mode
eager, ok := broker.(eager.Mode)
if ok {
// we don't have to call worker.Launch in eager mode
eager.AssignWorker(srv.NewWorker("eager", 0))
}
return srv, nil
} | go | func NewServer(cnf *config.Config) (*Server, error) {
broker, err := BrokerFactory(cnf)
if err != nil {
return nil, err
}
// Backend is optional so we ignore the error
backend, _ := BackendFactory(cnf)
srv := NewServerWithBrokerBackend(cnf, broker, backend)
// init for eager-mode
eager, ok := broker.(eager.Mode)
if ok {
// we don't have to call worker.Launch in eager mode
eager.AssignWorker(srv.NewWorker("eager", 0))
}
return srv, nil
} | [
"func",
"NewServer",
"(",
"cnf",
"*",
"config",
".",
"Config",
")",
"(",
"*",
"Server",
",",
"error",
")",
"{",
"broker",
",",
"err",
":=",
"BrokerFactory",
"(",
"cnf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"backend",
",",
"_",
":=",
"BackendFactory",
"(",
"cnf",
")",
"\n",
"srv",
":=",
"NewServerWithBrokerBackend",
"(",
"cnf",
",",
"broker",
",",
"backend",
")",
"\n",
"eager",
",",
"ok",
":=",
"broker",
".",
"(",
"eager",
".",
"Mode",
")",
"\n",
"if",
"ok",
"{",
"eager",
".",
"AssignWorker",
"(",
"srv",
".",
"NewWorker",
"(",
"\"eager\"",
",",
"0",
")",
")",
"\n",
"}",
"\n",
"return",
"srv",
",",
"nil",
"\n",
"}"
] | // NewServer creates Server instance | [
"NewServer",
"creates",
"Server",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L42-L61 | train |
RichardKnop/machinery | v1/server.go | NewWorker | func (server *Server) NewWorker(consumerTag string, concurrency int) *Worker {
return &Worker{
server: server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: "",
}
} | go | func (server *Server) NewWorker(consumerTag string, concurrency int) *Worker {
return &Worker{
server: server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: "",
}
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"NewWorker",
"(",
"consumerTag",
"string",
",",
"concurrency",
"int",
")",
"*",
"Worker",
"{",
"return",
"&",
"Worker",
"{",
"server",
":",
"server",
",",
"ConsumerTag",
":",
"consumerTag",
",",
"Concurrency",
":",
"concurrency",
",",
"Queue",
":",
"\"\"",
",",
"}",
"\n",
"}"
] | // NewWorker creates Worker instance | [
"NewWorker",
"creates",
"Worker",
"instance"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L64-L71 | train |
RichardKnop/machinery | v1/server.go | NewCustomQueueWorker | func (server *Server) NewCustomQueueWorker(consumerTag string, concurrency int, queue string) *Worker {
return &Worker{
server: server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: queue,
}
} | go | func (server *Server) NewCustomQueueWorker(consumerTag string, concurrency int, queue string) *Worker {
return &Worker{
server: server,
ConsumerTag: consumerTag,
Concurrency: concurrency,
Queue: queue,
}
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"NewCustomQueueWorker",
"(",
"consumerTag",
"string",
",",
"concurrency",
"int",
",",
"queue",
"string",
")",
"*",
"Worker",
"{",
"return",
"&",
"Worker",
"{",
"server",
":",
"server",
",",
"ConsumerTag",
":",
"consumerTag",
",",
"Concurrency",
":",
"concurrency",
",",
"Queue",
":",
"queue",
",",
"}",
"\n",
"}"
] | // NewCustomQueueWorker creates Worker instance with Custom Queue | [
"NewCustomQueueWorker",
"creates",
"Worker",
"instance",
"with",
"Custom",
"Queue"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L74-L81 | train |
RichardKnop/machinery | v1/server.go | RegisterTasks | func (server *Server) RegisterTasks(namedTaskFuncs map[string]interface{}) error {
for _, task := range namedTaskFuncs {
if err := tasks.ValidateTask(task); err != nil {
return err
}
}
server.registeredTasks = namedTaskFuncs
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | go | func (server *Server) RegisterTasks(namedTaskFuncs map[string]interface{}) error {
for _, task := range namedTaskFuncs {
if err := tasks.ValidateTask(task); err != nil {
return err
}
}
server.registeredTasks = namedTaskFuncs
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"RegisterTasks",
"(",
"namedTaskFuncs",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"for",
"_",
",",
"task",
":=",
"range",
"namedTaskFuncs",
"{",
"if",
"err",
":=",
"tasks",
".",
"ValidateTask",
"(",
"task",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"server",
".",
"registeredTasks",
"=",
"namedTaskFuncs",
"\n",
"server",
".",
"broker",
".",
"SetRegisteredTaskNames",
"(",
"server",
".",
"GetRegisteredTaskNames",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // RegisterTasks registers all tasks at once | [
"RegisterTasks",
"registers",
"all",
"tasks",
"at",
"once"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L119-L128 | train |
RichardKnop/machinery | v1/server.go | RegisterTask | func (server *Server) RegisterTask(name string, taskFunc interface{}) error {
if err := tasks.ValidateTask(taskFunc); err != nil {
return err
}
server.registeredTasks[name] = taskFunc
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | go | func (server *Server) RegisterTask(name string, taskFunc interface{}) error {
if err := tasks.ValidateTask(taskFunc); err != nil {
return err
}
server.registeredTasks[name] = taskFunc
server.broker.SetRegisteredTaskNames(server.GetRegisteredTaskNames())
return nil
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"RegisterTask",
"(",
"name",
"string",
",",
"taskFunc",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"err",
":=",
"tasks",
".",
"ValidateTask",
"(",
"taskFunc",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"server",
".",
"registeredTasks",
"[",
"name",
"]",
"=",
"taskFunc",
"\n",
"server",
".",
"broker",
".",
"SetRegisteredTaskNames",
"(",
"server",
".",
"GetRegisteredTaskNames",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // RegisterTask registers a single task | [
"RegisterTask",
"registers",
"a",
"single",
"task"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L131-L138 | train |
RichardKnop/machinery | v1/server.go | IsTaskRegistered | func (server *Server) IsTaskRegistered(name string) bool {
_, ok := server.registeredTasks[name]
return ok
} | go | func (server *Server) IsTaskRegistered(name string) bool {
_, ok := server.registeredTasks[name]
return ok
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"IsTaskRegistered",
"(",
"name",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"server",
".",
"registeredTasks",
"[",
"name",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsTaskRegistered returns true if the task name is registered with this broker | [
"IsTaskRegistered",
"returns",
"true",
"if",
"the",
"task",
"name",
"is",
"registered",
"with",
"this",
"broker"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L141-L144 | train |
RichardKnop/machinery | v1/server.go | GetRegisteredTask | func (server *Server) GetRegisteredTask(name string) (interface{}, error) {
taskFunc, ok := server.registeredTasks[name]
if !ok {
return nil, fmt.Errorf("Task not registered error: %s", name)
}
return taskFunc, nil
} | go | func (server *Server) GetRegisteredTask(name string) (interface{}, error) {
taskFunc, ok := server.registeredTasks[name]
if !ok {
return nil, fmt.Errorf("Task not registered error: %s", name)
}
return taskFunc, nil
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"GetRegisteredTask",
"(",
"name",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"taskFunc",
",",
"ok",
":=",
"server",
".",
"registeredTasks",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Task not registered error: %s\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"taskFunc",
",",
"nil",
"\n",
"}"
] | // GetRegisteredTask returns registered task by name | [
"GetRegisteredTask",
"returns",
"registered",
"task",
"by",
"name"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L147-L153 | train |
RichardKnop/machinery | v1/server.go | SendTaskWithContext | func (server *Server) SendTaskWithContext(ctx context.Context, signature *tasks.Signature) (*result.AsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendTask", tracing.ProducerOption(), tracing.MachineryTag)
defer span.Finish()
// tag the span with some info about the signature
signature.Headers = tracing.HeadersWithSpan(signature.Headers, span)
// Make sure result backend is defined
if server.backend == nil {
return nil, errors.New("Result backend required")
}
// Auto generate a UUID if not set already
if signature.UUID == "" {
taskID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", taskID)
}
// Set initial task state to PENDING
if err := server.backend.SetStatePending(signature); err != nil {
return nil, fmt.Errorf("Set state pending error: %s", err)
}
if server.prePublishHandler != nil {
server.prePublishHandler(signature)
}
if err := server.broker.Publish(ctx, signature); err != nil {
return nil, fmt.Errorf("Publish message error: %s", err)
}
return result.NewAsyncResult(signature, server.backend), nil
} | go | func (server *Server) SendTaskWithContext(ctx context.Context, signature *tasks.Signature) (*result.AsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendTask", tracing.ProducerOption(), tracing.MachineryTag)
defer span.Finish()
// tag the span with some info about the signature
signature.Headers = tracing.HeadersWithSpan(signature.Headers, span)
// Make sure result backend is defined
if server.backend == nil {
return nil, errors.New("Result backend required")
}
// Auto generate a UUID if not set already
if signature.UUID == "" {
taskID := uuid.New().String()
signature.UUID = fmt.Sprintf("task_%v", taskID)
}
// Set initial task state to PENDING
if err := server.backend.SetStatePending(signature); err != nil {
return nil, fmt.Errorf("Set state pending error: %s", err)
}
if server.prePublishHandler != nil {
server.prePublishHandler(signature)
}
if err := server.broker.Publish(ctx, signature); err != nil {
return nil, fmt.Errorf("Publish message error: %s", err)
}
return result.NewAsyncResult(signature, server.backend), nil
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"SendTaskWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"signature",
"*",
"tasks",
".",
"Signature",
")",
"(",
"*",
"result",
".",
"AsyncResult",
",",
"error",
")",
"{",
"span",
",",
"_",
":=",
"opentracing",
".",
"StartSpanFromContext",
"(",
"ctx",
",",
"\"SendTask\"",
",",
"tracing",
".",
"ProducerOption",
"(",
")",
",",
"tracing",
".",
"MachineryTag",
")",
"\n",
"defer",
"span",
".",
"Finish",
"(",
")",
"\n",
"signature",
".",
"Headers",
"=",
"tracing",
".",
"HeadersWithSpan",
"(",
"signature",
".",
"Headers",
",",
"span",
")",
"\n",
"if",
"server",
".",
"backend",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"Result backend required\"",
")",
"\n",
"}",
"\n",
"if",
"signature",
".",
"UUID",
"==",
"\"\"",
"{",
"taskID",
":=",
"uuid",
".",
"New",
"(",
")",
".",
"String",
"(",
")",
"\n",
"signature",
".",
"UUID",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"task_%v\"",
",",
"taskID",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"server",
".",
"backend",
".",
"SetStatePending",
"(",
"signature",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Set state pending error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"server",
".",
"prePublishHandler",
"!=",
"nil",
"{",
"server",
".",
"prePublishHandler",
"(",
"signature",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"server",
".",
"broker",
".",
"Publish",
"(",
"ctx",
",",
"signature",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Publish message error: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"result",
".",
"NewAsyncResult",
"(",
"signature",
",",
"server",
".",
"backend",
")",
",",
"nil",
"\n",
"}"
] | // SendTaskWithContext will inject the trace context in the signature headers before publishing it | [
"SendTaskWithContext",
"will",
"inject",
"the",
"trace",
"context",
"in",
"the",
"signature",
"headers",
"before",
"publishing",
"it"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L156-L188 | train |
RichardKnop/machinery | v1/server.go | SendTask | func (server *Server) SendTask(signature *tasks.Signature) (*result.AsyncResult, error) {
return server.SendTaskWithContext(context.Background(), signature)
} | go | func (server *Server) SendTask(signature *tasks.Signature) (*result.AsyncResult, error) {
return server.SendTaskWithContext(context.Background(), signature)
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"SendTask",
"(",
"signature",
"*",
"tasks",
".",
"Signature",
")",
"(",
"*",
"result",
".",
"AsyncResult",
",",
"error",
")",
"{",
"return",
"server",
".",
"SendTaskWithContext",
"(",
"context",
".",
"Background",
"(",
")",
",",
"signature",
")",
"\n",
"}"
] | // SendTask publishes a task to the default queue | [
"SendTask",
"publishes",
"a",
"task",
"to",
"the",
"default",
"queue"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L191-L193 | train |
RichardKnop/machinery | v1/server.go | SendChainWithContext | func (server *Server) SendChainWithContext(ctx context.Context, chain *tasks.Chain) (*result.ChainAsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendChain", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowChainTag)
defer span.Finish()
tracing.AnnotateSpanWithChainInfo(span, chain)
return server.SendChain(chain)
} | go | func (server *Server) SendChainWithContext(ctx context.Context, chain *tasks.Chain) (*result.ChainAsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendChain", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowChainTag)
defer span.Finish()
tracing.AnnotateSpanWithChainInfo(span, chain)
return server.SendChain(chain)
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"SendChainWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"chain",
"*",
"tasks",
".",
"Chain",
")",
"(",
"*",
"result",
".",
"ChainAsyncResult",
",",
"error",
")",
"{",
"span",
",",
"_",
":=",
"opentracing",
".",
"StartSpanFromContext",
"(",
"ctx",
",",
"\"SendChain\"",
",",
"tracing",
".",
"ProducerOption",
"(",
")",
",",
"tracing",
".",
"MachineryTag",
",",
"tracing",
".",
"WorkflowChainTag",
")",
"\n",
"defer",
"span",
".",
"Finish",
"(",
")",
"\n",
"tracing",
".",
"AnnotateSpanWithChainInfo",
"(",
"span",
",",
"chain",
")",
"\n",
"return",
"server",
".",
"SendChain",
"(",
"chain",
")",
"\n",
"}"
] | // SendChainWithContext will inject the trace context in all the signature headers before publishing it | [
"SendChainWithContext",
"will",
"inject",
"the",
"trace",
"context",
"in",
"all",
"the",
"signature",
"headers",
"before",
"publishing",
"it"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L196-L203 | train |
RichardKnop/machinery | v1/server.go | SendChain | func (server *Server) SendChain(chain *tasks.Chain) (*result.ChainAsyncResult, error) {
_, err := server.SendTask(chain.Tasks[0])
if err != nil {
return nil, err
}
return result.NewChainAsyncResult(chain.Tasks, server.backend), nil
} | go | func (server *Server) SendChain(chain *tasks.Chain) (*result.ChainAsyncResult, error) {
_, err := server.SendTask(chain.Tasks[0])
if err != nil {
return nil, err
}
return result.NewChainAsyncResult(chain.Tasks, server.backend), nil
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"SendChain",
"(",
"chain",
"*",
"tasks",
".",
"Chain",
")",
"(",
"*",
"result",
".",
"ChainAsyncResult",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"server",
".",
"SendTask",
"(",
"chain",
".",
"Tasks",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"result",
".",
"NewChainAsyncResult",
"(",
"chain",
".",
"Tasks",
",",
"server",
".",
"backend",
")",
",",
"nil",
"\n",
"}"
] | // SendChain triggers a chain of tasks | [
"SendChain",
"triggers",
"a",
"chain",
"of",
"tasks"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L206-L213 | train |
RichardKnop/machinery | v1/server.go | SendGroupWithContext | func (server *Server) SendGroupWithContext(ctx context.Context, group *tasks.Group, sendConcurrency int) ([]*result.AsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendGroup", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowGroupTag)
defer span.Finish()
tracing.AnnotateSpanWithGroupInfo(span, group, sendConcurrency)
// Make sure result backend is defined
if server.backend == nil {
return nil, errors.New("Result backend required")
}
asyncResults := make([]*result.AsyncResult, len(group.Tasks))
var wg sync.WaitGroup
wg.Add(len(group.Tasks))
errorsChan := make(chan error, len(group.Tasks)*2)
// Init group
server.backend.InitGroup(group.GroupUUID, group.GetUUIDs())
// Init the tasks Pending state first
for _, signature := range group.Tasks {
if err := server.backend.SetStatePending(signature); err != nil {
errorsChan <- err
continue
}
}
pool := make(chan struct{}, sendConcurrency)
go func() {
for i := 0; i < sendConcurrency; i++ {
pool <- struct{}{}
}
}()
for i, signature := range group.Tasks {
if sendConcurrency > 0 {
<-pool
}
go func(s *tasks.Signature, index int) {
defer wg.Done()
// Publish task
err := server.broker.Publish(ctx, s)
if sendConcurrency > 0 {
pool <- struct{}{}
}
if err != nil {
errorsChan <- fmt.Errorf("Publish message error: %s", err)
return
}
asyncResults[index] = result.NewAsyncResult(s, server.backend)
}(signature, i)
}
done := make(chan int)
go func() {
wg.Wait()
done <- 1
}()
select {
case err := <-errorsChan:
return asyncResults, err
case <-done:
return asyncResults, nil
}
} | go | func (server *Server) SendGroupWithContext(ctx context.Context, group *tasks.Group, sendConcurrency int) ([]*result.AsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendGroup", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowGroupTag)
defer span.Finish()
tracing.AnnotateSpanWithGroupInfo(span, group, sendConcurrency)
// Make sure result backend is defined
if server.backend == nil {
return nil, errors.New("Result backend required")
}
asyncResults := make([]*result.AsyncResult, len(group.Tasks))
var wg sync.WaitGroup
wg.Add(len(group.Tasks))
errorsChan := make(chan error, len(group.Tasks)*2)
// Init group
server.backend.InitGroup(group.GroupUUID, group.GetUUIDs())
// Init the tasks Pending state first
for _, signature := range group.Tasks {
if err := server.backend.SetStatePending(signature); err != nil {
errorsChan <- err
continue
}
}
pool := make(chan struct{}, sendConcurrency)
go func() {
for i := 0; i < sendConcurrency; i++ {
pool <- struct{}{}
}
}()
for i, signature := range group.Tasks {
if sendConcurrency > 0 {
<-pool
}
go func(s *tasks.Signature, index int) {
defer wg.Done()
// Publish task
err := server.broker.Publish(ctx, s)
if sendConcurrency > 0 {
pool <- struct{}{}
}
if err != nil {
errorsChan <- fmt.Errorf("Publish message error: %s", err)
return
}
asyncResults[index] = result.NewAsyncResult(s, server.backend)
}(signature, i)
}
done := make(chan int)
go func() {
wg.Wait()
done <- 1
}()
select {
case err := <-errorsChan:
return asyncResults, err
case <-done:
return asyncResults, nil
}
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"SendGroupWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"group",
"*",
"tasks",
".",
"Group",
",",
"sendConcurrency",
"int",
")",
"(",
"[",
"]",
"*",
"result",
".",
"AsyncResult",
",",
"error",
")",
"{",
"span",
",",
"_",
":=",
"opentracing",
".",
"StartSpanFromContext",
"(",
"ctx",
",",
"\"SendGroup\"",
",",
"tracing",
".",
"ProducerOption",
"(",
")",
",",
"tracing",
".",
"MachineryTag",
",",
"tracing",
".",
"WorkflowGroupTag",
")",
"\n",
"defer",
"span",
".",
"Finish",
"(",
")",
"\n",
"tracing",
".",
"AnnotateSpanWithGroupInfo",
"(",
"span",
",",
"group",
",",
"sendConcurrency",
")",
"\n",
"if",
"server",
".",
"backend",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"Result backend required\"",
")",
"\n",
"}",
"\n",
"asyncResults",
":=",
"make",
"(",
"[",
"]",
"*",
"result",
".",
"AsyncResult",
",",
"len",
"(",
"group",
".",
"Tasks",
")",
")",
"\n",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"wg",
".",
"Add",
"(",
"len",
"(",
"group",
".",
"Tasks",
")",
")",
"\n",
"errorsChan",
":=",
"make",
"(",
"chan",
"error",
",",
"len",
"(",
"group",
".",
"Tasks",
")",
"*",
"2",
")",
"\n",
"server",
".",
"backend",
".",
"InitGroup",
"(",
"group",
".",
"GroupUUID",
",",
"group",
".",
"GetUUIDs",
"(",
")",
")",
"\n",
"for",
"_",
",",
"signature",
":=",
"range",
"group",
".",
"Tasks",
"{",
"if",
"err",
":=",
"server",
".",
"backend",
".",
"SetStatePending",
"(",
"signature",
")",
";",
"err",
"!=",
"nil",
"{",
"errorsChan",
"<-",
"err",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"pool",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"sendConcurrency",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"sendConcurrency",
";",
"i",
"++",
"{",
"pool",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"for",
"i",
",",
"signature",
":=",
"range",
"group",
".",
"Tasks",
"{",
"if",
"sendConcurrency",
">",
"0",
"{",
"<-",
"pool",
"\n",
"}",
"\n",
"go",
"func",
"(",
"s",
"*",
"tasks",
".",
"Signature",
",",
"index",
"int",
")",
"{",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n",
"err",
":=",
"server",
".",
"broker",
".",
"Publish",
"(",
"ctx",
",",
"s",
")",
"\n",
"if",
"sendConcurrency",
">",
"0",
"{",
"pool",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errorsChan",
"<-",
"fmt",
".",
"Errorf",
"(",
"\"Publish message error: %s\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"asyncResults",
"[",
"index",
"]",
"=",
"result",
".",
"NewAsyncResult",
"(",
"s",
",",
"server",
".",
"backend",
")",
"\n",
"}",
"(",
"signature",
",",
"i",
")",
"\n",
"}",
"\n",
"done",
":=",
"make",
"(",
"chan",
"int",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"wg",
".",
"Wait",
"(",
")",
"\n",
"done",
"<-",
"1",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"errorsChan",
":",
"return",
"asyncResults",
",",
"err",
"\n",
"case",
"<-",
"done",
":",
"return",
"asyncResults",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // SendGroupWithContext will inject the trace context in all the signature headers before publishing it | [
"SendGroupWithContext",
"will",
"inject",
"the",
"trace",
"context",
"in",
"all",
"the",
"signature",
"headers",
"before",
"publishing",
"it"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L216-L289 | train |
RichardKnop/machinery | v1/server.go | SendGroup | func (server *Server) SendGroup(group *tasks.Group, sendConcurrency int) ([]*result.AsyncResult, error) {
return server.SendGroupWithContext(context.Background(), group, sendConcurrency)
} | go | func (server *Server) SendGroup(group *tasks.Group, sendConcurrency int) ([]*result.AsyncResult, error) {
return server.SendGroupWithContext(context.Background(), group, sendConcurrency)
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"SendGroup",
"(",
"group",
"*",
"tasks",
".",
"Group",
",",
"sendConcurrency",
"int",
")",
"(",
"[",
"]",
"*",
"result",
".",
"AsyncResult",
",",
"error",
")",
"{",
"return",
"server",
".",
"SendGroupWithContext",
"(",
"context",
".",
"Background",
"(",
")",
",",
"group",
",",
"sendConcurrency",
")",
"\n",
"}"
] | // SendGroup triggers a group of parallel tasks | [
"SendGroup",
"triggers",
"a",
"group",
"of",
"parallel",
"tasks"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L292-L294 | train |
RichardKnop/machinery | v1/server.go | SendChordWithContext | func (server *Server) SendChordWithContext(ctx context.Context, chord *tasks.Chord, sendConcurrency int) (*result.ChordAsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendChord", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowChordTag)
defer span.Finish()
tracing.AnnotateSpanWithChordInfo(span, chord, sendConcurrency)
_, err := server.SendGroupWithContext(ctx, chord.Group, sendConcurrency)
if err != nil {
return nil, err
}
return result.NewChordAsyncResult(
chord.Group.Tasks,
chord.Callback,
server.backend,
), nil
} | go | func (server *Server) SendChordWithContext(ctx context.Context, chord *tasks.Chord, sendConcurrency int) (*result.ChordAsyncResult, error) {
span, _ := opentracing.StartSpanFromContext(ctx, "SendChord", tracing.ProducerOption(), tracing.MachineryTag, tracing.WorkflowChordTag)
defer span.Finish()
tracing.AnnotateSpanWithChordInfo(span, chord, sendConcurrency)
_, err := server.SendGroupWithContext(ctx, chord.Group, sendConcurrency)
if err != nil {
return nil, err
}
return result.NewChordAsyncResult(
chord.Group.Tasks,
chord.Callback,
server.backend,
), nil
} | [
"func",
"(",
"server",
"*",
"Server",
")",
"SendChordWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"chord",
"*",
"tasks",
".",
"Chord",
",",
"sendConcurrency",
"int",
")",
"(",
"*",
"result",
".",
"ChordAsyncResult",
",",
"error",
")",
"{",
"span",
",",
"_",
":=",
"opentracing",
".",
"StartSpanFromContext",
"(",
"ctx",
",",
"\"SendChord\"",
",",
"tracing",
".",
"ProducerOption",
"(",
")",
",",
"tracing",
".",
"MachineryTag",
",",
"tracing",
".",
"WorkflowChordTag",
")",
"\n",
"defer",
"span",
".",
"Finish",
"(",
")",
"\n",
"tracing",
".",
"AnnotateSpanWithChordInfo",
"(",
"span",
",",
"chord",
",",
"sendConcurrency",
")",
"\n",
"_",
",",
"err",
":=",
"server",
".",
"SendGroupWithContext",
"(",
"ctx",
",",
"chord",
".",
"Group",
",",
"sendConcurrency",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"result",
".",
"NewChordAsyncResult",
"(",
"chord",
".",
"Group",
".",
"Tasks",
",",
"chord",
".",
"Callback",
",",
"server",
".",
"backend",
",",
")",
",",
"nil",
"\n",
"}"
] | // SendChordWithContext will inject the trace context in all the signature headers before publishing it | [
"SendChordWithContext",
"will",
"inject",
"the",
"trace",
"context",
"in",
"all",
"the",
"signature",
"headers",
"before",
"publishing",
"it"
] | 07418869e268a380aea5b9aefbb0b9f5bb715a12 | https://github.com/RichardKnop/machinery/blob/07418869e268a380aea5b9aefbb0b9f5bb715a12/v1/server.go#L297-L313 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.