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