id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
15,800 | choria-io/go-choria | aagent/machine/notifications.go | NotifyWatcherState | func (m *Machine) NotifyWatcherState(watcher string, state interface{}) {
notification, ok := state.(WatcherStateNotification)
if !ok {
m.Errorf(watcher, "Could not notify watcher state: state does not implement WatcherStateNotification: %#v", state)
}
for _, n := range m.notifiers {
err := n.NotifyWatcherState(watcher, notification)
if err != nil {
m.Errorf(watcher, "Could not notify watcher state: %s", err)
}
}
} | go | func (m *Machine) NotifyWatcherState(watcher string, state interface{}) {
notification, ok := state.(WatcherStateNotification)
if !ok {
m.Errorf(watcher, "Could not notify watcher state: state does not implement WatcherStateNotification: %#v", state)
}
for _, n := range m.notifiers {
err := n.NotifyWatcherState(watcher, notification)
if err != nil {
m.Errorf(watcher, "Could not notify watcher state: %s", err)
}
}
} | [
"func",
"(",
"m",
"*",
"Machine",
")",
"NotifyWatcherState",
"(",
"watcher",
"string",
",",
"state",
"interface",
"{",
"}",
")",
"{",
"notification",
",",
"ok",
":=",
"state",
".",
"(",
"WatcherStateNotification",
")",
"\n",
"if",
"!",
"ok",
"{",
"m",
".",
"Errorf",
"(",
"watcher",
",",
"\"",
"\"",
",",
"state",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"n",
":=",
"range",
"m",
".",
"notifiers",
"{",
"err",
":=",
"n",
".",
"NotifyWatcherState",
"(",
"watcher",
",",
"notification",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"m",
".",
"Errorf",
"(",
"watcher",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // NotifyWatcherState implements NotificationService | [
"NotifyWatcherState",
"implements",
"NotificationService"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/machine/notifications.go#L95-L107 |
15,801 | choria-io/go-choria | server/discovery/agents/agents.go | Match | func Match(needles []string, knownAgents []string) bool {
matched := 0
failed := 0
for _, needle := range needles {
if strings.HasPrefix(needle, "/") && strings.HasSuffix(needle, "/") {
needle = strings.TrimPrefix(needle, "/")
needle = strings.TrimSuffix(needle, "/")
if hasAgentMatching(needle, knownAgents) {
matched++
} else {
failed++
}
continue
}
if hasAgent(needle, knownAgents) {
matched++
} else {
failed++
}
}
return failed == 0 && matched > 0
} | go | func Match(needles []string, knownAgents []string) bool {
matched := 0
failed := 0
for _, needle := range needles {
if strings.HasPrefix(needle, "/") && strings.HasSuffix(needle, "/") {
needle = strings.TrimPrefix(needle, "/")
needle = strings.TrimSuffix(needle, "/")
if hasAgentMatching(needle, knownAgents) {
matched++
} else {
failed++
}
continue
}
if hasAgent(needle, knownAgents) {
matched++
} else {
failed++
}
}
return failed == 0 && matched > 0
} | [
"func",
"Match",
"(",
"needles",
"[",
"]",
"string",
",",
"knownAgents",
"[",
"]",
"string",
")",
"bool",
"{",
"matched",
":=",
"0",
"\n",
"failed",
":=",
"0",
"\n\n",
"for",
"_",
",",
"needle",
":=",
"range",
"needles",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"needle",
",",
"\"",
"\"",
")",
"&&",
"strings",
".",
"HasSuffix",
"(",
"needle",
",",
"\"",
"\"",
")",
"{",
"needle",
"=",
"strings",
".",
"TrimPrefix",
"(",
"needle",
",",
"\"",
"\"",
")",
"\n",
"needle",
"=",
"strings",
".",
"TrimSuffix",
"(",
"needle",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"hasAgentMatching",
"(",
"needle",
",",
"knownAgents",
")",
"{",
"matched",
"++",
"\n",
"}",
"else",
"{",
"failed",
"++",
"\n",
"}",
"\n\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"hasAgent",
"(",
"needle",
",",
"knownAgents",
")",
"{",
"matched",
"++",
"\n",
"}",
"else",
"{",
"failed",
"++",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"failed",
"==",
"0",
"&&",
"matched",
">",
"0",
"\n",
"}"
] | // Match agents on a AND basis | [
"Match",
"agents",
"on",
"a",
"AND",
"basis"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/discovery/agents/agents.go#L9-L35 |
15,802 | choria-io/go-choria | server/agents/agents.go | New | func New(requests chan *choria.ConnectorMessage, fw *choria.Framework, conn choria.ConnectorInfo, srv ServerInfoSource, log *logrus.Entry) *Manager {
return &Manager{
agents: make(map[string]Agent),
subs: make(map[string][]string),
fw: fw,
log: log.WithFields(logrus.Fields{"subsystem": "agents"}),
mu: &sync.Mutex{},
requests: requests,
conn: conn,
serverInfo: srv,
}
} | go | func New(requests chan *choria.ConnectorMessage, fw *choria.Framework, conn choria.ConnectorInfo, srv ServerInfoSource, log *logrus.Entry) *Manager {
return &Manager{
agents: make(map[string]Agent),
subs: make(map[string][]string),
fw: fw,
log: log.WithFields(logrus.Fields{"subsystem": "agents"}),
mu: &sync.Mutex{},
requests: requests,
conn: conn,
serverInfo: srv,
}
} | [
"func",
"New",
"(",
"requests",
"chan",
"*",
"choria",
".",
"ConnectorMessage",
",",
"fw",
"*",
"choria",
".",
"Framework",
",",
"conn",
"choria",
".",
"ConnectorInfo",
",",
"srv",
"ServerInfoSource",
",",
"log",
"*",
"logrus",
".",
"Entry",
")",
"*",
"Manager",
"{",
"return",
"&",
"Manager",
"{",
"agents",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"Agent",
")",
",",
"subs",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
",",
"fw",
":",
"fw",
",",
"log",
":",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
")",
",",
"mu",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"requests",
":",
"requests",
",",
"conn",
":",
"conn",
",",
"serverInfo",
":",
"srv",
",",
"}",
"\n",
"}"
] | // New creates a new Agent Manager | [
"New",
"creates",
"a",
"new",
"Agent",
"Manager"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agents/agents.go#L79-L90 |
15,803 | choria-io/go-choria | server/agents/agents.go | DenyAgent | func (a *Manager) DenyAgent(agent string) {
a.denylist = append(a.denylist, agent)
} | go | func (a *Manager) DenyAgent(agent string) {
a.denylist = append(a.denylist, agent)
} | [
"func",
"(",
"a",
"*",
"Manager",
")",
"DenyAgent",
"(",
"agent",
"string",
")",
"{",
"a",
".",
"denylist",
"=",
"append",
"(",
"a",
".",
"denylist",
",",
"agent",
")",
"\n",
"}"
] | // DenyAgent adds an agent to the list of agent names not allowed to start | [
"DenyAgent",
"adds",
"an",
"agent",
"to",
"the",
"list",
"of",
"agent",
"names",
"not",
"allowed",
"to",
"start"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agents/agents.go#L93-L95 |
15,804 | choria-io/go-choria | server/agents/agents.go | RegisterAgent | func (a *Manager) RegisterAgent(ctx context.Context, name string, agent Agent, conn choria.AgentConnector) error {
a.mu.Lock()
defer a.mu.Unlock()
if a.agentDenied(name) {
a.log.Infof("Denying agent %s based on agent deny list", name)
return nil
}
a.log.Infof("Registering new agent %s of type %s", name, agent.Metadata().Name)
agent.SetServerInfo(a.serverInfo)
if _, found := a.agents[name]; found {
return fmt.Errorf("Agent %s is already registered", name)
}
err := a.subscribeAgent(ctx, name, agent, conn)
if err != nil {
return fmt.Errorf("Could not register agent %s: %s", name, err)
}
a.agents[name] = agent
return nil
} | go | func (a *Manager) RegisterAgent(ctx context.Context, name string, agent Agent, conn choria.AgentConnector) error {
a.mu.Lock()
defer a.mu.Unlock()
if a.agentDenied(name) {
a.log.Infof("Denying agent %s based on agent deny list", name)
return nil
}
a.log.Infof("Registering new agent %s of type %s", name, agent.Metadata().Name)
agent.SetServerInfo(a.serverInfo)
if _, found := a.agents[name]; found {
return fmt.Errorf("Agent %s is already registered", name)
}
err := a.subscribeAgent(ctx, name, agent, conn)
if err != nil {
return fmt.Errorf("Could not register agent %s: %s", name, err)
}
a.agents[name] = agent
return nil
} | [
"func",
"(",
"a",
"*",
"Manager",
")",
"RegisterAgent",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"agent",
"Agent",
",",
"conn",
"choria",
".",
"AgentConnector",
")",
"error",
"{",
"a",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"a",
".",
"agentDenied",
"(",
"name",
")",
"{",
"a",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"a",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
",",
"agent",
".",
"Metadata",
"(",
")",
".",
"Name",
")",
"\n\n",
"agent",
".",
"SetServerInfo",
"(",
"a",
".",
"serverInfo",
")",
"\n\n",
"if",
"_",
",",
"found",
":=",
"a",
".",
"agents",
"[",
"name",
"]",
";",
"found",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"a",
".",
"subscribeAgent",
"(",
"ctx",
",",
"name",
",",
"agent",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"a",
".",
"agents",
"[",
"name",
"]",
"=",
"agent",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // RegisterAgent connects a new agent to the server instance, subscribe to all its targets etc | [
"RegisterAgent",
"connects",
"a",
"new",
"agent",
"to",
"the",
"server",
"instance",
"subscribe",
"to",
"all",
"its",
"targets",
"etc"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agents/agents.go#L98-L123 |
15,805 | choria-io/go-choria | server/agents/agents.go | KnownAgents | func (a *Manager) KnownAgents() []string {
a.mu.Lock()
defer a.mu.Unlock()
known := make([]string, 0, len(a.agents))
for agent := range a.agents {
known = append(known, agent)
}
sort.Strings(known)
return known
} | go | func (a *Manager) KnownAgents() []string {
a.mu.Lock()
defer a.mu.Unlock()
known := make([]string, 0, len(a.agents))
for agent := range a.agents {
known = append(known, agent)
}
sort.Strings(known)
return known
} | [
"func",
"(",
"a",
"*",
"Manager",
")",
"KnownAgents",
"(",
")",
"[",
"]",
"string",
"{",
"a",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"known",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"a",
".",
"agents",
")",
")",
"\n\n",
"for",
"agent",
":=",
"range",
"a",
".",
"agents",
"{",
"known",
"=",
"append",
"(",
"known",
",",
"agent",
")",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"known",
")",
"\n\n",
"return",
"known",
"\n",
"}"
] | // KnownAgents retrieves a list of known agents | [
"KnownAgents",
"retrieves",
"a",
"list",
"of",
"known",
"agents"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agents/agents.go#L126-L139 |
15,806 | choria-io/go-choria | server/agents/agents.go | subscribeAgent | func (a *Manager) subscribeAgent(ctx context.Context, name string, agent Agent, conn choria.AgentConnector) error {
if _, found := a.subs[name]; found {
return fmt.Errorf("Could not subscribe agent %s, it's already subscribed", name)
}
a.subs[name] = []string{}
for _, collective := range a.fw.Config.Collectives {
target := conn.AgentBroadcastTarget(collective, name)
subname := fmt.Sprintf("%s.%s", collective, name)
a.log.Infof("Subscribing agent %s to %s", name, target)
err := conn.QueueSubscribe(ctx, subname, target, "", a.requests)
if err != nil {
a.log.Errorf("Could not subscribe agent %s to %s, rewinding all subscriptions for this agent", name, target)
for _, sub := range a.subs[name] {
conn.Unsubscribe(sub)
}
return fmt.Errorf("Subscription failed: %s", err)
}
a.subs[name] = append(a.subs[name], subname)
}
return nil
} | go | func (a *Manager) subscribeAgent(ctx context.Context, name string, agent Agent, conn choria.AgentConnector) error {
if _, found := a.subs[name]; found {
return fmt.Errorf("Could not subscribe agent %s, it's already subscribed", name)
}
a.subs[name] = []string{}
for _, collective := range a.fw.Config.Collectives {
target := conn.AgentBroadcastTarget(collective, name)
subname := fmt.Sprintf("%s.%s", collective, name)
a.log.Infof("Subscribing agent %s to %s", name, target)
err := conn.QueueSubscribe(ctx, subname, target, "", a.requests)
if err != nil {
a.log.Errorf("Could not subscribe agent %s to %s, rewinding all subscriptions for this agent", name, target)
for _, sub := range a.subs[name] {
conn.Unsubscribe(sub)
}
return fmt.Errorf("Subscription failed: %s", err)
}
a.subs[name] = append(a.subs[name], subname)
}
return nil
} | [
"func",
"(",
"a",
"*",
"Manager",
")",
"subscribeAgent",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"agent",
"Agent",
",",
"conn",
"choria",
".",
"AgentConnector",
")",
"error",
"{",
"if",
"_",
",",
"found",
":=",
"a",
".",
"subs",
"[",
"name",
"]",
";",
"found",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n\n",
"a",
".",
"subs",
"[",
"name",
"]",
"=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"for",
"_",
",",
"collective",
":=",
"range",
"a",
".",
"fw",
".",
"Config",
".",
"Collectives",
"{",
"target",
":=",
"conn",
".",
"AgentBroadcastTarget",
"(",
"collective",
",",
"name",
")",
"\n",
"subname",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"collective",
",",
"name",
")",
"\n\n",
"a",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"name",
",",
"target",
")",
"\n",
"err",
":=",
"conn",
".",
"QueueSubscribe",
"(",
"ctx",
",",
"subname",
",",
"target",
",",
"\"",
"\"",
",",
"a",
".",
"requests",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"target",
")",
"\n",
"for",
"_",
",",
"sub",
":=",
"range",
"a",
".",
"subs",
"[",
"name",
"]",
"{",
"conn",
".",
"Unsubscribe",
"(",
"sub",
")",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"a",
".",
"subs",
"[",
"name",
"]",
"=",
"append",
"(",
"a",
".",
"subs",
"[",
"name",
"]",
",",
"subname",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Subscribes an agent to all its targets on the connector. Should any subscription fail
// all the preceding subscriptions for this agents is unsubscribed and an error returned.
// Errors during the unsub is just ignored because it's quite possible that they would fail
// too but this avoids problems of messages arriving we did not expect.
//
// In practise though this is something done during bootstrap and failure here should exit
// the whole instance, so it's probably not needed | [
"Subscribes",
"an",
"agent",
"to",
"all",
"its",
"targets",
"on",
"the",
"connector",
".",
"Should",
"any",
"subscription",
"fail",
"all",
"the",
"preceding",
"subscriptions",
"for",
"this",
"agents",
"is",
"unsubscribed",
"and",
"an",
"error",
"returned",
".",
"Errors",
"during",
"the",
"unsub",
"is",
"just",
"ignored",
"because",
"it",
"s",
"quite",
"possible",
"that",
"they",
"would",
"fail",
"too",
"but",
"this",
"avoids",
"problems",
"of",
"messages",
"arriving",
"we",
"did",
"not",
"expect",
".",
"In",
"practise",
"though",
"this",
"is",
"something",
"done",
"during",
"bootstrap",
"and",
"failure",
"here",
"should",
"exit",
"the",
"whole",
"instance",
"so",
"it",
"s",
"probably",
"not",
"needed"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agents/agents.go#L158-L184 |
15,807 | choria-io/go-choria | cmd/ping.go | sparkline | func (p *pingCommand) sparkline() string {
ticks := []string{"▁", "▂", "▃", "▄", "▅", "▆", "▇"}
sort.Float64s(p.times)
latest := p.times[len(p.times)-1]
bcount := int(latest/50) + 1
buckets := make([]int, bcount)
for _, t := range p.times {
b := int(t / 50.0)
buckets[b]++
}
max := 0
for _, cnt := range buckets {
if max < cnt {
max = cnt
}
}
chars := make([]string, len(buckets))
distance := float64(max) / float64(len(ticks)-1)
for i, cnt := range buckets {
tick := int(math.Round(float64(cnt) / distance))
if tick < 0 {
tick = 0
}
chars[i] = ticks[tick]
}
return strings.Join(chars, "")
} | go | func (p *pingCommand) sparkline() string {
ticks := []string{"▁", "▂", "▃", "▄", "▅", "▆", "▇"}
sort.Float64s(p.times)
latest := p.times[len(p.times)-1]
bcount := int(latest/50) + 1
buckets := make([]int, bcount)
for _, t := range p.times {
b := int(t / 50.0)
buckets[b]++
}
max := 0
for _, cnt := range buckets {
if max < cnt {
max = cnt
}
}
chars := make([]string, len(buckets))
distance := float64(max) / float64(len(ticks)-1)
for i, cnt := range buckets {
tick := int(math.Round(float64(cnt) / distance))
if tick < 0 {
tick = 0
}
chars[i] = ticks[tick]
}
return strings.Join(chars, "")
} | [
"func",
"(",
"p",
"*",
"pingCommand",
")",
"sparkline",
"(",
")",
"string",
"{",
"ticks",
":=",
"[",
"]",
"string",
"{",
"\"",
" ",
"\"",
"\"",
"▃",
"\"",
" ",
",",
" ",
"▅",
"\"",
"▆",
",",
"\"",
"}",
"",
"",
"",
"",
"",
"",
"\n\n",
"sort",
".",
"Float64s",
"(",
"p",
".",
"times",
")",
"\n\n",
"latest",
":=",
"p",
".",
"times",
"[",
"len",
"(",
"p",
".",
"times",
")",
"-",
"1",
"]",
"\n",
"bcount",
":=",
"int",
"(",
"latest",
"/",
"50",
")",
"+",
"1",
"\n",
"buckets",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"bcount",
")",
"\n\n",
"for",
"_",
",",
"t",
":=",
"range",
"p",
".",
"times",
"{",
"b",
":=",
"int",
"(",
"t",
"/",
"50.0",
")",
"\n",
"buckets",
"[",
"b",
"]",
"++",
"\n",
"}",
"\n\n",
"max",
":=",
"0",
"\n",
"for",
"_",
",",
"cnt",
":=",
"range",
"buckets",
"{",
"if",
"max",
"<",
"cnt",
"{",
"max",
"=",
"cnt",
"\n",
"}",
"\n",
"}",
"\n\n",
"chars",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"buckets",
")",
")",
"\n",
"distance",
":=",
"float64",
"(",
"max",
")",
"/",
"float64",
"(",
"len",
"(",
"ticks",
")",
"-",
"1",
")",
"\n\n",
"for",
"i",
",",
"cnt",
":=",
"range",
"buckets",
"{",
"tick",
":=",
"int",
"(",
"math",
".",
"Round",
"(",
"float64",
"(",
"cnt",
")",
"/",
"distance",
")",
")",
"\n",
"if",
"tick",
"<",
"0",
"{",
"tick",
"=",
"0",
"\n",
"}",
"\n\n",
"chars",
"[",
"i",
"]",
"=",
"ticks",
"[",
"tick",
"]",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"chars",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // sparkline takes all the received time stamps and put them
// in buckets of 50ms time brackets, it then use the amount
// of messages received in each bucket as the height | [
"sparkline",
"takes",
"all",
"the",
"received",
"time",
"stamps",
"and",
"put",
"them",
"in",
"buckets",
"of",
"50ms",
"time",
"brackets",
"it",
"then",
"use",
"the",
"amount",
"of",
"messages",
"received",
"in",
"each",
"bucket",
"as",
"the",
"height"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/cmd/ping.go#L206-L240 |
15,808 | choria-io/go-choria | provtarget/builddefaults/default.go | Targets | func (b *Resolver) Targets(ctx context.Context, log *logrus.Entry) []string {
if build.ProvisionBrokerURLs != "" {
return strings.Split(build.ProvisionBrokerURLs, ",")
}
return []string{}
} | go | func (b *Resolver) Targets(ctx context.Context, log *logrus.Entry) []string {
if build.ProvisionBrokerURLs != "" {
return strings.Split(build.ProvisionBrokerURLs, ",")
}
return []string{}
} | [
"func",
"(",
"b",
"*",
"Resolver",
")",
"Targets",
"(",
"ctx",
"context",
".",
"Context",
",",
"log",
"*",
"logrus",
".",
"Entry",
")",
"[",
"]",
"string",
"{",
"if",
"build",
".",
"ProvisionBrokerURLs",
"!=",
"\"",
"\"",
"{",
"return",
"strings",
".",
"Split",
"(",
"build",
".",
"ProvisionBrokerURLs",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}"
] | // Targets are the build time configured provisioners | [
"Targets",
"are",
"the",
"build",
"time",
"configured",
"provisioners"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/provtarget/builddefaults/default.go#L25-L31 |
15,809 | choria-io/go-choria | provtarget/provtarget.go | RegisterTargetResolver | func RegisterTargetResolver(r TargetResolver) error {
mu.Lock()
defer mu.Unlock()
resolver = r
return nil
} | go | func RegisterTargetResolver(r TargetResolver) error {
mu.Lock()
defer mu.Unlock()
resolver = r
return nil
} | [
"func",
"RegisterTargetResolver",
"(",
"r",
"TargetResolver",
")",
"error",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"resolver",
"=",
"r",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // RegisterTargetResolver registers a custom target resolver, else the default will be used | [
"RegisterTargetResolver",
"registers",
"a",
"custom",
"target",
"resolver",
"else",
"the",
"default",
"will",
"be",
"used"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/provtarget/provtarget.go#L27-L34 |
15,810 | choria-io/go-choria | provtarget/provtarget.go | Targets | func Targets(ctx context.Context, log *logrus.Entry) ([]srvcache.Server, error) {
mu.Lock()
defer mu.Unlock()
if resolver == nil {
return []srvcache.Server{}, fmt.Errorf("no Provisioning Target Resolver registered")
}
s := resolver.Targets(ctx, log)
if len(s) == 0 {
return []srvcache.Server{}, fmt.Errorf("provisioning target plugin %s returned no servers", Name())
}
servers, err := srvcache.StringHostsToServers(s, "nats")
if err != nil {
return []srvcache.Server{}, fmt.Errorf("could not determine provisioning servers using %s provisionig target plugin: %s", Name(), err)
}
if len(servers) == 0 {
return []srvcache.Server{}, fmt.Errorf("provisioning broker urls from the %s plugin were not in the valid format, 0 server:port combinations were foundin %v", Name(), s)
}
return servers, nil
} | go | func Targets(ctx context.Context, log *logrus.Entry) ([]srvcache.Server, error) {
mu.Lock()
defer mu.Unlock()
if resolver == nil {
return []srvcache.Server{}, fmt.Errorf("no Provisioning Target Resolver registered")
}
s := resolver.Targets(ctx, log)
if len(s) == 0 {
return []srvcache.Server{}, fmt.Errorf("provisioning target plugin %s returned no servers", Name())
}
servers, err := srvcache.StringHostsToServers(s, "nats")
if err != nil {
return []srvcache.Server{}, fmt.Errorf("could not determine provisioning servers using %s provisionig target plugin: %s", Name(), err)
}
if len(servers) == 0 {
return []srvcache.Server{}, fmt.Errorf("provisioning broker urls from the %s plugin were not in the valid format, 0 server:port combinations were foundin %v", Name(), s)
}
return servers, nil
} | [
"func",
"Targets",
"(",
"ctx",
"context",
".",
"Context",
",",
"log",
"*",
"logrus",
".",
"Entry",
")",
"(",
"[",
"]",
"srvcache",
".",
"Server",
",",
"error",
")",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"resolver",
"==",
"nil",
"{",
"return",
"[",
"]",
"srvcache",
".",
"Server",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"s",
":=",
"resolver",
".",
"Targets",
"(",
"ctx",
",",
"log",
")",
"\n\n",
"if",
"len",
"(",
"s",
")",
"==",
"0",
"{",
"return",
"[",
"]",
"srvcache",
".",
"Server",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"Name",
"(",
")",
")",
"\n",
"}",
"\n\n",
"servers",
",",
"err",
":=",
"srvcache",
".",
"StringHostsToServers",
"(",
"s",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"srvcache",
".",
"Server",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"servers",
")",
"==",
"0",
"{",
"return",
"[",
"]",
"srvcache",
".",
"Server",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"Name",
"(",
")",
",",
"s",
")",
"\n",
"}",
"\n\n",
"return",
"servers",
",",
"nil",
"\n",
"}"
] | // Targets is a list of brokers to connect to | [
"Targets",
"is",
"a",
"list",
"of",
"brokers",
"to",
"connect",
"to"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/provtarget/provtarget.go#L37-L61 |
15,811 | choria-io/go-choria | config/config.go | NewDefaultConfig | func NewDefaultConfig() (*Config, error) {
c := newConfig()
err := normalize(c)
if err != nil {
return nil, err
}
return c, nil
} | go | func NewDefaultConfig() (*Config, error) {
c := newConfig()
err := normalize(c)
if err != nil {
return nil, err
}
return c, nil
} | [
"func",
"NewDefaultConfig",
"(",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"c",
":=",
"newConfig",
"(",
")",
"\n\n",
"err",
":=",
"normalize",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | // NewDefaultConfig creates a empty configuration | [
"NewDefaultConfig",
"creates",
"a",
"empty",
"configuration"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/config/config.go#L176-L185 |
15,812 | choria-io/go-choria | config/config.go | NewConfig | func NewConfig(path string) (*Config, error) {
c := newConfig()
c.ConfigFile = path
err := parseConfig(path, c, "", c.rawOpts)
if err != nil {
return nil, err
}
err = parseConfig(c.ConfigFile, c.Choria, "", c.rawOpts)
if err != nil {
return nil, err
}
c.parseAllDotCfg()
err = normalize(c)
if err != nil {
return nil, err
}
return c, nil
} | go | func NewConfig(path string) (*Config, error) {
c := newConfig()
c.ConfigFile = path
err := parseConfig(path, c, "", c.rawOpts)
if err != nil {
return nil, err
}
err = parseConfig(c.ConfigFile, c.Choria, "", c.rawOpts)
if err != nil {
return nil, err
}
c.parseAllDotCfg()
err = normalize(c)
if err != nil {
return nil, err
}
return c, nil
} | [
"func",
"NewConfig",
"(",
"path",
"string",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"c",
":=",
"newConfig",
"(",
")",
"\n",
"c",
".",
"ConfigFile",
"=",
"path",
"\n\n",
"err",
":=",
"parseConfig",
"(",
"path",
",",
"c",
",",
"\"",
"\"",
",",
"c",
".",
"rawOpts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"parseConfig",
"(",
"c",
".",
"ConfigFile",
",",
"c",
".",
"Choria",
",",
"\"",
"\"",
",",
"c",
".",
"rawOpts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"parseAllDotCfg",
"(",
")",
"\n\n",
"err",
"=",
"normalize",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | // NewConfig parses a config file and return the config | [
"NewConfig",
"parses",
"a",
"config",
"file",
"and",
"return",
"the",
"config"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/config/config.go#L188-L210 |
15,813 | choria-io/go-choria | config/config.go | HasOption | func (conf *Config) HasOption(option string) bool {
_, ok := conf.rawOpts[option]
return ok
} | go | func (conf *Config) HasOption(option string) bool {
_, ok := conf.rawOpts[option]
return ok
} | [
"func",
"(",
"conf",
"*",
"Config",
")",
"HasOption",
"(",
"option",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"conf",
".",
"rawOpts",
"[",
"option",
"]",
"\n\n",
"return",
"ok",
"\n",
"}"
] | // HasOption determines if a specific option was set from a config key.
// The option given would be something like `plugin.choria.use_srv`
// and true would indicate that it was set by config vs using defaults | [
"HasOption",
"determines",
"if",
"a",
"specific",
"option",
"was",
"set",
"from",
"a",
"config",
"key",
".",
"The",
"option",
"given",
"would",
"be",
"something",
"like",
"plugin",
".",
"choria",
".",
"use_srv",
"and",
"true",
"would",
"indicate",
"that",
"it",
"was",
"set",
"by",
"config",
"vs",
"using",
"defaults"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/config/config.go#L264-L268 |
15,814 | choria-io/go-choria | config/config.go | Option | func (conf *Config) Option(option string, deflt string) string {
v, ok := conf.rawOpts[option]
if !ok {
return deflt
}
return v
} | go | func (conf *Config) Option(option string, deflt string) string {
v, ok := conf.rawOpts[option]
if !ok {
return deflt
}
return v
} | [
"func",
"(",
"conf",
"*",
"Config",
")",
"Option",
"(",
"option",
"string",
",",
"deflt",
"string",
")",
"string",
"{",
"v",
",",
"ok",
":=",
"conf",
".",
"rawOpts",
"[",
"option",
"]",
"\n\n",
"if",
"!",
"ok",
"{",
"return",
"deflt",
"\n",
"}",
"\n\n",
"return",
"v",
"\n",
"}"
] | // Option retrieves the raw string representation of a given option
// from that was loaded from the configuration | [
"Option",
"retrieves",
"the",
"raw",
"string",
"representation",
"of",
"a",
"given",
"option",
"from",
"that",
"was",
"loaded",
"from",
"the",
"configuration"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/config/config.go#L272-L280 |
15,815 | choria-io/go-choria | config/config.go | parseConfig | func parseConfig(path string, config interface{}, prefix string, found map[string]string) error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
parseConfigContents(file, config, prefix, found)
return nil
} | go | func parseConfig(path string, config interface{}, prefix string, found map[string]string) error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
parseConfigContents(file, config, prefix, found)
return nil
} | [
"func",
"parseConfig",
"(",
"path",
"string",
",",
"config",
"interface",
"{",
"}",
",",
"prefix",
"string",
",",
"found",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"file",
".",
"Close",
"(",
")",
"\n\n",
"parseConfigContents",
"(",
"file",
",",
"config",
",",
"prefix",
",",
"found",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // parse a config file and fill in the given config structure based on its tags | [
"parse",
"a",
"config",
"file",
"and",
"fill",
"in",
"the",
"given",
"config",
"structure",
"based",
"on",
"its",
"tags"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/config/config.go#L332-L342 |
15,816 | choria-io/go-choria | server/discovery/classes/classes.go | Match | func Match(needles []string, source string, log *logrus.Entry) bool {
classes, err := ReadClasses(source)
if err != nil {
log.Warnf("Could not parse classes file %s: %s", source, err)
return false
}
matched := 0
failed := 0
for _, needle := range needles {
if strings.HasPrefix(needle, "/") && strings.HasSuffix(needle, "/") {
needle = strings.TrimPrefix(needle, "/")
needle = strings.TrimSuffix(needle, "/")
if hasClassMatching(needle, classes) {
matched++
} else {
failed++
}
continue
}
if hasClass(needle, classes) {
matched++
} else {
failed++
}
}
return failed == 0 && matched > 0
} | go | func Match(needles []string, source string, log *logrus.Entry) bool {
classes, err := ReadClasses(source)
if err != nil {
log.Warnf("Could not parse classes file %s: %s", source, err)
return false
}
matched := 0
failed := 0
for _, needle := range needles {
if strings.HasPrefix(needle, "/") && strings.HasSuffix(needle, "/") {
needle = strings.TrimPrefix(needle, "/")
needle = strings.TrimSuffix(needle, "/")
if hasClassMatching(needle, classes) {
matched++
} else {
failed++
}
continue
}
if hasClass(needle, classes) {
matched++
} else {
failed++
}
}
return failed == 0 && matched > 0
} | [
"func",
"Match",
"(",
"needles",
"[",
"]",
"string",
",",
"source",
"string",
",",
"log",
"*",
"logrus",
".",
"Entry",
")",
"bool",
"{",
"classes",
",",
"err",
":=",
"ReadClasses",
"(",
"source",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"source",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"matched",
":=",
"0",
"\n",
"failed",
":=",
"0",
"\n\n",
"for",
"_",
",",
"needle",
":=",
"range",
"needles",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"needle",
",",
"\"",
"\"",
")",
"&&",
"strings",
".",
"HasSuffix",
"(",
"needle",
",",
"\"",
"\"",
")",
"{",
"needle",
"=",
"strings",
".",
"TrimPrefix",
"(",
"needle",
",",
"\"",
"\"",
")",
"\n",
"needle",
"=",
"strings",
".",
"TrimSuffix",
"(",
"needle",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"hasClassMatching",
"(",
"needle",
",",
"classes",
")",
"{",
"matched",
"++",
"\n",
"}",
"else",
"{",
"failed",
"++",
"\n",
"}",
"\n\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"hasClass",
"(",
"needle",
",",
"classes",
")",
"{",
"matched",
"++",
"\n",
"}",
"else",
"{",
"failed",
"++",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"failed",
"==",
"0",
"&&",
"matched",
">",
"0",
"\n",
"}"
] | // Match classes on a AND basis | [
"Match",
"classes",
"on",
"a",
"AND",
"basis"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/discovery/classes/classes.go#L13-L45 |
15,817 | choria-io/go-choria | server/discovery/classes/classes.go | ReadClasses | func ReadClasses(file string) ([]string, error) {
classes := []string{}
fh, err := os.Open(file)
if err != nil {
return classes, err
}
defer fh.Close()
scanner := bufio.NewScanner(fh)
for scanner.Scan() {
classes = append(classes, scanner.Text())
}
return classes, nil
} | go | func ReadClasses(file string) ([]string, error) {
classes := []string{}
fh, err := os.Open(file)
if err != nil {
return classes, err
}
defer fh.Close()
scanner := bufio.NewScanner(fh)
for scanner.Scan() {
classes = append(classes, scanner.Text())
}
return classes, nil
} | [
"func",
"ReadClasses",
"(",
"file",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"classes",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"fh",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"classes",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"fh",
".",
"Close",
"(",
")",
"\n\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"fh",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"classes",
"=",
"append",
"(",
"classes",
",",
"scanner",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"classes",
",",
"nil",
"\n",
"}"
] | // ReadClasses reads a given file and attempts to parse it as a typical classes file | [
"ReadClasses",
"reads",
"a",
"given",
"file",
"and",
"attempts",
"to",
"parse",
"it",
"as",
"a",
"typical",
"classes",
"file"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/discovery/classes/classes.go#L68-L84 |
15,818 | choria-io/go-choria | server/discovery/discovery.go | New | func New(framework *choria.Framework, logger *logrus.Entry) *Manager {
return &Manager{
fw: framework,
cfg: framework.Config,
log: logger.WithFields(logrus.Fields{"subsystem": "discovery"}),
}
} | go | func New(framework *choria.Framework, logger *logrus.Entry) *Manager {
return &Manager{
fw: framework,
cfg: framework.Config,
log: logger.WithFields(logrus.Fields{"subsystem": "discovery"}),
}
} | [
"func",
"New",
"(",
"framework",
"*",
"choria",
".",
"Framework",
",",
"logger",
"*",
"logrus",
".",
"Entry",
")",
"*",
"Manager",
"{",
"return",
"&",
"Manager",
"{",
"fw",
":",
"framework",
",",
"cfg",
":",
"framework",
".",
"Config",
",",
"log",
":",
"logger",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
")",
",",
"}",
"\n",
"}"
] | // New creates a new discovery Manager | [
"New",
"creates",
"a",
"new",
"discovery",
"Manager"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/discovery/discovery.go#L23-L29 |
15,819 | choria-io/go-choria | server/discovery/discovery.go | ShouldProcess | func (mgr *Manager) ShouldProcess(request protocol.Request, knownAgents []string) bool {
filter, _ := request.Filter()
passed := 0
if filter.Empty() {
mgr.log.Debugf("Matching request %s with empty filter", request.RequestID())
passed++
}
if len(filter.ClassFilters()) > 0 {
if classes.Match(filter.ClassFilters(), mgr.cfg.ClassesFile, mgr.log) {
mgr.log.Debugf("Matching request %s with class filters '%#v'", request.RequestID(), filter.ClassFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s with class filters '%#v'", request.RequestID(), filter.ClassFilters())
return false
}
}
if len(filter.AgentFilters()) > 0 {
if agents.Match(filter.AgentFilters(), knownAgents) {
mgr.log.Debugf("Matching request %s with agent filters '%#v'", request.RequestID(), filter.AgentFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s with agent filters '%#v'", request.RequestID(), filter.AgentFilters())
return false
}
}
if len(filter.IdentityFilters()) > 0 {
if identity.Match(filter.IdentityFilters(), mgr.cfg.Identity) {
mgr.log.Debugf("Matching request %s with identity filters '%#v'", request.RequestID(), filter.IdentityFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s with identity filters '%#v'", request.RequestID(), filter.IdentityFilters())
return false
}
}
if len(filter.FactFilters()) > 0 {
if facts.Match(filter.FactFilters(), mgr.fw, mgr.log) {
mgr.log.Debugf("Matching request %s based on fact filters '%#v'", request.RequestID(), filter.FactFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s based on fact filters '%#v'", request.RequestID(), filter.FactFilters())
return false
}
}
if len(filter.CompoundFilters()) > 0 {
mgr.log.Warnf("Compound filters are not supported, not matching request %s with filter '%#v'", request.RequestID(), filter.CompoundFilters())
return false
}
return passed > 0
} | go | func (mgr *Manager) ShouldProcess(request protocol.Request, knownAgents []string) bool {
filter, _ := request.Filter()
passed := 0
if filter.Empty() {
mgr.log.Debugf("Matching request %s with empty filter", request.RequestID())
passed++
}
if len(filter.ClassFilters()) > 0 {
if classes.Match(filter.ClassFilters(), mgr.cfg.ClassesFile, mgr.log) {
mgr.log.Debugf("Matching request %s with class filters '%#v'", request.RequestID(), filter.ClassFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s with class filters '%#v'", request.RequestID(), filter.ClassFilters())
return false
}
}
if len(filter.AgentFilters()) > 0 {
if agents.Match(filter.AgentFilters(), knownAgents) {
mgr.log.Debugf("Matching request %s with agent filters '%#v'", request.RequestID(), filter.AgentFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s with agent filters '%#v'", request.RequestID(), filter.AgentFilters())
return false
}
}
if len(filter.IdentityFilters()) > 0 {
if identity.Match(filter.IdentityFilters(), mgr.cfg.Identity) {
mgr.log.Debugf("Matching request %s with identity filters '%#v'", request.RequestID(), filter.IdentityFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s with identity filters '%#v'", request.RequestID(), filter.IdentityFilters())
return false
}
}
if len(filter.FactFilters()) > 0 {
if facts.Match(filter.FactFilters(), mgr.fw, mgr.log) {
mgr.log.Debugf("Matching request %s based on fact filters '%#v'", request.RequestID(), filter.FactFilters())
passed++
} else {
mgr.log.Debugf("Not matching request %s based on fact filters '%#v'", request.RequestID(), filter.FactFilters())
return false
}
}
if len(filter.CompoundFilters()) > 0 {
mgr.log.Warnf("Compound filters are not supported, not matching request %s with filter '%#v'", request.RequestID(), filter.CompoundFilters())
return false
}
return passed > 0
} | [
"func",
"(",
"mgr",
"*",
"Manager",
")",
"ShouldProcess",
"(",
"request",
"protocol",
".",
"Request",
",",
"knownAgents",
"[",
"]",
"string",
")",
"bool",
"{",
"filter",
",",
"_",
":=",
"request",
".",
"Filter",
"(",
")",
"\n",
"passed",
":=",
"0",
"\n\n",
"if",
"filter",
".",
"Empty",
"(",
")",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
")",
"\n",
"passed",
"++",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"filter",
".",
"ClassFilters",
"(",
")",
")",
">",
"0",
"{",
"if",
"classes",
".",
"Match",
"(",
"filter",
".",
"ClassFilters",
"(",
")",
",",
"mgr",
".",
"cfg",
".",
"ClassesFile",
",",
"mgr",
".",
"log",
")",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"ClassFilters",
"(",
")",
")",
"\n",
"passed",
"++",
"\n",
"}",
"else",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"ClassFilters",
"(",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"filter",
".",
"AgentFilters",
"(",
")",
")",
">",
"0",
"{",
"if",
"agents",
".",
"Match",
"(",
"filter",
".",
"AgentFilters",
"(",
")",
",",
"knownAgents",
")",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"AgentFilters",
"(",
")",
")",
"\n",
"passed",
"++",
"\n",
"}",
"else",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"AgentFilters",
"(",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"filter",
".",
"IdentityFilters",
"(",
")",
")",
">",
"0",
"{",
"if",
"identity",
".",
"Match",
"(",
"filter",
".",
"IdentityFilters",
"(",
")",
",",
"mgr",
".",
"cfg",
".",
"Identity",
")",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"IdentityFilters",
"(",
")",
")",
"\n",
"passed",
"++",
"\n",
"}",
"else",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"IdentityFilters",
"(",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"filter",
".",
"FactFilters",
"(",
")",
")",
">",
"0",
"{",
"if",
"facts",
".",
"Match",
"(",
"filter",
".",
"FactFilters",
"(",
")",
",",
"mgr",
".",
"fw",
",",
"mgr",
".",
"log",
")",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"FactFilters",
"(",
")",
")",
"\n",
"passed",
"++",
"\n",
"}",
"else",
"{",
"mgr",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"FactFilters",
"(",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"filter",
".",
"CompoundFilters",
"(",
")",
")",
">",
"0",
"{",
"mgr",
".",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"request",
".",
"RequestID",
"(",
")",
",",
"filter",
".",
"CompoundFilters",
"(",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"passed",
">",
"0",
"\n",
"}"
] | // ShouldProcess checks all filters against methods for filtering
// and returns boolean if it matches | [
"ShouldProcess",
"checks",
"all",
"filters",
"against",
"methods",
"for",
"filtering",
"and",
"returns",
"boolean",
"if",
"it",
"matches"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/discovery/discovery.go#L33-L88 |
15,820 | choria-io/go-choria | server/agent_provider_mock.go | NewMockAgentProvider | func NewMockAgentProvider(ctrl *gomock.Controller) *MockAgentProvider {
mock := &MockAgentProvider{ctrl: ctrl}
mock.recorder = &MockAgentProviderMockRecorder{mock}
return mock
} | go | func NewMockAgentProvider(ctrl *gomock.Controller) *MockAgentProvider {
mock := &MockAgentProvider{ctrl: ctrl}
mock.recorder = &MockAgentProviderMockRecorder{mock}
return mock
} | [
"func",
"NewMockAgentProvider",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAgentProvider",
"{",
"mock",
":=",
"&",
"MockAgentProvider",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAgentProviderMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAgentProvider creates a new mock instance | [
"NewMockAgentProvider",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agent_provider_mock.go#L27-L31 |
15,821 | choria-io/go-choria | server/agent_provider_mock.go | Initialize | func (mr *MockAgentProviderMockRecorder) Initialize(fw, log interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockAgentProvider)(nil).Initialize), fw, log)
} | go | func (mr *MockAgentProviderMockRecorder) Initialize(fw, log interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockAgentProvider)(nil).Initialize), fw, log)
} | [
"func",
"(",
"mr",
"*",
"MockAgentProviderMockRecorder",
")",
"Initialize",
"(",
"fw",
",",
"log",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAgentProvider",
")",
"(",
"nil",
")",
".",
"Initialize",
")",
",",
"fw",
",",
"log",
")",
"\n",
"}"
] | // Initialize indicates an expected call of Initialize | [
"Initialize",
"indicates",
"an",
"expected",
"call",
"of",
"Initialize"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agent_provider_mock.go#L44-L46 |
15,822 | choria-io/go-choria | server/agent_provider_mock.go | RegisterAgents | func (m *MockAgentProvider) RegisterAgents(ctx context.Context, mgr AgentManager, connector choria.InstanceConnector, log *logrus.Entry) error {
ret := m.ctrl.Call(m, "RegisterAgents", ctx, mgr, connector, log)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockAgentProvider) RegisterAgents(ctx context.Context, mgr AgentManager, connector choria.InstanceConnector, log *logrus.Entry) error {
ret := m.ctrl.Call(m, "RegisterAgents", ctx, mgr, connector, log)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAgentProvider",
")",
"RegisterAgents",
"(",
"ctx",
"context",
".",
"Context",
",",
"mgr",
"AgentManager",
",",
"connector",
"choria",
".",
"InstanceConnector",
",",
"log",
"*",
"logrus",
".",
"Entry",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
",",
"mgr",
",",
"connector",
",",
"log",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // RegisterAgents mocks base method | [
"RegisterAgents",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agent_provider_mock.go#L49-L53 |
15,823 | choria-io/go-choria | server/agent_provider_mock.go | RegisterAgents | func (mr *MockAgentProviderMockRecorder) RegisterAgents(ctx, mgr, connector, log interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterAgents", reflect.TypeOf((*MockAgentProvider)(nil).RegisterAgents), ctx, mgr, connector, log)
} | go | func (mr *MockAgentProviderMockRecorder) RegisterAgents(ctx, mgr, connector, log interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterAgents", reflect.TypeOf((*MockAgentProvider)(nil).RegisterAgents), ctx, mgr, connector, log)
} | [
"func",
"(",
"mr",
"*",
"MockAgentProviderMockRecorder",
")",
"RegisterAgents",
"(",
"ctx",
",",
"mgr",
",",
"connector",
",",
"log",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAgentProvider",
")",
"(",
"nil",
")",
".",
"RegisterAgents",
")",
",",
"ctx",
",",
"mgr",
",",
"connector",
",",
"log",
")",
"\n",
"}"
] | // RegisterAgents indicates an expected call of RegisterAgents | [
"RegisterAgents",
"indicates",
"an",
"expected",
"call",
"of",
"RegisterAgents"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agent_provider_mock.go#L56-L58 |
15,824 | choria-io/go-choria | server/agent_provider_mock.go | Version | func (mr *MockAgentProviderMockRecorder) Version() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockAgentProvider)(nil).Version))
} | go | func (mr *MockAgentProviderMockRecorder) Version() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockAgentProvider)(nil).Version))
} | [
"func",
"(",
"mr",
"*",
"MockAgentProviderMockRecorder",
")",
"Version",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockAgentProvider",
")",
"(",
"nil",
")",
".",
"Version",
")",
")",
"\n",
"}"
] | // Version indicates an expected call of Version | [
"Version",
"indicates",
"an",
"expected",
"call",
"of",
"Version"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agent_provider_mock.go#L68-L70 |
15,825 | choria-io/go-choria | aagent/notifiers/console/console.go | Debugf | func (n *Notifier) Debugf(m machine.InfoSource, name string, format string, args ...interface{}) {
logrus.Debugf("%s#%s: %s", m.Name(), name, fmt.Sprintf(format, args...))
} | go | func (n *Notifier) Debugf(m machine.InfoSource, name string, format string, args ...interface{}) {
logrus.Debugf("%s#%s: %s", m.Name(), name, fmt.Sprintf(format, args...))
} | [
"func",
"(",
"n",
"*",
"Notifier",
")",
"Debugf",
"(",
"m",
"machine",
".",
"InfoSource",
",",
"name",
"string",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"m",
".",
"Name",
"(",
")",
",",
"name",
",",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
")",
"\n",
"}"
] | // Debugf implements machine.NotificationService | [
"Debugf",
"implements",
"machine",
".",
"NotificationService"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/notifiers/console/console.go#L15-L17 |
15,826 | choria-io/go-choria | choria/connection_mock.go | NewMockConnectionManager | func NewMockConnectionManager(ctrl *gomock.Controller) *MockConnectionManager {
mock := &MockConnectionManager{ctrl: ctrl}
mock.recorder = &MockConnectionManagerMockRecorder{mock}
return mock
} | go | func NewMockConnectionManager(ctrl *gomock.Controller) *MockConnectionManager {
mock := &MockConnectionManager{ctrl: ctrl}
mock.recorder = &MockConnectionManagerMockRecorder{mock}
return mock
} | [
"func",
"NewMockConnectionManager",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockConnectionManager",
"{",
"mock",
":=",
"&",
"MockConnectionManager",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockConnectionManagerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockConnectionManager creates a new mock instance | [
"NewMockConnectionManager",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L28-L32 |
15,827 | choria-io/go-choria | choria/connection_mock.go | NewConnector | func (m *MockConnectionManager) NewConnector(ctx context.Context, servers func() ([]srvcache.Server, error), name string, logger *logrus.Entry) (Connector, error) {
ret := m.ctrl.Call(m, "NewConnector", ctx, servers, name, logger)
ret0, _ := ret[0].(Connector)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockConnectionManager) NewConnector(ctx context.Context, servers func() ([]srvcache.Server, error), name string, logger *logrus.Entry) (Connector, error) {
ret := m.ctrl.Call(m, "NewConnector", ctx, servers, name, logger)
ret0, _ := ret[0].(Connector)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockConnectionManager",
")",
"NewConnector",
"(",
"ctx",
"context",
".",
"Context",
",",
"servers",
"func",
"(",
")",
"(",
"[",
"]",
"srvcache",
".",
"Server",
",",
"error",
")",
",",
"name",
"string",
",",
"logger",
"*",
"logrus",
".",
"Entry",
")",
"(",
"Connector",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
",",
"servers",
",",
"name",
",",
"logger",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"Connector",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // NewConnector mocks base method | [
"NewConnector",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L40-L45 |
15,828 | choria-io/go-choria | choria/connection_mock.go | NewConnector | func (mr *MockConnectionManagerMockRecorder) NewConnector(ctx, servers, name, logger interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnector", reflect.TypeOf((*MockConnectionManager)(nil).NewConnector), ctx, servers, name, logger)
} | go | func (mr *MockConnectionManagerMockRecorder) NewConnector(ctx, servers, name, logger interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnector", reflect.TypeOf((*MockConnectionManager)(nil).NewConnector), ctx, servers, name, logger)
} | [
"func",
"(",
"mr",
"*",
"MockConnectionManagerMockRecorder",
")",
"NewConnector",
"(",
"ctx",
",",
"servers",
",",
"name",
",",
"logger",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockConnectionManager",
")",
"(",
"nil",
")",
".",
"NewConnector",
")",
",",
"ctx",
",",
"servers",
",",
"name",
",",
"logger",
")",
"\n",
"}"
] | // NewConnector indicates an expected call of NewConnector | [
"NewConnector",
"indicates",
"an",
"expected",
"call",
"of",
"NewConnector"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L48-L50 |
15,829 | choria-io/go-choria | choria/connection_mock.go | NewMockPublishableConnector | func NewMockPublishableConnector(ctrl *gomock.Controller) *MockPublishableConnector {
mock := &MockPublishableConnector{ctrl: ctrl}
mock.recorder = &MockPublishableConnectorMockRecorder{mock}
return mock
} | go | func NewMockPublishableConnector(ctrl *gomock.Controller) *MockPublishableConnector {
mock := &MockPublishableConnector{ctrl: ctrl}
mock.recorder = &MockPublishableConnectorMockRecorder{mock}
return mock
} | [
"func",
"NewMockPublishableConnector",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockPublishableConnector",
"{",
"mock",
":=",
"&",
"MockPublishableConnector",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockPublishableConnectorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockPublishableConnector creates a new mock instance | [
"NewMockPublishableConnector",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L64-L68 |
15,830 | choria-io/go-choria | choria/connection_mock.go | NewMockRawPublishableConnector | func NewMockRawPublishableConnector(ctrl *gomock.Controller) *MockRawPublishableConnector {
mock := &MockRawPublishableConnector{ctrl: ctrl}
mock.recorder = &MockRawPublishableConnectorMockRecorder{mock}
return mock
} | go | func NewMockRawPublishableConnector(ctrl *gomock.Controller) *MockRawPublishableConnector {
mock := &MockRawPublishableConnector{ctrl: ctrl}
mock.recorder = &MockRawPublishableConnectorMockRecorder{mock}
return mock
} | [
"func",
"NewMockRawPublishableConnector",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRawPublishableConnector",
"{",
"mock",
":=",
"&",
"MockRawPublishableConnector",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRawPublishableConnectorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockRawPublishableConnector creates a new mock instance | [
"NewMockRawPublishableConnector",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L99-L103 |
15,831 | choria-io/go-choria | choria/connection_mock.go | NewMockAgentConnector | func NewMockAgentConnector(ctrl *gomock.Controller) *MockAgentConnector {
mock := &MockAgentConnector{ctrl: ctrl}
mock.recorder = &MockAgentConnectorMockRecorder{mock}
return mock
} | go | func NewMockAgentConnector(ctrl *gomock.Controller) *MockAgentConnector {
mock := &MockAgentConnector{ctrl: ctrl}
mock.recorder = &MockAgentConnectorMockRecorder{mock}
return mock
} | [
"func",
"NewMockAgentConnector",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockAgentConnector",
"{",
"mock",
":=",
"&",
"MockAgentConnector",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockAgentConnectorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockAgentConnector creates a new mock instance | [
"NewMockAgentConnector",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L134-L138 |
15,832 | choria-io/go-choria | choria/connection_mock.go | QueueSubscribe | func (m *MockAgentConnector) QueueSubscribe(ctx context.Context, name, subject, group string, output chan *ConnectorMessage) error {
ret := m.ctrl.Call(m, "QueueSubscribe", ctx, name, subject, group, output)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockAgentConnector) QueueSubscribe(ctx context.Context, name, subject, group string, output chan *ConnectorMessage) error {
ret := m.ctrl.Call(m, "QueueSubscribe", ctx, name, subject, group, output)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockAgentConnector",
")",
"QueueSubscribe",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
",",
"subject",
",",
"group",
"string",
",",
"output",
"chan",
"*",
"ConnectorMessage",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
",",
"name",
",",
"subject",
",",
"group",
",",
"output",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // QueueSubscribe mocks base method | [
"QueueSubscribe",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L182-L186 |
15,833 | choria-io/go-choria | choria/connection_mock.go | NewMockClientConnector | func NewMockClientConnector(ctrl *gomock.Controller) *MockClientConnector {
mock := &MockClientConnector{ctrl: ctrl}
mock.recorder = &MockClientConnectorMockRecorder{mock}
return mock
} | go | func NewMockClientConnector(ctrl *gomock.Controller) *MockClientConnector {
mock := &MockClientConnector{ctrl: ctrl}
mock.recorder = &MockClientConnectorMockRecorder{mock}
return mock
} | [
"func",
"NewMockClientConnector",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockClientConnector",
"{",
"mock",
":=",
"&",
"MockClientConnector",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockClientConnectorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockClientConnector creates a new mock instance | [
"NewMockClientConnector",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L229-L233 |
15,834 | choria-io/go-choria | choria/connection_mock.go | NewMockConnectorInfo | func NewMockConnectorInfo(ctrl *gomock.Controller) *MockConnectorInfo {
mock := &MockConnectorInfo{ctrl: ctrl}
mock.recorder = &MockConnectorInfoMockRecorder{mock}
return mock
} | go | func NewMockConnectorInfo(ctrl *gomock.Controller) *MockConnectorInfo {
mock := &MockConnectorInfo{ctrl: ctrl}
mock.recorder = &MockConnectorInfoMockRecorder{mock}
return mock
} | [
"func",
"NewMockConnectorInfo",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockConnectorInfo",
"{",
"mock",
":=",
"&",
"MockConnectorInfo",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockConnectorInfoMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockConnectorInfo creates a new mock instance | [
"NewMockConnectorInfo",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L289-L293 |
15,835 | choria-io/go-choria | choria/connection_mock.go | ConnectionOptions | func (m *MockConnectorInfo) ConnectionOptions() go_nats.Options {
ret := m.ctrl.Call(m, "ConnectionOptions")
ret0, _ := ret[0].(go_nats.Options)
return ret0
} | go | func (m *MockConnectorInfo) ConnectionOptions() go_nats.Options {
ret := m.ctrl.Call(m, "ConnectionOptions")
ret0, _ := ret[0].(go_nats.Options)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockConnectorInfo",
")",
"ConnectionOptions",
"(",
")",
"go_nats",
".",
"Options",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"go_nats",
".",
"Options",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ConnectionOptions mocks base method | [
"ConnectionOptions",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L313-L317 |
15,836 | choria-io/go-choria | choria/connection_mock.go | NewMockInstanceConnector | func NewMockInstanceConnector(ctrl *gomock.Controller) *MockInstanceConnector {
mock := &MockInstanceConnector{ctrl: ctrl}
mock.recorder = &MockInstanceConnectorMockRecorder{mock}
return mock
} | go | func NewMockInstanceConnector(ctrl *gomock.Controller) *MockInstanceConnector {
mock := &MockInstanceConnector{ctrl: ctrl}
mock.recorder = &MockInstanceConnectorMockRecorder{mock}
return mock
} | [
"func",
"NewMockInstanceConnector",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockInstanceConnector",
"{",
"mock",
":=",
"&",
"MockInstanceConnector",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockInstanceConnectorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockInstanceConnector creates a new mock instance | [
"NewMockInstanceConnector",
"creates",
"a",
"new",
"mock",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L348-L352 |
15,837 | choria-io/go-choria | choria/connection_mock.go | ConnectedServer | func (m *MockInstanceConnector) ConnectedServer() string {
ret := m.ctrl.Call(m, "ConnectedServer")
ret0, _ := ret[0].(string)
return ret0
} | go | func (m *MockInstanceConnector) ConnectedServer() string {
ret := m.ctrl.Call(m, "ConnectedServer")
ret0, _ := ret[0].(string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockInstanceConnector",
")",
"ConnectedServer",
"(",
")",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ConnectedServer mocks base method | [
"ConnectedServer",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L360-L364 |
15,838 | choria-io/go-choria | choria/connection_mock.go | Unsubscribe | func (m *MockInstanceConnector) Unsubscribe(name string) error {
ret := m.ctrl.Call(m, "Unsubscribe", name)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockInstanceConnector) Unsubscribe(name string) error {
ret := m.ctrl.Call(m, "Unsubscribe", name)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockInstanceConnector",
")",
"Unsubscribe",
"(",
"name",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"name",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Unsubscribe mocks base method | [
"Unsubscribe",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L408-L412 |
15,839 | choria-io/go-choria | choria/connection_mock.go | AgentBroadcastTarget | func (m *MockInstanceConnector) AgentBroadcastTarget(collective, agent string) string {
ret := m.ctrl.Call(m, "AgentBroadcastTarget", collective, agent)
ret0, _ := ret[0].(string)
return ret0
} | go | func (m *MockInstanceConnector) AgentBroadcastTarget(collective, agent string) string {
ret := m.ctrl.Call(m, "AgentBroadcastTarget", collective, agent)
ret0, _ := ret[0].(string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockInstanceConnector",
")",
"AgentBroadcastTarget",
"(",
"collective",
",",
"agent",
"string",
")",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"collective",
",",
"agent",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // AgentBroadcastTarget mocks base method | [
"AgentBroadcastTarget",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L420-L424 |
15,840 | choria-io/go-choria | choria/connection_mock.go | NodeDirectedTarget | func (m *MockInstanceConnector) NodeDirectedTarget(collective, identity string) string {
ret := m.ctrl.Call(m, "NodeDirectedTarget", collective, identity)
ret0, _ := ret[0].(string)
return ret0
} | go | func (m *MockInstanceConnector) NodeDirectedTarget(collective, identity string) string {
ret := m.ctrl.Call(m, "NodeDirectedTarget", collective, identity)
ret0, _ := ret[0].(string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockInstanceConnector",
")",
"NodeDirectedTarget",
"(",
"collective",
",",
"identity",
"string",
")",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"collective",
",",
"identity",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // NodeDirectedTarget mocks base method | [
"NodeDirectedTarget",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L456-L460 |
15,841 | choria-io/go-choria | choria/connection_mock.go | ConnectionStats | func (m *MockConnector) ConnectionStats() go_nats.Statistics {
ret := m.ctrl.Call(m, "ConnectionStats")
ret0, _ := ret[0].(go_nats.Statistics)
return ret0
} | go | func (m *MockConnector) ConnectionStats() go_nats.Statistics {
ret := m.ctrl.Call(m, "ConnectionStats")
ret0, _ := ret[0].(go_nats.Statistics)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockConnector",
")",
"ConnectionStats",
"(",
")",
"go_nats",
".",
"Statistics",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"go_nats",
".",
"Statistics",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ConnectionStats mocks base method | [
"ConnectionStats",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L525-L529 |
15,842 | choria-io/go-choria | choria/connection_mock.go | Publish | func (m *MockConnector) Publish(msg *Message) error {
ret := m.ctrl.Call(m, "Publish", msg)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockConnector) Publish(msg *Message) error {
ret := m.ctrl.Call(m, "Publish", msg)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockConnector",
")",
"Publish",
"(",
"msg",
"*",
"Message",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"msg",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Publish mocks base method | [
"Publish",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L573-L577 |
15,843 | choria-io/go-choria | choria/connection_mock.go | PublishRaw | func (m *MockConnector) PublishRaw(target string, data []byte) error {
ret := m.ctrl.Call(m, "PublishRaw", target, data)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockConnector) PublishRaw(target string, data []byte) error {
ret := m.ctrl.Call(m, "PublishRaw", target, data)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockConnector",
")",
"PublishRaw",
"(",
"target",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"target",
",",
"data",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // PublishRaw mocks base method | [
"PublishRaw",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L585-L589 |
15,844 | choria-io/go-choria | choria/connection_mock.go | ReplyTarget | func (m *MockConnector) ReplyTarget(msg *Message) string {
ret := m.ctrl.Call(m, "ReplyTarget", msg)
ret0, _ := ret[0].(string)
return ret0
} | go | func (m *MockConnector) ReplyTarget(msg *Message) string {
ret := m.ctrl.Call(m, "ReplyTarget", msg)
ret0, _ := ret[0].(string)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockConnector",
")",
"ReplyTarget",
"(",
"msg",
"*",
"Message",
")",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"msg",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ReplyTarget mocks base method | [
"ReplyTarget",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L619-L623 |
15,845 | choria-io/go-choria | choria/connection_mock.go | ReplyTarget | func (mr *MockConnectorMockRecorder) ReplyTarget(msg interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplyTarget", reflect.TypeOf((*MockConnector)(nil).ReplyTarget), msg)
} | go | func (mr *MockConnectorMockRecorder) ReplyTarget(msg interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplyTarget", reflect.TypeOf((*MockConnector)(nil).ReplyTarget), msg)
} | [
"func",
"(",
"mr",
"*",
"MockConnectorMockRecorder",
")",
"ReplyTarget",
"(",
"msg",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockConnector",
")",
"(",
"nil",
")",
".",
"ReplyTarget",
")",
",",
"msg",
")",
"\n",
"}"
] | // ReplyTarget indicates an expected call of ReplyTarget | [
"ReplyTarget",
"indicates",
"an",
"expected",
"call",
"of",
"ReplyTarget"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L626-L628 |
15,846 | choria-io/go-choria | choria/connection_mock.go | ChanQueueSubscribe | func (m *MockConnector) ChanQueueSubscribe(name, subject, group string, capacity int) (chan *ConnectorMessage, error) {
ret := m.ctrl.Call(m, "ChanQueueSubscribe", name, subject, group, capacity)
ret0, _ := ret[0].(chan *ConnectorMessage)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockConnector) ChanQueueSubscribe(name, subject, group string, capacity int) (chan *ConnectorMessage, error) {
ret := m.ctrl.Call(m, "ChanQueueSubscribe", name, subject, group, capacity)
ret0, _ := ret[0].(chan *ConnectorMessage)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockConnector",
")",
"ChanQueueSubscribe",
"(",
"name",
",",
"subject",
",",
"group",
"string",
",",
"capacity",
"int",
")",
"(",
"chan",
"*",
"ConnectorMessage",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"name",
",",
"subject",
",",
"group",
",",
"capacity",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"chan",
"*",
"ConnectorMessage",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ChanQueueSubscribe mocks base method | [
"ChanQueueSubscribe",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L631-L636 |
15,847 | choria-io/go-choria | choria/connection_mock.go | Connect | func (m *MockConnector) Connect(ctx context.Context) error {
ret := m.ctrl.Call(m, "Connect", ctx)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockConnector) Connect(ctx context.Context) error {
ret := m.ctrl.Call(m, "Connect", ctx)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockConnector",
")",
"Connect",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Connect mocks base method | [
"Connect",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L644-L648 |
15,848 | choria-io/go-choria | choria/connection_mock.go | Connect | func (mr *MockConnectorMockRecorder) Connect(ctx interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockConnector)(nil).Connect), ctx)
} | go | func (mr *MockConnectorMockRecorder) Connect(ctx interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockConnector)(nil).Connect), ctx)
} | [
"func",
"(",
"mr",
"*",
"MockConnectorMockRecorder",
")",
"Connect",
"(",
"ctx",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockConnector",
")",
"(",
"nil",
")",
".",
"Connect",
")",
",",
"ctx",
")",
"\n",
"}"
] | // Connect indicates an expected call of Connect | [
"Connect",
"indicates",
"an",
"expected",
"call",
"of",
"Connect"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L651-L653 |
15,849 | choria-io/go-choria | choria/connection_mock.go | Nats | func (m *MockConnector) Nats() *go_nats.Conn {
ret := m.ctrl.Call(m, "Nats")
ret0, _ := ret[0].(*go_nats.Conn)
return ret0
} | go | func (m *MockConnector) Nats() *go_nats.Conn {
ret := m.ctrl.Call(m, "Nats")
ret0, _ := ret[0].(*go_nats.Conn)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockConnector",
")",
"Nats",
"(",
")",
"*",
"go_nats",
".",
"Conn",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"go_nats",
".",
"Conn",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Nats mocks base method | [
"Nats",
"mocks",
"base",
"method"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L656-L660 |
15,850 | choria-io/go-choria | choria/connection_mock.go | Nats | func (mr *MockConnectorMockRecorder) Nats() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nats", reflect.TypeOf((*MockConnector)(nil).Nats))
} | go | func (mr *MockConnectorMockRecorder) Nats() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nats", reflect.TypeOf((*MockConnector)(nil).Nats))
} | [
"func",
"(",
"mr",
"*",
"MockConnectorMockRecorder",
")",
"Nats",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockConnector",
")",
"(",
"nil",
")",
".",
"Nats",
")",
")",
"\n",
"}"
] | // Nats indicates an expected call of Nats | [
"Nats",
"indicates",
"an",
"expected",
"call",
"of",
"Nats"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/connection_mock.go#L663-L665 |
15,851 | choria-io/go-choria | aagent/notifiers/choria/choria.go | New | func New(fw ChoriaProvider) (n *Notifier, err error) {
n = &Notifier{
fw: fw,
logger: fw.Logger("machine"),
}
return n, nil
} | go | func New(fw ChoriaProvider) (n *Notifier, err error) {
n = &Notifier{
fw: fw,
logger: fw.Logger("machine"),
}
return n, nil
} | [
"func",
"New",
"(",
"fw",
"ChoriaProvider",
")",
"(",
"n",
"*",
"Notifier",
",",
"err",
"error",
")",
"{",
"n",
"=",
"&",
"Notifier",
"{",
"fw",
":",
"fw",
",",
"logger",
":",
"fw",
".",
"Logger",
"(",
"\"",
"\"",
")",
",",
"}",
"\n\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] | // New creates a new choria notifier | [
"New",
"creates",
"a",
"new",
"choria",
"notifier"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/notifiers/choria/choria.go#L25-L32 |
15,852 | choria-io/go-choria | srvcache/server.go | URL | func (s *Server) URL() (u *url.URL, err error) {
if s.Scheme == "" {
return u, fmt.Errorf("Server %s:%d has no scheme, cannot make a URL", s.Host, s.Port)
}
ustring := fmt.Sprintf("%s://%s:%d", s.Scheme, s.Host, s.Port)
u, err = url.Parse(ustring)
if err != nil {
return u, fmt.Errorf("Could not parse %s: %s", ustring, err)
}
return
} | go | func (s *Server) URL() (u *url.URL, err error) {
if s.Scheme == "" {
return u, fmt.Errorf("Server %s:%d has no scheme, cannot make a URL", s.Host, s.Port)
}
ustring := fmt.Sprintf("%s://%s:%d", s.Scheme, s.Host, s.Port)
u, err = url.Parse(ustring)
if err != nil {
return u, fmt.Errorf("Could not parse %s: %s", ustring, err)
}
return
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"URL",
"(",
")",
"(",
"u",
"*",
"url",
".",
"URL",
",",
"err",
"error",
")",
"{",
"if",
"s",
".",
"Scheme",
"==",
"\"",
"\"",
"{",
"return",
"u",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Host",
",",
"s",
".",
"Port",
")",
"\n",
"}",
"\n\n",
"ustring",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
".",
"Scheme",
",",
"s",
".",
"Host",
",",
"s",
".",
"Port",
")",
"\n\n",
"u",
",",
"err",
"=",
"url",
".",
"Parse",
"(",
"ustring",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"u",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ustring",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // URL creates a correct url from the server if scheme is known | [
"URL",
"creates",
"a",
"correct",
"url",
"from",
"the",
"server",
"if",
"scheme",
"is",
"known"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/srvcache/server.go#L16-L29 |
15,853 | choria-io/go-choria | aagent/aagent.go | New | func New(dir string, fw ChoriaProvider) (aa *AAgent, err error) {
notifier, err := notifier.New(fw)
if err != nil {
return nil, errors.Wrapf(err, "could not create notifier")
}
return &AAgent{
fw: fw,
logger: fw.Logger("aagent"),
source: dir,
machines: []*managedMachine{},
notifier: notifier,
}, nil
} | go | func New(dir string, fw ChoriaProvider) (aa *AAgent, err error) {
notifier, err := notifier.New(fw)
if err != nil {
return nil, errors.Wrapf(err, "could not create notifier")
}
return &AAgent{
fw: fw,
logger: fw.Logger("aagent"),
source: dir,
machines: []*managedMachine{},
notifier: notifier,
}, nil
} | [
"func",
"New",
"(",
"dir",
"string",
",",
"fw",
"ChoriaProvider",
")",
"(",
"aa",
"*",
"AAgent",
",",
"err",
"error",
")",
"{",
"notifier",
",",
"err",
":=",
"notifier",
".",
"New",
"(",
"fw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"AAgent",
"{",
"fw",
":",
"fw",
",",
"logger",
":",
"fw",
".",
"Logger",
"(",
"\"",
"\"",
")",
",",
"source",
":",
"dir",
",",
"machines",
":",
"[",
"]",
"*",
"managedMachine",
"{",
"}",
",",
"notifier",
":",
"notifier",
",",
"}",
",",
"nil",
"\n",
"}"
] | // New creates a new instance of the choria autonomous agent host | [
"New",
"creates",
"a",
"new",
"instance",
"of",
"the",
"choria",
"autonomous",
"agent",
"host"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/aagent.go#L46-L59 |
15,854 | choria-io/go-choria | aagent/aagent.go | ManageMachines | func (a *AAgent) ManageMachines(ctx context.Context, wg *sync.WaitGroup) error {
wg.Add(1)
go a.watchSource(ctx, wg)
return nil
} | go | func (a *AAgent) ManageMachines(ctx context.Context, wg *sync.WaitGroup) error {
wg.Add(1)
go a.watchSource(ctx, wg)
return nil
} | [
"func",
"(",
"a",
"*",
"AAgent",
")",
"ManageMachines",
"(",
"ctx",
"context",
".",
"Context",
",",
"wg",
"*",
"sync",
".",
"WaitGroup",
")",
"error",
"{",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"a",
".",
"watchSource",
"(",
"ctx",
",",
"wg",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ManageMachines start observing the | [
"ManageMachines",
"start",
"observing",
"the"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/aagent.go#L62-L67 |
15,855 | choria-io/go-choria | aagent/aagent.go | Transition | func (a *AAgent) Transition(name string, version string, path string, id string, transition string) error {
m := a.findMachine(name, version, path, id)
if m == nil {
return fmt.Errorf("could not find machine with id %s", id)
}
if !m.machine.Can(transition) {
return fmt.Errorf("transition %s is not valid while in %v state", transition, m.machine.State())
}
err := m.machine.Transition(transition)
if err != nil {
return err
}
return nil
} | go | func (a *AAgent) Transition(name string, version string, path string, id string, transition string) error {
m := a.findMachine(name, version, path, id)
if m == nil {
return fmt.Errorf("could not find machine with id %s", id)
}
if !m.machine.Can(transition) {
return fmt.Errorf("transition %s is not valid while in %v state", transition, m.machine.State())
}
err := m.machine.Transition(transition)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"a",
"*",
"AAgent",
")",
"Transition",
"(",
"name",
"string",
",",
"version",
"string",
",",
"path",
"string",
",",
"id",
"string",
",",
"transition",
"string",
")",
"error",
"{",
"m",
":=",
"a",
".",
"findMachine",
"(",
"name",
",",
"version",
",",
"path",
",",
"id",
")",
"\n",
"if",
"m",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"m",
".",
"machine",
".",
"Can",
"(",
"transition",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"transition",
",",
"m",
".",
"machine",
".",
"State",
"(",
")",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"m",
".",
"machine",
".",
"Transition",
"(",
"transition",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Transition transitions a running machine using a supplied transition event. Success is not guaranteed as the machine might be in a state that does not allow the transition | [
"Transition",
"transitions",
"a",
"running",
"machine",
"using",
"a",
"supplied",
"transition",
"event",
".",
"Success",
"is",
"not",
"guaranteed",
"as",
"the",
"machine",
"might",
"be",
"in",
"a",
"state",
"that",
"does",
"not",
"allow",
"the",
"transition"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/aagent.go#L70-L86 |
15,856 | choria-io/go-choria | server/infosource.go | NewEvent | func (srv *Instance) NewEvent(t lifecycle.Type, opts ...lifecycle.Option) error {
opts = append(opts, lifecycle.Component(srv.eventComponent()))
opts = append(opts, lifecycle.Identity(srv.cfg.Identity))
opts = append(opts, lifecycle.Version(build.Version))
e, err := lifecycle.New(t, opts...)
if err != nil {
return err
}
return srv.PublishEvent(e)
} | go | func (srv *Instance) NewEvent(t lifecycle.Type, opts ...lifecycle.Option) error {
opts = append(opts, lifecycle.Component(srv.eventComponent()))
opts = append(opts, lifecycle.Identity(srv.cfg.Identity))
opts = append(opts, lifecycle.Version(build.Version))
e, err := lifecycle.New(t, opts...)
if err != nil {
return err
}
return srv.PublishEvent(e)
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"NewEvent",
"(",
"t",
"lifecycle",
".",
"Type",
",",
"opts",
"...",
"lifecycle",
".",
"Option",
")",
"error",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"lifecycle",
".",
"Component",
"(",
"srv",
".",
"eventComponent",
"(",
")",
")",
")",
"\n",
"opts",
"=",
"append",
"(",
"opts",
",",
"lifecycle",
".",
"Identity",
"(",
"srv",
".",
"cfg",
".",
"Identity",
")",
")",
"\n",
"opts",
"=",
"append",
"(",
"opts",
",",
"lifecycle",
".",
"Version",
"(",
"build",
".",
"Version",
")",
")",
"\n\n",
"e",
",",
"err",
":=",
"lifecycle",
".",
"New",
"(",
"t",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"srv",
".",
"PublishEvent",
"(",
"e",
")",
"\n",
"}"
] | // NewEvent creates a new event with the server component and identity set and publishes it | [
"NewEvent",
"creates",
"a",
"new",
"event",
"with",
"the",
"server",
"component",
"and",
"identity",
"set",
"and",
"publishes",
"it"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L37-L48 |
15,857 | choria-io/go-choria | server/infosource.go | PublishRaw | func (srv *Instance) PublishRaw(target string, data []byte) error {
return srv.connector.PublishRaw(target, data)
} | go | func (srv *Instance) PublishRaw(target string, data []byte) error {
return srv.connector.PublishRaw(target, data)
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"PublishRaw",
"(",
"target",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"return",
"srv",
".",
"connector",
".",
"PublishRaw",
"(",
"target",
",",
"data",
")",
"\n",
"}"
] | // PublishRaw allows publishing to the connected middleware | [
"PublishRaw",
"allows",
"publishing",
"to",
"the",
"connected",
"middleware"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L61-L63 |
15,858 | choria-io/go-choria | server/infosource.go | MachinesStatus | func (srv *Instance) MachinesStatus() ([]aagent.MachineState, error) {
if srv.machines == nil {
return []aagent.MachineState{}, nil
}
return srv.machines.AllMachineStates()
} | go | func (srv *Instance) MachinesStatus() ([]aagent.MachineState, error) {
if srv.machines == nil {
return []aagent.MachineState{}, nil
}
return srv.machines.AllMachineStates()
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"MachinesStatus",
"(",
")",
"(",
"[",
"]",
"aagent",
".",
"MachineState",
",",
"error",
")",
"{",
"if",
"srv",
".",
"machines",
"==",
"nil",
"{",
"return",
"[",
"]",
"aagent",
".",
"MachineState",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"srv",
".",
"machines",
".",
"AllMachineStates",
"(",
")",
"\n",
"}"
] | // MachinesStatus returns the status of all loaded autonomous agents | [
"MachinesStatus",
"returns",
"the",
"status",
"of",
"all",
"loaded",
"autonomous",
"agents"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L76-L82 |
15,859 | choria-io/go-choria | server/infosource.go | MachineTransition | func (srv *Instance) MachineTransition(name string, version string, path string, id string, transition string) error {
if srv.machines == nil {
return fmt.Errorf("Autonomous Agent host not initialized")
}
return srv.machines.Transition(name, version, path, id, transition)
} | go | func (srv *Instance) MachineTransition(name string, version string, path string, id string, transition string) error {
if srv.machines == nil {
return fmt.Errorf("Autonomous Agent host not initialized")
}
return srv.machines.Transition(name, version, path, id, transition)
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"MachineTransition",
"(",
"name",
"string",
",",
"version",
"string",
",",
"path",
"string",
",",
"id",
"string",
",",
"transition",
"string",
")",
"error",
"{",
"if",
"srv",
".",
"machines",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"srv",
".",
"machines",
".",
"Transition",
"(",
"name",
",",
"version",
",",
"path",
",",
"id",
",",
"transition",
")",
"\n",
"}"
] | // MachineTransition sends a transition event to a specific running machine instance | [
"MachineTransition",
"sends",
"a",
"transition",
"event",
"to",
"a",
"specific",
"running",
"machine",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L85-L91 |
15,860 | choria-io/go-choria | server/infosource.go | AgentMetadata | func (srv *Instance) AgentMetadata(agent string) (agents.Metadata, bool) {
a, found := srv.agents.Get(agent)
if !found {
return agents.Metadata{}, false
}
return *a.Metadata(), true
} | go | func (srv *Instance) AgentMetadata(agent string) (agents.Metadata, bool) {
a, found := srv.agents.Get(agent)
if !found {
return agents.Metadata{}, false
}
return *a.Metadata(), true
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"AgentMetadata",
"(",
"agent",
"string",
")",
"(",
"agents",
".",
"Metadata",
",",
"bool",
")",
"{",
"a",
",",
"found",
":=",
"srv",
".",
"agents",
".",
"Get",
"(",
"agent",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"agents",
".",
"Metadata",
"{",
"}",
",",
"false",
"\n",
"}",
"\n\n",
"return",
"*",
"a",
".",
"Metadata",
"(",
")",
",",
"true",
"\n",
"}"
] | // AgentMetadata looks up the metadata for a specific agent | [
"AgentMetadata",
"looks",
"up",
"the",
"metadata",
"for",
"a",
"specific",
"agent"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L99-L106 |
15,861 | choria-io/go-choria | server/infosource.go | Classes | func (srv *Instance) Classes() []string {
classes, err := classes.ReadClasses(srv.cfg.ClassesFile)
if err != nil {
return []string{}
}
return classes
} | go | func (srv *Instance) Classes() []string {
classes, err := classes.ReadClasses(srv.cfg.ClassesFile)
if err != nil {
return []string{}
}
return classes
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"Classes",
"(",
")",
"[",
"]",
"string",
"{",
"classes",
",",
"err",
":=",
"classes",
".",
"ReadClasses",
"(",
"srv",
".",
"cfg",
".",
"ClassesFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n\n",
"return",
"classes",
"\n",
"}"
] | // Classes is a list of classification classes this node matches | [
"Classes",
"is",
"a",
"list",
"of",
"classification",
"classes",
"this",
"node",
"matches"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L114-L121 |
15,862 | choria-io/go-choria | server/infosource.go | Facts | func (srv *Instance) Facts() json.RawMessage {
j, _ := facts.JSON(srv.cfg.FactSourceFile, srv.log)
return j
} | go | func (srv *Instance) Facts() json.RawMessage {
j, _ := facts.JSON(srv.cfg.FactSourceFile, srv.log)
return j
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"Facts",
"(",
")",
"json",
".",
"RawMessage",
"{",
"j",
",",
"_",
":=",
"facts",
".",
"JSON",
"(",
"srv",
".",
"cfg",
".",
"FactSourceFile",
",",
"srv",
".",
"log",
")",
"\n\n",
"return",
"j",
"\n",
"}"
] | // Facts are all the known facts to this instance | [
"Facts",
"are",
"all",
"the",
"known",
"facts",
"to",
"this",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L124-L128 |
15,863 | choria-io/go-choria | server/infosource.go | UpTime | func (srv *Instance) UpTime() int64 {
return int64(time.Now().Sub(srv.startTime).Seconds())
} | go | func (srv *Instance) UpTime() int64 {
return int64(time.Now().Sub(srv.startTime).Seconds())
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"UpTime",
"(",
")",
"int64",
"{",
"return",
"int64",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"srv",
".",
"startTime",
")",
".",
"Seconds",
"(",
")",
")",
"\n",
"}"
] | // UpTime returns how long the server has been running | [
"UpTime",
"returns",
"how",
"long",
"the",
"server",
"has",
"been",
"running"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L136-L138 |
15,864 | choria-io/go-choria | server/infosource.go | Stats | func (srv *Instance) Stats() agents.ServerStats {
return agents.ServerStats{
Total: srv.getPromCtrValue(totalCtr),
Valid: srv.getPromCtrValue(validatedCtr),
Invalid: srv.getPromCtrValue(unvalidatedCtr),
Passed: srv.getPromCtrValue(passedCtr),
Filtered: srv.getPromCtrValue(filteredCtr),
Replies: srv.getPromCtrValue(repliesCtr),
TTLExpired: srv.getPromCtrValue(ttlExpiredCtr),
}
} | go | func (srv *Instance) Stats() agents.ServerStats {
return agents.ServerStats{
Total: srv.getPromCtrValue(totalCtr),
Valid: srv.getPromCtrValue(validatedCtr),
Invalid: srv.getPromCtrValue(unvalidatedCtr),
Passed: srv.getPromCtrValue(passedCtr),
Filtered: srv.getPromCtrValue(filteredCtr),
Replies: srv.getPromCtrValue(repliesCtr),
TTLExpired: srv.getPromCtrValue(ttlExpiredCtr),
}
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"Stats",
"(",
")",
"agents",
".",
"ServerStats",
"{",
"return",
"agents",
".",
"ServerStats",
"{",
"Total",
":",
"srv",
".",
"getPromCtrValue",
"(",
"totalCtr",
")",
",",
"Valid",
":",
"srv",
".",
"getPromCtrValue",
"(",
"validatedCtr",
")",
",",
"Invalid",
":",
"srv",
".",
"getPromCtrValue",
"(",
"unvalidatedCtr",
")",
",",
"Passed",
":",
"srv",
".",
"getPromCtrValue",
"(",
"passedCtr",
")",
",",
"Filtered",
":",
"srv",
".",
"getPromCtrValue",
"(",
"filteredCtr",
")",
",",
"Replies",
":",
"srv",
".",
"getPromCtrValue",
"(",
"repliesCtr",
")",
",",
"TTLExpired",
":",
"srv",
".",
"getPromCtrValue",
"(",
"ttlExpiredCtr",
")",
",",
"}",
"\n",
"}"
] | // Stats expose server statistics | [
"Stats",
"expose",
"server",
"statistics"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L146-L156 |
15,865 | choria-io/go-choria | server/infosource.go | Status | func (srv *Instance) Status() *InstanceStatus {
stats := srv.Stats()
return &InstanceStatus{
Identity: srv.cfg.Identity,
Uptime: srv.UpTime(),
ConnectedServer: srv.ConnectedServer(),
LastMessage: srv.LastProcessedMessage().Unix(),
Provisioning: srv.Provisioning(),
Stats: &stats,
}
} | go | func (srv *Instance) Status() *InstanceStatus {
stats := srv.Stats()
return &InstanceStatus{
Identity: srv.cfg.Identity,
Uptime: srv.UpTime(),
ConnectedServer: srv.ConnectedServer(),
LastMessage: srv.LastProcessedMessage().Unix(),
Provisioning: srv.Provisioning(),
Stats: &stats,
}
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"Status",
"(",
")",
"*",
"InstanceStatus",
"{",
"stats",
":=",
"srv",
".",
"Stats",
"(",
")",
"\n\n",
"return",
"&",
"InstanceStatus",
"{",
"Identity",
":",
"srv",
".",
"cfg",
".",
"Identity",
",",
"Uptime",
":",
"srv",
".",
"UpTime",
"(",
")",
",",
"ConnectedServer",
":",
"srv",
".",
"ConnectedServer",
"(",
")",
",",
"LastMessage",
":",
"srv",
".",
"LastProcessedMessage",
"(",
")",
".",
"Unix",
"(",
")",
",",
"Provisioning",
":",
"srv",
".",
"Provisioning",
"(",
")",
",",
"Stats",
":",
"&",
"stats",
",",
"}",
"\n",
"}"
] | // Status calculates the current server status | [
"Status",
"calculates",
"the",
"current",
"server",
"status"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L159-L170 |
15,866 | choria-io/go-choria | server/infosource.go | WriteServerStatus | func (srv *Instance) WriteServerStatus(ctx context.Context, wg *sync.WaitGroup) {
defer wg.Done()
target := srv.cfg.Choria.StatusFilePath
freq := srv.cfg.Choria.StatusUpdateSeconds
writer := func() error {
if target == "" || freq == 0 {
srv.log.Debug("Server status writing has been disabled")
return nil
}
srv.log.Debugf("Writing server status to %s", target)
j, err := json.Marshal(srv.Status())
if err != nil {
return err
}
err = ioutil.WriteFile(target, j, 0644)
if err != nil {
return err
}
return os.Chmod(target, 0644)
}
err := writer()
if err != nil {
srv.log.Errorf("Initial server status write to %s failed: %s", target, err)
}
timer := time.NewTicker(time.Duration(freq) * time.Second)
for {
select {
case <-timer.C:
err = writer()
if err != nil {
srv.log.Errorf("Server status write to %s failed: %s", target, err)
}
case <-ctx.Done():
return
}
}
} | go | func (srv *Instance) WriteServerStatus(ctx context.Context, wg *sync.WaitGroup) {
defer wg.Done()
target := srv.cfg.Choria.StatusFilePath
freq := srv.cfg.Choria.StatusUpdateSeconds
writer := func() error {
if target == "" || freq == 0 {
srv.log.Debug("Server status writing has been disabled")
return nil
}
srv.log.Debugf("Writing server status to %s", target)
j, err := json.Marshal(srv.Status())
if err != nil {
return err
}
err = ioutil.WriteFile(target, j, 0644)
if err != nil {
return err
}
return os.Chmod(target, 0644)
}
err := writer()
if err != nil {
srv.log.Errorf("Initial server status write to %s failed: %s", target, err)
}
timer := time.NewTicker(time.Duration(freq) * time.Second)
for {
select {
case <-timer.C:
err = writer()
if err != nil {
srv.log.Errorf("Server status write to %s failed: %s", target, err)
}
case <-ctx.Done():
return
}
}
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"WriteServerStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"wg",
"*",
"sync",
".",
"WaitGroup",
")",
"{",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"target",
":=",
"srv",
".",
"cfg",
".",
"Choria",
".",
"StatusFilePath",
"\n",
"freq",
":=",
"srv",
".",
"cfg",
".",
"Choria",
".",
"StatusUpdateSeconds",
"\n\n",
"writer",
":=",
"func",
"(",
")",
"error",
"{",
"if",
"target",
"==",
"\"",
"\"",
"||",
"freq",
"==",
"0",
"{",
"srv",
".",
"log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"srv",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"target",
")",
"\n\n",
"j",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"srv",
".",
"Status",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"target",
",",
"j",
",",
"0644",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"Chmod",
"(",
"target",
",",
"0644",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"writer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"srv",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"target",
",",
"err",
")",
"\n",
"}",
"\n\n",
"timer",
":=",
"time",
".",
"NewTicker",
"(",
"time",
".",
"Duration",
"(",
"freq",
")",
"*",
"time",
".",
"Second",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"timer",
".",
"C",
":",
"err",
"=",
"writer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"srv",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"target",
",",
"err",
")",
"\n",
"}",
"\n\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WriteServerStatus periodically writes the server status to a file | [
"WriteServerStatus",
"periodically",
"writes",
"the",
"server",
"status",
"to",
"a",
"file"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/infosource.go#L173-L219 |
15,867 | choria-io/go-choria | server/instance.go | NewInstance | func NewInstance(fw *choria.Framework) (i *Instance, err error) {
i = &Instance{
fw: fw,
cfg: fw.Config,
requests: make(chan *choria.ConnectorMessage),
mu: &sync.Mutex{},
startTime: time.Now(),
lastMsgProcessed: time.Unix(0, 0),
agentDenyList: []string{},
}
i.log = log.WithFields(log.Fields{"identity": fw.Config.Identity, "component": "server"})
i.discovery = discovery.New(fw, i.log)
return i, nil
} | go | func NewInstance(fw *choria.Framework) (i *Instance, err error) {
i = &Instance{
fw: fw,
cfg: fw.Config,
requests: make(chan *choria.ConnectorMessage),
mu: &sync.Mutex{},
startTime: time.Now(),
lastMsgProcessed: time.Unix(0, 0),
agentDenyList: []string{},
}
i.log = log.WithFields(log.Fields{"identity": fw.Config.Identity, "component": "server"})
i.discovery = discovery.New(fw, i.log)
return i, nil
} | [
"func",
"NewInstance",
"(",
"fw",
"*",
"choria",
".",
"Framework",
")",
"(",
"i",
"*",
"Instance",
",",
"err",
"error",
")",
"{",
"i",
"=",
"&",
"Instance",
"{",
"fw",
":",
"fw",
",",
"cfg",
":",
"fw",
".",
"Config",
",",
"requests",
":",
"make",
"(",
"chan",
"*",
"choria",
".",
"ConnectorMessage",
")",
",",
"mu",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"startTime",
":",
"time",
".",
"Now",
"(",
")",
",",
"lastMsgProcessed",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"0",
")",
",",
"agentDenyList",
":",
"[",
"]",
"string",
"{",
"}",
",",
"}",
"\n\n",
"i",
".",
"log",
"=",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"",
"\"",
":",
"fw",
".",
"Config",
".",
"Identity",
",",
"\"",
"\"",
":",
"\"",
"\"",
"}",
")",
"\n",
"i",
".",
"discovery",
"=",
"discovery",
".",
"New",
"(",
"fw",
",",
"i",
".",
"log",
")",
"\n\n",
"return",
"i",
",",
"nil",
"\n",
"}"
] | // NewInstance creates a new choria server instance | [
"NewInstance",
"creates",
"a",
"new",
"choria",
"server",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/instance.go#L43-L58 |
15,868 | choria-io/go-choria | server/instance.go | Logger | func (srv *Instance) Logger(component string) *log.Entry {
return srv.fw.Logger(component)
} | go | func (srv *Instance) Logger(component string) *log.Entry {
return srv.fw.Logger(component)
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"Logger",
"(",
"component",
"string",
")",
"*",
"log",
".",
"Entry",
"{",
"return",
"srv",
".",
"fw",
".",
"Logger",
"(",
"component",
")",
"\n",
"}"
] | // Logger creates a new logger instance | [
"Logger",
"creates",
"a",
"new",
"logger",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/instance.go#L61-L63 |
15,869 | choria-io/go-choria | server/instance.go | RegisterRegistrationProvider | func (srv *Instance) RegisterRegistrationProvider(ctx context.Context, wg *sync.WaitGroup, provider registration.RegistrationDataProvider) error {
return srv.registration.RegisterProvider(ctx, wg, provider)
} | go | func (srv *Instance) RegisterRegistrationProvider(ctx context.Context, wg *sync.WaitGroup, provider registration.RegistrationDataProvider) error {
return srv.registration.RegisterProvider(ctx, wg, provider)
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"RegisterRegistrationProvider",
"(",
"ctx",
"context",
".",
"Context",
",",
"wg",
"*",
"sync",
".",
"WaitGroup",
",",
"provider",
"registration",
".",
"RegistrationDataProvider",
")",
"error",
"{",
"return",
"srv",
".",
"registration",
".",
"RegisterProvider",
"(",
"ctx",
",",
"wg",
",",
"provider",
")",
"\n",
"}"
] | // RegisterRegistrationProvider adds a new provider for registration data to the registration subsystem | [
"RegisterRegistrationProvider",
"adds",
"a",
"new",
"provider",
"for",
"registration",
"data",
"to",
"the",
"registration",
"subsystem"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/instance.go#L134-L136 |
15,870 | choria-io/go-choria | server/instance.go | RegisterAgent | func (srv *Instance) RegisterAgent(ctx context.Context, name string, agent agents.Agent) error {
return srv.agents.RegisterAgent(ctx, name, agent, srv.connector)
} | go | func (srv *Instance) RegisterAgent(ctx context.Context, name string, agent agents.Agent) error {
return srv.agents.RegisterAgent(ctx, name, agent, srv.connector)
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"RegisterAgent",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"agent",
"agents",
".",
"Agent",
")",
"error",
"{",
"return",
"srv",
".",
"agents",
".",
"RegisterAgent",
"(",
"ctx",
",",
"name",
",",
"agent",
",",
"srv",
".",
"connector",
")",
"\n",
"}"
] | // RegisterAgent adds a new agent to the running instance | [
"RegisterAgent",
"adds",
"a",
"new",
"agent",
"to",
"the",
"running",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/instance.go#L139-L141 |
15,871 | choria-io/go-choria | server/instance.go | DenyAgent | func (srv *Instance) DenyAgent(agent string) {
srv.mu.Lock()
defer srv.mu.Unlock()
srv.agentDenyList = append(srv.agentDenyList, agent)
} | go | func (srv *Instance) DenyAgent(agent string) {
srv.mu.Lock()
defer srv.mu.Unlock()
srv.agentDenyList = append(srv.agentDenyList, agent)
} | [
"func",
"(",
"srv",
"*",
"Instance",
")",
"DenyAgent",
"(",
"agent",
"string",
")",
"{",
"srv",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"srv",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"srv",
".",
"agentDenyList",
"=",
"append",
"(",
"srv",
".",
"agentDenyList",
",",
"agent",
")",
"\n",
"}"
] | // DenyAgent prevents an agent from being loaded, if it was already loaded this has no effect | [
"DenyAgent",
"prevents",
"an",
"agent",
"from",
"being",
"loaded",
"if",
"it",
"was",
"already",
"loaded",
"this",
"has",
"no",
"effect"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/instance.go#L144-L149 |
15,872 | choria-io/go-choria | server/discovery/identity/identity.go | Match | func Match(needles []string, certname string) bool {
for _, needle := range needles {
if strings.HasPrefix(needle, "/") && strings.HasSuffix(needle, "/") {
needle = strings.TrimPrefix(needle, "/")
needle = strings.TrimSuffix(needle, "/")
if matched, _ := regexp.MatchString(needle, certname); matched {
return true
}
continue
}
if needle == certname {
return true
}
}
return false
} | go | func Match(needles []string, certname string) bool {
for _, needle := range needles {
if strings.HasPrefix(needle, "/") && strings.HasSuffix(needle, "/") {
needle = strings.TrimPrefix(needle, "/")
needle = strings.TrimSuffix(needle, "/")
if matched, _ := regexp.MatchString(needle, certname); matched {
return true
}
continue
}
if needle == certname {
return true
}
}
return false
} | [
"func",
"Match",
"(",
"needles",
"[",
"]",
"string",
",",
"certname",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"needle",
":=",
"range",
"needles",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"needle",
",",
"\"",
"\"",
")",
"&&",
"strings",
".",
"HasSuffix",
"(",
"needle",
",",
"\"",
"\"",
")",
"{",
"needle",
"=",
"strings",
".",
"TrimPrefix",
"(",
"needle",
",",
"\"",
"\"",
")",
"\n",
"needle",
"=",
"strings",
".",
"TrimSuffix",
"(",
"needle",
",",
"\"",
"\"",
")",
"\n",
"if",
"matched",
",",
"_",
":=",
"regexp",
".",
"MatchString",
"(",
"needle",
",",
"certname",
")",
";",
"matched",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"needle",
"==",
"certname",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // Match identities on a OR basis, since nodes have only 1 identity | [
"Match",
"identities",
"on",
"a",
"OR",
"basis",
"since",
"nodes",
"have",
"only",
"1",
"identity"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/discovery/identity/identity.go#L9-L27 |
15,873 | choria-io/go-choria | choria/protocol.go | NewMessage | func (fw *Framework) NewMessage(payload string, agent string, collective string, msgType string, request *Message) (msg *Message, err error) {
msg, err = NewMessage(payload, agent, collective, msgType, request, fw)
return
} | go | func (fw *Framework) NewMessage(payload string, agent string, collective string, msgType string, request *Message) (msg *Message, err error) {
msg, err = NewMessage(payload, agent, collective, msgType, request, fw)
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewMessage",
"(",
"payload",
"string",
",",
"agent",
"string",
",",
"collective",
"string",
",",
"msgType",
"string",
",",
"request",
"*",
"Message",
")",
"(",
"msg",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"msg",
",",
"err",
"=",
"NewMessage",
"(",
"payload",
",",
"agent",
",",
"collective",
",",
"msgType",
",",
"request",
",",
"fw",
")",
"\n\n",
"return",
"\n",
"}"
] | // NewMessage creates a new Message associated with this Choria instance | [
"NewMessage",
"creates",
"a",
"new",
"Message",
"associated",
"with",
"this",
"Choria",
"instance"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L13-L17 |
15,874 | choria-io/go-choria | choria/protocol.go | NewRequestMessageFromTransportJSON | func (fw *Framework) NewRequestMessageFromTransportJSON(payload []byte) (msg *Message, err error) {
transport, err := fw.NewTransportFromJSON(string(payload))
if err != nil {
return nil, err
}
srequest, err := fw.NewSecureRequestFromTransport(transport, false)
if err != nil {
return nil, err
}
request, err := fw.NewRequestFromSecureRequest(srequest)
if err != nil {
return nil, err
}
protocol.CopyFederationData(transport, request)
msg, err = NewMessageFromRequest(request, transport.ReplyTo(), fw)
if err != nil {
return nil, err
}
return
} | go | func (fw *Framework) NewRequestMessageFromTransportJSON(payload []byte) (msg *Message, err error) {
transport, err := fw.NewTransportFromJSON(string(payload))
if err != nil {
return nil, err
}
srequest, err := fw.NewSecureRequestFromTransport(transport, false)
if err != nil {
return nil, err
}
request, err := fw.NewRequestFromSecureRequest(srequest)
if err != nil {
return nil, err
}
protocol.CopyFederationData(transport, request)
msg, err = NewMessageFromRequest(request, transport.ReplyTo(), fw)
if err != nil {
return nil, err
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewRequestMessageFromTransportJSON",
"(",
"payload",
"[",
"]",
"byte",
")",
"(",
"msg",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"transport",
",",
"err",
":=",
"fw",
".",
"NewTransportFromJSON",
"(",
"string",
"(",
"payload",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"srequest",
",",
"err",
":=",
"fw",
".",
"NewSecureRequestFromTransport",
"(",
"transport",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"request",
",",
"err",
":=",
"fw",
".",
"NewRequestFromSecureRequest",
"(",
"srequest",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"protocol",
".",
"CopyFederationData",
"(",
"transport",
",",
"request",
")",
"\n\n",
"msg",
",",
"err",
"=",
"NewMessageFromRequest",
"(",
"request",
",",
"transport",
".",
"ReplyTo",
"(",
")",
",",
"fw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewRequestMessageFromTransportJSON creates a Message from a Transport JSON that holds a Request | [
"NewRequestMessageFromTransportJSON",
"creates",
"a",
"Message",
"from",
"a",
"Transport",
"JSON",
"that",
"holds",
"a",
"Request"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L20-L44 |
15,875 | choria-io/go-choria | choria/protocol.go | NewReplyFromTransportJSON | func (fw *Framework) NewReplyFromTransportJSON(payload []byte, skipvalidate bool) (msg protocol.Reply, err error) {
transport, err := fw.NewTransportFromJSON(string(payload))
if err != nil {
return nil, err
}
sreply, err := fw.NewSecureReplyFromTransport(transport, skipvalidate)
if err != nil {
return nil, err
}
reply, err := fw.NewReplyFromSecureReply(sreply)
if err != nil {
return nil, err
}
protocol.CopyFederationData(transport, reply)
return reply, nil
} | go | func (fw *Framework) NewReplyFromTransportJSON(payload []byte, skipvalidate bool) (msg protocol.Reply, err error) {
transport, err := fw.NewTransportFromJSON(string(payload))
if err != nil {
return nil, err
}
sreply, err := fw.NewSecureReplyFromTransport(transport, skipvalidate)
if err != nil {
return nil, err
}
reply, err := fw.NewReplyFromSecureReply(sreply)
if err != nil {
return nil, err
}
protocol.CopyFederationData(transport, reply)
return reply, nil
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewReplyFromTransportJSON",
"(",
"payload",
"[",
"]",
"byte",
",",
"skipvalidate",
"bool",
")",
"(",
"msg",
"protocol",
".",
"Reply",
",",
"err",
"error",
")",
"{",
"transport",
",",
"err",
":=",
"fw",
".",
"NewTransportFromJSON",
"(",
"string",
"(",
"payload",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"sreply",
",",
"err",
":=",
"fw",
".",
"NewSecureReplyFromTransport",
"(",
"transport",
",",
"skipvalidate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"reply",
",",
"err",
":=",
"fw",
".",
"NewReplyFromSecureReply",
"(",
"sreply",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"protocol",
".",
"CopyFederationData",
"(",
"transport",
",",
"reply",
")",
"\n\n",
"return",
"reply",
",",
"nil",
"\n",
"}"
] | // NewReplyFromTransportJSON creates a new Reply from a transport JSON | [
"NewReplyFromTransportJSON",
"creates",
"a",
"new",
"Reply",
"from",
"a",
"transport",
"JSON"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L47-L66 |
15,876 | choria-io/go-choria | choria/protocol.go | NewRequestFromTransportJSON | func (fw *Framework) NewRequestFromTransportJSON(payload []byte, skipvalidate bool) (msg protocol.Request, err error) {
transport, err := fw.NewTransportFromJSON(string(payload))
if err != nil {
return nil, err
}
sreq, err := fw.NewSecureRequestFromTransport(transport, skipvalidate)
if err != nil {
return nil, err
}
req, err := fw.NewRequestFromSecureRequest(sreq)
if err != nil {
return nil, err
}
protocol.CopyFederationData(transport, req)
return req, nil
} | go | func (fw *Framework) NewRequestFromTransportJSON(payload []byte, skipvalidate bool) (msg protocol.Request, err error) {
transport, err := fw.NewTransportFromJSON(string(payload))
if err != nil {
return nil, err
}
sreq, err := fw.NewSecureRequestFromTransport(transport, skipvalidate)
if err != nil {
return nil, err
}
req, err := fw.NewRequestFromSecureRequest(sreq)
if err != nil {
return nil, err
}
protocol.CopyFederationData(transport, req)
return req, nil
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewRequestFromTransportJSON",
"(",
"payload",
"[",
"]",
"byte",
",",
"skipvalidate",
"bool",
")",
"(",
"msg",
"protocol",
".",
"Request",
",",
"err",
"error",
")",
"{",
"transport",
",",
"err",
":=",
"fw",
".",
"NewTransportFromJSON",
"(",
"string",
"(",
"payload",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"sreq",
",",
"err",
":=",
"fw",
".",
"NewSecureRequestFromTransport",
"(",
"transport",
",",
"skipvalidate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"fw",
".",
"NewRequestFromSecureRequest",
"(",
"sreq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"protocol",
".",
"CopyFederationData",
"(",
"transport",
",",
"req",
")",
"\n\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] | // NewRequestFromTransportJSON creates a new Request from transport JSON | [
"NewRequestFromTransportJSON",
"creates",
"a",
"new",
"Request",
"from",
"transport",
"JSON"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L69-L88 |
15,877 | choria-io/go-choria | choria/protocol.go | NewRequest | func (fw *Framework) NewRequest(version string, agent string, senderid string, callerid string, ttl int, requestid string, collective string) (request protocol.Request, err error) {
switch version {
case protocol.RequestV1:
request, err = v1.NewRequest(agent, senderid, callerid, ttl, requestid, collective)
default:
err = fmt.Errorf("Do not know how to create a Request version %s", version)
}
return
} | go | func (fw *Framework) NewRequest(version string, agent string, senderid string, callerid string, ttl int, requestid string, collective string) (request protocol.Request, err error) {
switch version {
case protocol.RequestV1:
request, err = v1.NewRequest(agent, senderid, callerid, ttl, requestid, collective)
default:
err = fmt.Errorf("Do not know how to create a Request version %s", version)
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewRequest",
"(",
"version",
"string",
",",
"agent",
"string",
",",
"senderid",
"string",
",",
"callerid",
"string",
",",
"ttl",
"int",
",",
"requestid",
"string",
",",
"collective",
"string",
")",
"(",
"request",
"protocol",
".",
"Request",
",",
"err",
"error",
")",
"{",
"switch",
"version",
"{",
"case",
"protocol",
".",
"RequestV1",
":",
"request",
",",
"err",
"=",
"v1",
".",
"NewRequest",
"(",
"agent",
",",
"senderid",
",",
"callerid",
",",
"ttl",
",",
"requestid",
",",
"collective",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewRequest creates a new Request complying with a specific protocol version like protocol.RequestV1 | [
"NewRequest",
"creates",
"a",
"new",
"Request",
"complying",
"with",
"a",
"specific",
"protocol",
"version",
"like",
"protocol",
".",
"RequestV1"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L91-L100 |
15,878 | choria-io/go-choria | choria/protocol.go | NewRequestFromMessage | func (fw *Framework) NewRequestFromMessage(version string, msg *Message) (req protocol.Request, err error) {
if !(msg.Type() == "request" || msg.Type() == "direct_request") {
err = fmt.Errorf("Cannot use `%s` message to construct a Request", msg.Type())
return
}
req, err = fw.NewRequest(version, msg.Agent, msg.SenderID, msg.CallerID, msg.TTL, msg.RequestID, msg.Collective())
if err != nil {
return req, fmt.Errorf("Could not create a Request from a Message: %s", err)
}
req.SetMessage(msg.Payload)
if msg.Filter == nil || msg.Filter.Empty() {
req.NewFilter()
} else {
req.SetFilter(msg.Filter)
}
return
} | go | func (fw *Framework) NewRequestFromMessage(version string, msg *Message) (req protocol.Request, err error) {
if !(msg.Type() == "request" || msg.Type() == "direct_request") {
err = fmt.Errorf("Cannot use `%s` message to construct a Request", msg.Type())
return
}
req, err = fw.NewRequest(version, msg.Agent, msg.SenderID, msg.CallerID, msg.TTL, msg.RequestID, msg.Collective())
if err != nil {
return req, fmt.Errorf("Could not create a Request from a Message: %s", err)
}
req.SetMessage(msg.Payload)
if msg.Filter == nil || msg.Filter.Empty() {
req.NewFilter()
} else {
req.SetFilter(msg.Filter)
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewRequestFromMessage",
"(",
"version",
"string",
",",
"msg",
"*",
"Message",
")",
"(",
"req",
"protocol",
".",
"Request",
",",
"err",
"error",
")",
"{",
"if",
"!",
"(",
"msg",
".",
"Type",
"(",
")",
"==",
"\"",
"\"",
"||",
"msg",
".",
"Type",
"(",
")",
"==",
"\"",
"\"",
")",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"msg",
".",
"Type",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"req",
",",
"err",
"=",
"fw",
".",
"NewRequest",
"(",
"version",
",",
"msg",
".",
"Agent",
",",
"msg",
".",
"SenderID",
",",
"msg",
".",
"CallerID",
",",
"msg",
".",
"TTL",
",",
"msg",
".",
"RequestID",
",",
"msg",
".",
"Collective",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"req",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"req",
".",
"SetMessage",
"(",
"msg",
".",
"Payload",
")",
"\n\n",
"if",
"msg",
".",
"Filter",
"==",
"nil",
"||",
"msg",
".",
"Filter",
".",
"Empty",
"(",
")",
"{",
"req",
".",
"NewFilter",
"(",
")",
"\n",
"}",
"else",
"{",
"req",
".",
"SetFilter",
"(",
"msg",
".",
"Filter",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewRequestFromMessage creates a new Request with the Message settings preloaded complying with a specific protocol version like protocol.RequestV1 | [
"NewRequestFromMessage",
"creates",
"a",
"new",
"Request",
"with",
"the",
"Message",
"settings",
"preloaded",
"complying",
"with",
"a",
"specific",
"protocol",
"version",
"like",
"protocol",
".",
"RequestV1"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L103-L123 |
15,879 | choria-io/go-choria | choria/protocol.go | NewReply | func (fw *Framework) NewReply(request protocol.Request) (reply protocol.Reply, err error) {
switch request.Version() {
case protocol.RequestV1:
reply, err = v1.NewReply(request, fw.Config.Identity)
default:
err = fmt.Errorf("Do not know how to create a Reply version %s", request.Version())
}
return
} | go | func (fw *Framework) NewReply(request protocol.Request) (reply protocol.Reply, err error) {
switch request.Version() {
case protocol.RequestV1:
reply, err = v1.NewReply(request, fw.Config.Identity)
default:
err = fmt.Errorf("Do not know how to create a Reply version %s", request.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewReply",
"(",
"request",
"protocol",
".",
"Request",
")",
"(",
"reply",
"protocol",
".",
"Reply",
",",
"err",
"error",
")",
"{",
"switch",
"request",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"RequestV1",
":",
"reply",
",",
"err",
"=",
"v1",
".",
"NewReply",
"(",
"request",
",",
"fw",
".",
"Config",
".",
"Identity",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"request",
".",
"Version",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewReply creates a new Reply, the version will match that of the given request | [
"NewReply",
"creates",
"a",
"new",
"Reply",
"the",
"version",
"will",
"match",
"that",
"of",
"the",
"given",
"request"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L126-L135 |
15,880 | choria-io/go-choria | choria/protocol.go | NewReplyFromMessage | func (fw *Framework) NewReplyFromMessage(version string, msg *Message) (rep protocol.Reply, err error) {
if msg.Type() != "reply" {
err = fmt.Errorf("Cannot use `%s` message to construct a Reply", msg.Type())
return
}
if msg.Request == nil {
err = fmt.Errorf("Cannot create a Reply from Messages without Requests")
return
}
req, err := fw.NewRequestFromMessage(version, msg.Request)
if err != nil {
return
}
rep, err = fw.NewReply(req)
rep.SetMessage(msg.Payload)
return
} | go | func (fw *Framework) NewReplyFromMessage(version string, msg *Message) (rep protocol.Reply, err error) {
if msg.Type() != "reply" {
err = fmt.Errorf("Cannot use `%s` message to construct a Reply", msg.Type())
return
}
if msg.Request == nil {
err = fmt.Errorf("Cannot create a Reply from Messages without Requests")
return
}
req, err := fw.NewRequestFromMessage(version, msg.Request)
if err != nil {
return
}
rep, err = fw.NewReply(req)
rep.SetMessage(msg.Payload)
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewReplyFromMessage",
"(",
"version",
"string",
",",
"msg",
"*",
"Message",
")",
"(",
"rep",
"protocol",
".",
"Reply",
",",
"err",
"error",
")",
"{",
"if",
"msg",
".",
"Type",
"(",
")",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"msg",
".",
"Type",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"msg",
".",
"Request",
"==",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"fw",
".",
"NewRequestFromMessage",
"(",
"version",
",",
"msg",
".",
"Request",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"rep",
",",
"err",
"=",
"fw",
".",
"NewReply",
"(",
"req",
")",
"\n",
"rep",
".",
"SetMessage",
"(",
"msg",
".",
"Payload",
")",
"\n\n",
"return",
"\n",
"}"
] | // NewReplyFromMessage creates a new Reply with the Message settings preloaded complying with a specific protocol version like protocol.ReplyV1 | [
"NewReplyFromMessage",
"creates",
"a",
"new",
"Reply",
"with",
"the",
"Message",
"settings",
"preloaded",
"complying",
"with",
"a",
"specific",
"protocol",
"version",
"like",
"protocol",
".",
"ReplyV1"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L138-L158 |
15,881 | choria-io/go-choria | choria/protocol.go | NewReplyFromSecureReply | func (fw *Framework) NewReplyFromSecureReply(sr protocol.SecureReply) (reply protocol.Reply, err error) {
switch sr.Version() {
case protocol.SecureReplyV1:
reply, err = v1.NewReplyFromSecureReply(sr)
default:
err = fmt.Errorf("Do not know how to create a Reply version %s", sr.Version())
}
return
} | go | func (fw *Framework) NewReplyFromSecureReply(sr protocol.SecureReply) (reply protocol.Reply, err error) {
switch sr.Version() {
case protocol.SecureReplyV1:
reply, err = v1.NewReplyFromSecureReply(sr)
default:
err = fmt.Errorf("Do not know how to create a Reply version %s", sr.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewReplyFromSecureReply",
"(",
"sr",
"protocol",
".",
"SecureReply",
")",
"(",
"reply",
"protocol",
".",
"Reply",
",",
"err",
"error",
")",
"{",
"switch",
"sr",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"SecureReplyV1",
":",
"reply",
",",
"err",
"=",
"v1",
".",
"NewReplyFromSecureReply",
"(",
"sr",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sr",
".",
"Version",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewReplyFromSecureReply creates a new Reply from the JSON payload of SecureReply, the version will match what is in the JSON payload | [
"NewReplyFromSecureReply",
"creates",
"a",
"new",
"Reply",
"from",
"the",
"JSON",
"payload",
"of",
"SecureReply",
"the",
"version",
"will",
"match",
"what",
"is",
"in",
"the",
"JSON",
"payload"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L161-L170 |
15,882 | choria-io/go-choria | choria/protocol.go | NewRequestFromSecureRequest | func (fw *Framework) NewRequestFromSecureRequest(sr protocol.SecureRequest) (request protocol.Request, err error) {
switch sr.Version() {
case protocol.SecureRequestV1:
request, err = v1.NewRequestFromSecureRequest(sr)
default:
err = fmt.Errorf("Do not know how to create a Reply version %s", sr.Version())
}
return
} | go | func (fw *Framework) NewRequestFromSecureRequest(sr protocol.SecureRequest) (request protocol.Request, err error) {
switch sr.Version() {
case protocol.SecureRequestV1:
request, err = v1.NewRequestFromSecureRequest(sr)
default:
err = fmt.Errorf("Do not know how to create a Reply version %s", sr.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewRequestFromSecureRequest",
"(",
"sr",
"protocol",
".",
"SecureRequest",
")",
"(",
"request",
"protocol",
".",
"Request",
",",
"err",
"error",
")",
"{",
"switch",
"sr",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"SecureRequestV1",
":",
"request",
",",
"err",
"=",
"v1",
".",
"NewRequestFromSecureRequest",
"(",
"sr",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sr",
".",
"Version",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewRequestFromSecureRequest creates a new Request from a SecureRequest, the version will match what is in the JSON payload | [
"NewRequestFromSecureRequest",
"creates",
"a",
"new",
"Request",
"from",
"a",
"SecureRequest",
"the",
"version",
"will",
"match",
"what",
"is",
"in",
"the",
"JSON",
"payload"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L173-L182 |
15,883 | choria-io/go-choria | choria/protocol.go | NewSecureReply | func (fw *Framework) NewSecureReply(reply protocol.Reply) (secure protocol.SecureReply, err error) {
switch reply.Version() {
case protocol.ReplyV1:
secure, err = v1.NewSecureReply(reply, fw.security)
default:
err = fmt.Errorf("Do not know how to create a SecureReply based on a Reply version %s", reply.Version())
}
return
} | go | func (fw *Framework) NewSecureReply(reply protocol.Reply) (secure protocol.SecureReply, err error) {
switch reply.Version() {
case protocol.ReplyV1:
secure, err = v1.NewSecureReply(reply, fw.security)
default:
err = fmt.Errorf("Do not know how to create a SecureReply based on a Reply version %s", reply.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewSecureReply",
"(",
"reply",
"protocol",
".",
"Reply",
")",
"(",
"secure",
"protocol",
".",
"SecureReply",
",",
"err",
"error",
")",
"{",
"switch",
"reply",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"ReplyV1",
":",
"secure",
",",
"err",
"=",
"v1",
".",
"NewSecureReply",
"(",
"reply",
",",
"fw",
".",
"security",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"reply",
".",
"Version",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewSecureReply creates a new SecureReply with the given Reply message as payload | [
"NewSecureReply",
"creates",
"a",
"new",
"SecureReply",
"with",
"the",
"given",
"Reply",
"message",
"as",
"payload"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L185-L194 |
15,884 | choria-io/go-choria | choria/protocol.go | NewSecureReplyFromTransport | func (fw *Framework) NewSecureReplyFromTransport(message protocol.TransportMessage, skipvalidate bool) (secure protocol.SecureReply, err error) {
switch message.Version() {
case protocol.TransportV1:
secure, err = v1.NewSecureReplyFromTransport(message, fw.security, skipvalidate)
default:
err = fmt.Errorf("Do not know how to create a SecureReply version %s", message.Version())
}
return
} | go | func (fw *Framework) NewSecureReplyFromTransport(message protocol.TransportMessage, skipvalidate bool) (secure protocol.SecureReply, err error) {
switch message.Version() {
case protocol.TransportV1:
secure, err = v1.NewSecureReplyFromTransport(message, fw.security, skipvalidate)
default:
err = fmt.Errorf("Do not know how to create a SecureReply version %s", message.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewSecureReplyFromTransport",
"(",
"message",
"protocol",
".",
"TransportMessage",
",",
"skipvalidate",
"bool",
")",
"(",
"secure",
"protocol",
".",
"SecureReply",
",",
"err",
"error",
")",
"{",
"switch",
"message",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"TransportV1",
":",
"secure",
",",
"err",
"=",
"v1",
".",
"NewSecureReplyFromTransport",
"(",
"message",
",",
"fw",
".",
"security",
",",
"skipvalidate",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"message",
".",
"Version",
"(",
")",
")",
"\n\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewSecureReplyFromTransport creates a new SecureReply from the JSON payload of TransportMessage, the version SecureReply will be the same as the TransportMessage | [
"NewSecureReplyFromTransport",
"creates",
"a",
"new",
"SecureReply",
"from",
"the",
"JSON",
"payload",
"of",
"TransportMessage",
"the",
"version",
"SecureReply",
"will",
"be",
"the",
"same",
"as",
"the",
"TransportMessage"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L197-L207 |
15,885 | choria-io/go-choria | choria/protocol.go | NewSecureRequest | func (fw *Framework) NewSecureRequest(request protocol.Request) (secure protocol.SecureRequest, err error) {
switch request.Version() {
case protocol.RequestV1:
secure, err = v1.NewSecureRequest(request, fw.security)
default:
err = fmt.Errorf("Do not know how to create a SecureReply from a Request with version %s", request.Version())
}
return
} | go | func (fw *Framework) NewSecureRequest(request protocol.Request) (secure protocol.SecureRequest, err error) {
switch request.Version() {
case protocol.RequestV1:
secure, err = v1.NewSecureRequest(request, fw.security)
default:
err = fmt.Errorf("Do not know how to create a SecureReply from a Request with version %s", request.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewSecureRequest",
"(",
"request",
"protocol",
".",
"Request",
")",
"(",
"secure",
"protocol",
".",
"SecureRequest",
",",
"err",
"error",
")",
"{",
"switch",
"request",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"RequestV1",
":",
"secure",
",",
"err",
"=",
"v1",
".",
"NewSecureRequest",
"(",
"request",
",",
"fw",
".",
"security",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"request",
".",
"Version",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewSecureRequest creates a new SecureRequest with the given Request message as payload | [
"NewSecureRequest",
"creates",
"a",
"new",
"SecureRequest",
"with",
"the",
"given",
"Request",
"message",
"as",
"payload"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L210-L219 |
15,886 | choria-io/go-choria | choria/protocol.go | NewTransportForSecureRequest | func (fw *Framework) NewTransportForSecureRequest(request protocol.SecureRequest) (message protocol.TransportMessage, err error) {
switch request.Version() {
case protocol.SecureRequestV1:
message, err = v1.NewTransportMessage(fw.Config.Identity)
if err != nil {
logrus.Errorf("Failed to create transport from secure request: %s", err)
return
}
err = message.SetRequestData(request)
if err != nil {
logrus.Errorf("Failed to create transport from secure request: %s", err)
return
}
default:
err = fmt.Errorf("Do not know how to create a Transport message for SecureRequest version %s", request.Version())
}
return
} | go | func (fw *Framework) NewTransportForSecureRequest(request protocol.SecureRequest) (message protocol.TransportMessage, err error) {
switch request.Version() {
case protocol.SecureRequestV1:
message, err = v1.NewTransportMessage(fw.Config.Identity)
if err != nil {
logrus.Errorf("Failed to create transport from secure request: %s", err)
return
}
err = message.SetRequestData(request)
if err != nil {
logrus.Errorf("Failed to create transport from secure request: %s", err)
return
}
default:
err = fmt.Errorf("Do not know how to create a Transport message for SecureRequest version %s", request.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewTransportForSecureRequest",
"(",
"request",
"protocol",
".",
"SecureRequest",
")",
"(",
"message",
"protocol",
".",
"TransportMessage",
",",
"err",
"error",
")",
"{",
"switch",
"request",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"SecureRequestV1",
":",
"message",
",",
"err",
"=",
"v1",
".",
"NewTransportMessage",
"(",
"fw",
".",
"Config",
".",
"Identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"err",
"=",
"message",
".",
"SetRequestData",
"(",
"request",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"request",
".",
"Version",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewTransportForSecureRequest creates a new TransportMessage with a SecureRequest as payload. The Transport will be the same version as the SecureRequest | [
"NewTransportForSecureRequest",
"creates",
"a",
"new",
"TransportMessage",
"with",
"a",
"SecureRequest",
"as",
"payload",
".",
"The",
"Transport",
"will",
"be",
"the",
"same",
"version",
"as",
"the",
"SecureRequest"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L234-L254 |
15,887 | choria-io/go-choria | choria/protocol.go | NewTransportForSecureReply | func (fw *Framework) NewTransportForSecureReply(reply protocol.SecureReply) (message protocol.TransportMessage, err error) {
switch reply.Version() {
case protocol.SecureReplyV1:
message, err = v1.NewTransportMessage(fw.Config.Identity)
message.SetReplyData(reply)
default:
err = fmt.Errorf("Do not know how to create a Transport message for SecureRequest version %s", reply.Version())
}
return
} | go | func (fw *Framework) NewTransportForSecureReply(reply protocol.SecureReply) (message protocol.TransportMessage, err error) {
switch reply.Version() {
case protocol.SecureReplyV1:
message, err = v1.NewTransportMessage(fw.Config.Identity)
message.SetReplyData(reply)
default:
err = fmt.Errorf("Do not know how to create a Transport message for SecureRequest version %s", reply.Version())
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewTransportForSecureReply",
"(",
"reply",
"protocol",
".",
"SecureReply",
")",
"(",
"message",
"protocol",
".",
"TransportMessage",
",",
"err",
"error",
")",
"{",
"switch",
"reply",
".",
"Version",
"(",
")",
"{",
"case",
"protocol",
".",
"SecureReplyV1",
":",
"message",
",",
"err",
"=",
"v1",
".",
"NewTransportMessage",
"(",
"fw",
".",
"Config",
".",
"Identity",
")",
"\n",
"message",
".",
"SetReplyData",
"(",
"reply",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"reply",
".",
"Version",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewTransportForSecureReply creates a new TransportMessage with a SecureReply as payload. The Transport will be the same version as the SecureRequest | [
"NewTransportForSecureReply",
"creates",
"a",
"new",
"TransportMessage",
"with",
"a",
"SecureReply",
"as",
"payload",
".",
"The",
"Transport",
"will",
"be",
"the",
"same",
"version",
"as",
"the",
"SecureRequest"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L257-L267 |
15,888 | choria-io/go-choria | choria/protocol.go | NewReplyTransportForMessage | func (fw *Framework) NewReplyTransportForMessage(msg *Message, request protocol.Request) (protocol.TransportMessage, error) {
reply, err := fw.NewReply(request)
if err != nil {
return nil, fmt.Errorf("Could not create Reply: %s", err)
}
reply.SetMessage(msg.Payload)
sreply, err := fw.NewSecureReply(reply)
if err != nil {
return nil, fmt.Errorf("Could not create Secure Reply: %s", err)
}
transport, err := fw.NewTransportForSecureReply(sreply)
if err != nil {
return nil, fmt.Errorf("Could not create Transport: %s", err)
}
protocol.CopyFederationData(request, transport)
return transport, nil
} | go | func (fw *Framework) NewReplyTransportForMessage(msg *Message, request protocol.Request) (protocol.TransportMessage, error) {
reply, err := fw.NewReply(request)
if err != nil {
return nil, fmt.Errorf("Could not create Reply: %s", err)
}
reply.SetMessage(msg.Payload)
sreply, err := fw.NewSecureReply(reply)
if err != nil {
return nil, fmt.Errorf("Could not create Secure Reply: %s", err)
}
transport, err := fw.NewTransportForSecureReply(sreply)
if err != nil {
return nil, fmt.Errorf("Could not create Transport: %s", err)
}
protocol.CopyFederationData(request, transport)
return transport, nil
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewReplyTransportForMessage",
"(",
"msg",
"*",
"Message",
",",
"request",
"protocol",
".",
"Request",
")",
"(",
"protocol",
".",
"TransportMessage",
",",
"error",
")",
"{",
"reply",
",",
"err",
":=",
"fw",
".",
"NewReply",
"(",
"request",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"reply",
".",
"SetMessage",
"(",
"msg",
".",
"Payload",
")",
"\n\n",
"sreply",
",",
"err",
":=",
"fw",
".",
"NewSecureReply",
"(",
"reply",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"transport",
",",
"err",
":=",
"fw",
".",
"NewTransportForSecureReply",
"(",
"sreply",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"protocol",
".",
"CopyFederationData",
"(",
"request",
",",
"transport",
")",
"\n\n",
"return",
"transport",
",",
"nil",
"\n",
"}"
] | // NewReplyTransportForMessage creates a new Transport message based on a Message and the request its a reply to
//
// The new transport message will have the same version as the request its based on | [
"NewReplyTransportForMessage",
"creates",
"a",
"new",
"Transport",
"message",
"based",
"on",
"a",
"Message",
"and",
"the",
"request",
"its",
"a",
"reply",
"to",
"The",
"new",
"transport",
"message",
"will",
"have",
"the",
"same",
"version",
"as",
"the",
"request",
"its",
"based",
"on"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L272-L293 |
15,889 | choria-io/go-choria | choria/protocol.go | NewRequestTransportForMessage | func (fw *Framework) NewRequestTransportForMessage(msg *Message, version string) (protocol.TransportMessage, error) {
req, err := fw.NewRequestFromMessage(version, msg)
if err != nil {
return nil, fmt.Errorf("Could not create Request: %s", err)
}
sr, err := fw.NewSecureRequest(req)
if err != nil {
return nil, fmt.Errorf("Could not create Secure Request: %s", err)
}
transport, err := fw.NewTransportForSecureRequest(sr)
if err != nil {
return nil, fmt.Errorf("Could not create Transport: %s", err)
}
return transport, nil
} | go | func (fw *Framework) NewRequestTransportForMessage(msg *Message, version string) (protocol.TransportMessage, error) {
req, err := fw.NewRequestFromMessage(version, msg)
if err != nil {
return nil, fmt.Errorf("Could not create Request: %s", err)
}
sr, err := fw.NewSecureRequest(req)
if err != nil {
return nil, fmt.Errorf("Could not create Secure Request: %s", err)
}
transport, err := fw.NewTransportForSecureRequest(sr)
if err != nil {
return nil, fmt.Errorf("Could not create Transport: %s", err)
}
return transport, nil
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewRequestTransportForMessage",
"(",
"msg",
"*",
"Message",
",",
"version",
"string",
")",
"(",
"protocol",
".",
"TransportMessage",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"fw",
".",
"NewRequestFromMessage",
"(",
"version",
",",
"msg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"sr",
",",
"err",
":=",
"fw",
".",
"NewSecureRequest",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"transport",
",",
"err",
":=",
"fw",
".",
"NewTransportForSecureRequest",
"(",
"sr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"transport",
",",
"nil",
"\n",
"}"
] | // NewRequestTransportForMessage creates a new versioned Transport message based on a Message | [
"NewRequestTransportForMessage",
"creates",
"a",
"new",
"versioned",
"Transport",
"message",
"based",
"on",
"a",
"Message"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L296-L313 |
15,890 | choria-io/go-choria | choria/protocol.go | NewTransportMessage | func (fw *Framework) NewTransportMessage(version string) (message protocol.TransportMessage, err error) {
switch version {
case protocol.TransportV1:
message, err = v1.NewTransportMessage(fw.Config.Identity)
default:
err = fmt.Errorf("Do not know how to create a Transport version '%s'", version)
}
return
} | go | func (fw *Framework) NewTransportMessage(version string) (message protocol.TransportMessage, err error) {
switch version {
case protocol.TransportV1:
message, err = v1.NewTransportMessage(fw.Config.Identity)
default:
err = fmt.Errorf("Do not know how to create a Transport version '%s'", version)
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewTransportMessage",
"(",
"version",
"string",
")",
"(",
"message",
"protocol",
".",
"TransportMessage",
",",
"err",
"error",
")",
"{",
"switch",
"version",
"{",
"case",
"protocol",
".",
"TransportV1",
":",
"message",
",",
"err",
"=",
"v1",
".",
"NewTransportMessage",
"(",
"fw",
".",
"Config",
".",
"Identity",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewTransportMessage creates a new TransportMessage complying with a specific protocol version like protocol.TransportV1 | [
"NewTransportMessage",
"creates",
"a",
"new",
"TransportMessage",
"complying",
"with",
"a",
"specific",
"protocol",
"version",
"like",
"protocol",
".",
"TransportV1"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L316-L325 |
15,891 | choria-io/go-choria | choria/protocol.go | NewTransportFromJSON | func (fw *Framework) NewTransportFromJSON(data string) (message protocol.TransportMessage, err error) {
version := gjson.Get(data, "protocol").String()
switch version {
case protocol.TransportV1:
message, err = v1.NewTransportFromJSON(data)
default:
err = fmt.Errorf("Do not know how to create a TransportMessage from an expected JSON format message with content: %s", data)
}
return
} | go | func (fw *Framework) NewTransportFromJSON(data string) (message protocol.TransportMessage, err error) {
version := gjson.Get(data, "protocol").String()
switch version {
case protocol.TransportV1:
message, err = v1.NewTransportFromJSON(data)
default:
err = fmt.Errorf("Do not know how to create a TransportMessage from an expected JSON format message with content: %s", data)
}
return
} | [
"func",
"(",
"fw",
"*",
"Framework",
")",
"NewTransportFromJSON",
"(",
"data",
"string",
")",
"(",
"message",
"protocol",
".",
"TransportMessage",
",",
"err",
"error",
")",
"{",
"version",
":=",
"gjson",
".",
"Get",
"(",
"data",
",",
"\"",
"\"",
")",
".",
"String",
"(",
")",
"\n\n",
"switch",
"version",
"{",
"case",
"protocol",
".",
"TransportV1",
":",
"message",
",",
"err",
"=",
"v1",
".",
"NewTransportFromJSON",
"(",
"data",
")",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"data",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewTransportFromJSON creates a new TransportMessage from a JSON payload. The version will match what is in the payload | [
"NewTransportFromJSON",
"creates",
"a",
"new",
"TransportMessage",
"from",
"a",
"JSON",
"payload",
".",
"The",
"version",
"will",
"match",
"what",
"is",
"in",
"the",
"payload"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/choria/protocol.go#L328-L339 |
15,892 | choria-io/go-choria | build/build.go | MaxBrokerClients | func MaxBrokerClients() int {
c, err := strconv.Atoi(maxBrokerClients)
if err != nil {
return 50000
}
return c
} | go | func MaxBrokerClients() int {
c, err := strconv.Atoi(maxBrokerClients)
if err != nil {
return 50000
}
return c
} | [
"func",
"MaxBrokerClients",
"(",
")",
"int",
"{",
"c",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"maxBrokerClients",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"50000",
"\n",
"}",
"\n\n",
"return",
"c",
"\n",
"}"
] | // MaxBrokerClients is the maximum number of clients the network broker may handle | [
"MaxBrokerClients",
"is",
"the",
"maximum",
"number",
"of",
"clients",
"the",
"network",
"broker",
"may",
"handle"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/build/build.go#L61-L68 |
15,893 | choria-io/go-choria | aagent/watchers/watchers.go | SetMachine | func (m *Manager) SetMachine(t interface{}) (err error) {
machine, ok := t.(Machine)
if !ok {
return errors.New("supplied machine does not implement watchers.Machine")
}
m.machine = machine
return nil
} | go | func (m *Manager) SetMachine(t interface{}) (err error) {
machine, ok := t.(Machine)
if !ok {
return errors.New("supplied machine does not implement watchers.Machine")
}
m.machine = machine
return nil
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"SetMachine",
"(",
"t",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"machine",
",",
"ok",
":=",
"t",
".",
"(",
"Machine",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
".",
"machine",
"=",
"machine",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // SetMachine supplies the machine this manager will manage | [
"SetMachine",
"supplies",
"the",
"machine",
"this",
"manager",
"will",
"manage"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/watchers/watchers.go#L65-L74 |
15,894 | choria-io/go-choria | aagent/watchers/watchers.go | AddWatcher | func (m *Manager) AddWatcher(w Watcher) error {
m.Lock()
defer m.Unlock()
_, ok := m.watchers[w.Name()]
if ok {
m.machine.Errorf("manager", "Already have a watcher %s", w.Name())
return fmt.Errorf("watcher %s already exist", w.Name())
}
m.watchers[w.Name()] = w
return nil
} | go | func (m *Manager) AddWatcher(w Watcher) error {
m.Lock()
defer m.Unlock()
_, ok := m.watchers[w.Name()]
if ok {
m.machine.Errorf("manager", "Already have a watcher %s", w.Name())
return fmt.Errorf("watcher %s already exist", w.Name())
}
m.watchers[w.Name()] = w
return nil
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"AddWatcher",
"(",
"w",
"Watcher",
")",
"error",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"_",
",",
"ok",
":=",
"m",
".",
"watchers",
"[",
"w",
".",
"Name",
"(",
")",
"]",
"\n",
"if",
"ok",
"{",
"m",
".",
"machine",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"w",
".",
"Name",
"(",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"w",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n\n",
"m",
".",
"watchers",
"[",
"w",
".",
"Name",
"(",
")",
"]",
"=",
"w",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // AddWatcher adds a watcher to a managed machine | [
"AddWatcher",
"adds",
"a",
"watcher",
"to",
"a",
"managed",
"machine"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/watchers/watchers.go#L77-L90 |
15,895 | choria-io/go-choria | aagent/watchers/watchers.go | Run | func (m *Manager) Run(ctx context.Context, wg *sync.WaitGroup) error {
if m.machine == nil {
return fmt.Errorf("manager requires a machine to manage")
}
err := m.configureWatchers()
if err != nil {
return errors.Wrap(err, "could not configure watchers")
}
for _, watcher := range m.watchers {
wg.Add(1)
go watcher.Run(ctx, wg)
if watcher.AnnounceInterval() > 0 {
wg.Add(1)
go m.announceWatcherState(ctx, wg, watcher)
}
}
return nil
} | go | func (m *Manager) Run(ctx context.Context, wg *sync.WaitGroup) error {
if m.machine == nil {
return fmt.Errorf("manager requires a machine to manage")
}
err := m.configureWatchers()
if err != nil {
return errors.Wrap(err, "could not configure watchers")
}
for _, watcher := range m.watchers {
wg.Add(1)
go watcher.Run(ctx, wg)
if watcher.AnnounceInterval() > 0 {
wg.Add(1)
go m.announceWatcherState(ctx, wg, watcher)
}
}
return nil
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"wg",
"*",
"sync",
".",
"WaitGroup",
")",
"error",
"{",
"if",
"m",
".",
"machine",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"m",
".",
"configureWatchers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"watcher",
":=",
"range",
"m",
".",
"watchers",
"{",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"watcher",
".",
"Run",
"(",
"ctx",
",",
"wg",
")",
"\n\n",
"if",
"watcher",
".",
"AnnounceInterval",
"(",
")",
">",
"0",
"{",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"m",
".",
"announceWatcherState",
"(",
"ctx",
",",
"wg",
",",
"watcher",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Run starts all the defined watchers and periodically announce
// their state based on AnnounceInterval | [
"Run",
"starts",
"all",
"the",
"defined",
"watchers",
"and",
"periodically",
"announce",
"their",
"state",
"based",
"on",
"AnnounceInterval"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/watchers/watchers.go#L130-L151 |
15,896 | choria-io/go-choria | aagent/watchers/watchers.go | NotifyStateChance | func (m *Manager) NotifyStateChance() {
m.Lock()
defer m.Unlock()
for _, watcher := range m.watchers {
watcher.NotifyStateChance()
}
} | go | func (m *Manager) NotifyStateChance() {
m.Lock()
defer m.Unlock()
for _, watcher := range m.watchers {
watcher.NotifyStateChance()
}
} | [
"func",
"(",
"m",
"*",
"Manager",
")",
"NotifyStateChance",
"(",
")",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"watcher",
":=",
"range",
"m",
".",
"watchers",
"{",
"watcher",
".",
"NotifyStateChance",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // NotifyStateChance implements machine.WatcherManager | [
"NotifyStateChance",
"implements",
"machine",
".",
"WatcherManager"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/aagent/watchers/watchers.go#L170-L177 |
15,897 | choria-io/go-choria | server/agent_providers.go | RegisterAdditionalAgentProvider | func RegisterAdditionalAgentProvider(p AgentProvider) {
aapmu.Lock()
defer aapmu.Unlock()
additionalAgentProviders = append(additionalAgentProviders, p)
build.AgentProviders = append(build.AgentProviders, p.Version())
} | go | func RegisterAdditionalAgentProvider(p AgentProvider) {
aapmu.Lock()
defer aapmu.Unlock()
additionalAgentProviders = append(additionalAgentProviders, p)
build.AgentProviders = append(build.AgentProviders, p.Version())
} | [
"func",
"RegisterAdditionalAgentProvider",
"(",
"p",
"AgentProvider",
")",
"{",
"aapmu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"aapmu",
".",
"Unlock",
"(",
")",
"\n\n",
"additionalAgentProviders",
"=",
"append",
"(",
"additionalAgentProviders",
",",
"p",
")",
"\n",
"build",
".",
"AgentProviders",
"=",
"append",
"(",
"build",
".",
"AgentProviders",
",",
"p",
".",
"Version",
"(",
")",
")",
"\n",
"}"
] | // RegisterAdditionalAgentProvider registers an agent provider as a subsystem
// capable of delivering new types of agent like the legacy mcollective ruby compatible
// ones
//
// Custom builders can use this to extend choria with new agent capabilities | [
"RegisterAdditionalAgentProvider",
"registers",
"an",
"agent",
"provider",
"as",
"a",
"subsystem",
"capable",
"of",
"delivering",
"new",
"types",
"of",
"agent",
"like",
"the",
"legacy",
"mcollective",
"ruby",
"compatible",
"ones",
"Custom",
"builders",
"can",
"use",
"this",
"to",
"extend",
"choria",
"with",
"new",
"agent",
"capabilities"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/server/agent_providers.go#L32-L38 |
15,898 | choria-io/go-choria | srvcache/srvcache.go | LookupSRV | func LookupSRV(service string, proto string, name string, resolver func(string, string, string) (string, []*net.SRV, error)) (string, []*net.SRV, error) {
mu.Lock()
defer mu.Unlock()
var err error
q := query{service, proto, name}
cname, addrs := retrieve(q)
if addrs == nil {
cname, addrs, err = resolver("", "", name)
}
store(q, cname, addrs)
srvctr.WithLabelValues(identity).Inc()
return cname, addrs, err
} | go | func LookupSRV(service string, proto string, name string, resolver func(string, string, string) (string, []*net.SRV, error)) (string, []*net.SRV, error) {
mu.Lock()
defer mu.Unlock()
var err error
q := query{service, proto, name}
cname, addrs := retrieve(q)
if addrs == nil {
cname, addrs, err = resolver("", "", name)
}
store(q, cname, addrs)
srvctr.WithLabelValues(identity).Inc()
return cname, addrs, err
} | [
"func",
"LookupSRV",
"(",
"service",
"string",
",",
"proto",
"string",
",",
"name",
"string",
",",
"resolver",
"func",
"(",
"string",
",",
"string",
",",
"string",
")",
"(",
"string",
",",
"[",
"]",
"*",
"net",
".",
"SRV",
",",
"error",
")",
")",
"(",
"string",
",",
"[",
"]",
"*",
"net",
".",
"SRV",
",",
"error",
")",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"err",
"error",
"\n\n",
"q",
":=",
"query",
"{",
"service",
",",
"proto",
",",
"name",
"}",
"\n\n",
"cname",
",",
"addrs",
":=",
"retrieve",
"(",
"q",
")",
"\n",
"if",
"addrs",
"==",
"nil",
"{",
"cname",
",",
"addrs",
",",
"err",
"=",
"resolver",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n\n",
"store",
"(",
"q",
",",
"cname",
",",
"addrs",
")",
"\n\n",
"srvctr",
".",
"WithLabelValues",
"(",
"identity",
")",
".",
"Inc",
"(",
")",
"\n\n",
"return",
"cname",
",",
"addrs",
",",
"err",
"\n",
"}"
] | // LookupSRV is a wrapper around net.LookupSRV that does a 5 second cache | [
"LookupSRV",
"is",
"a",
"wrapper",
"around",
"net",
".",
"LookupSRV",
"that",
"does",
"a",
"5",
"second",
"cache"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/srvcache/srvcache.go#L28-L46 |
15,899 | choria-io/go-choria | statistics/stats.go | Start | func Start(config *config.Config, handler http.Handler) {
mu.Lock()
defer mu.Unlock()
cfg = config
port := config.Choria.StatsPort
if port == 0 {
log.Infof("Statistics gathering disabled, set plugin.choria.stats_port")
return
}
prometheus.MustRegister(buildInfo)
buildInfo.WithLabelValues(build.Version, build.SHA).Inc()
if !running {
log.Infof("Starting statistic reporting Prometheus statistics on http://%s:%d/choria/", config.Choria.StatsListenAddress, port)
if handler == nil {
http.HandleFunc("/choria/", handleRoot)
http.Handle("/choria/prometheus", promhttp.Handler())
go http.ListenAndServe(fmt.Sprintf("%s:%d", config.Choria.StatsListenAddress, port), nil)
} else {
hh := handler.(*http.ServeMux)
hh.HandleFunc("/choria/", handleRoot)
hh.Handle("/choria/prometheus", promhttp.Handler())
}
running = true
}
} | go | func Start(config *config.Config, handler http.Handler) {
mu.Lock()
defer mu.Unlock()
cfg = config
port := config.Choria.StatsPort
if port == 0 {
log.Infof("Statistics gathering disabled, set plugin.choria.stats_port")
return
}
prometheus.MustRegister(buildInfo)
buildInfo.WithLabelValues(build.Version, build.SHA).Inc()
if !running {
log.Infof("Starting statistic reporting Prometheus statistics on http://%s:%d/choria/", config.Choria.StatsListenAddress, port)
if handler == nil {
http.HandleFunc("/choria/", handleRoot)
http.Handle("/choria/prometheus", promhttp.Handler())
go http.ListenAndServe(fmt.Sprintf("%s:%d", config.Choria.StatsListenAddress, port), nil)
} else {
hh := handler.(*http.ServeMux)
hh.HandleFunc("/choria/", handleRoot)
hh.Handle("/choria/prometheus", promhttp.Handler())
}
running = true
}
} | [
"func",
"Start",
"(",
"config",
"*",
"config",
".",
"Config",
",",
"handler",
"http",
".",
"Handler",
")",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"cfg",
"=",
"config",
"\n",
"port",
":=",
"config",
".",
"Choria",
".",
"StatsPort",
"\n\n",
"if",
"port",
"==",
"0",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"prometheus",
".",
"MustRegister",
"(",
"buildInfo",
")",
"\n",
"buildInfo",
".",
"WithLabelValues",
"(",
"build",
".",
"Version",
",",
"build",
".",
"SHA",
")",
".",
"Inc",
"(",
")",
"\n\n",
"if",
"!",
"running",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"config",
".",
"Choria",
".",
"StatsListenAddress",
",",
"port",
")",
"\n\n",
"if",
"handler",
"==",
"nil",
"{",
"http",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"handleRoot",
")",
"\n",
"http",
".",
"Handle",
"(",
"\"",
"\"",
",",
"promhttp",
".",
"Handler",
"(",
")",
")",
"\n\n",
"go",
"http",
".",
"ListenAndServe",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"config",
".",
"Choria",
".",
"StatsListenAddress",
",",
"port",
")",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"hh",
":=",
"handler",
".",
"(",
"*",
"http",
".",
"ServeMux",
")",
"\n",
"hh",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"handleRoot",
")",
"\n",
"hh",
".",
"Handle",
"(",
"\"",
"\"",
",",
"promhttp",
".",
"Handler",
"(",
")",
")",
"\n",
"}",
"\n\n",
"running",
"=",
"true",
"\n",
"}",
"\n",
"}"
] | // Start starts serving exp stats and metrics on the configured statistics port | [
"Start",
"starts",
"serving",
"exp",
"stats",
"and",
"metrics",
"on",
"the",
"configured",
"statistics",
"port"
] | 2c773ed36498f426852fd294ebb832c6a2625eba | https://github.com/choria-io/go-choria/blob/2c773ed36498f426852fd294ebb832c6a2625eba/statistics/stats.go#L55-L86 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.