Datasets:

---

semeru

/

code-text-go

like 2

Follow

Semeru Lab 7

[ "func", "(", "api", "*", "Client", ")", "PostMessageContext", "(", "ctx", "context", ".", "Context", ",", "channelID", "string", ",", "options", "...", "MsgOption", ")", "(", "string", ",", "string", ",", "error", ")", "{", "respChannel", ",", "respTimestamp", ",", "_", ",", "err", ":=", "api", ".", "SendMessageContext", "(", "ctx", ",", "channelID", ",", "MsgOptionPost", "(", ")", ",", "MsgOptionCompose", "(", "options", "...", ")", ",", ")", "\n", "return", "respChannel", ",", "respTimestamp", ",", "err", "\n", "}" ]

[ "PostMessageContext", "sends", "a", "message", "to", "a", "channel", "with", "a", "custom", "context", "For", "more", "details", "see", "PostMessage", "documentation", "." ]

[ "func", "(", "api", "*", "Client", ")", "PostEphemeralContext", "(", "ctx", "context", ".", "Context", ",", "channelID", ",", "userID", "string", ",", "options", "...", "MsgOption", ")", "(", "timestamp", "string", ",", "err", "error", ")", "{", "_", ",", "timestamp", ",", "_", ",", "err", "=", "api", ".", "SendMessageContext", "(", "ctx", ",", "channelID", ",", "MsgOptionPostEphemeral", "(", "userID", ")", ",", "MsgOptionCompose", "(", "options", "...", ")", ")", "\n", "return", "timestamp", ",", "err", "\n", "}" ]

[ "PostEphemeralContext", "sends", "an", "ephemeal", "message", "to", "a", "user", "in", "a", "channel", "with", "a", "custom", "context", "For", "more", "details", "see", "PostEphemeral", "documentation" ]

[ "func", "(", "api", "*", "Client", ")", "UpdateMessage", "(", "channelID", ",", "timestamp", "string", ",", "options", "...", "MsgOption", ")", "(", "string", ",", "string", ",", "string", ",", "error", ")", "{", "return", "api", ".", "SendMessageContext", "(", "context", ".", "Background", "(", ")", ",", "channelID", ",", "MsgOptionUpdate", "(", "timestamp", ")", ",", "MsgOptionCompose", "(", "options", "...", ")", ")", "\n", "}" ]

[ "UpdateMessage", "updates", "a", "message", "in", "a", "channel" ]

[ "func", "(", "api", "*", "Client", ")", "UpdateMessageContext", "(", "ctx", "context", ".", "Context", ",", "channelID", ",", "timestamp", "string", ",", "options", "...", "MsgOption", ")", "(", "string", ",", "string", ",", "string", ",", "error", ")", "{", "return", "api", ".", "SendMessageContext", "(", "ctx", ",", "channelID", ",", "MsgOptionUpdate", "(", "timestamp", ")", ",", "MsgOptionCompose", "(", "options", "...", ")", ")", "\n", "}" ]

[ "UpdateMessageContext", "updates", "a", "message", "in", "a", "channel" ]

[ "func", "(", "api", "*", "Client", ")", "UnfurlMessage", "(", "channelID", ",", "timestamp", "string", ",", "unfurls", "map", "[", "string", "]", "Attachment", ",", "options", "...", "MsgOption", ")", "(", "string", ",", "string", ",", "string", ",", "error", ")", "{", "return", "api", ".", "SendMessageContext", "(", "context", ".", "Background", "(", ")", ",", "channelID", ",", "MsgOptionUnfurl", "(", "timestamp", ",", "unfurls", ")", ",", "MsgOptionCompose", "(", "options", "...", ")", ")", "\n", "}" ]

[ "UnfurlMessage", "unfurls", "a", "message", "in", "a", "channel" ]

[ "func", "(", "api", "*", "Client", ")", "SendMessage", "(", "channel", "string", ",", "options", "...", "MsgOption", ")", "(", "string", ",", "string", ",", "string", ",", "error", ")", "{", "return", "api", ".", "SendMessageContext", "(", "context", ".", "Background", "(", ")", ",", "channel", ",", "options", "...", ")", "\n", "}" ]

[ "SendMessage", "more", "flexible", "method", "for", "configuring", "messages", "." ]

[ "func", "(", "api", "*", "Client", ")", "SendMessageContext", "(", "ctx", "context", ".", "Context", ",", "channelID", "string", ",", "options", "...", "MsgOption", ")", "(", "channel", "string", ",", "timestamp", "string", ",", "text", "string", ",", "err", "error", ")", "{", "var", "(", "config", "sendConfig", "\n", "response", "chatResponseFull", "\n", ")", "\n\n", "if", "config", ",", "err", "=", "applyMsgOptions", "(", "api", ".", "token", ",", "channelID", ",", "api", ".", "endpoint", ",", "options", "...", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "err", "=", "postForm", "(", "ctx", ",", "api", ".", "httpclient", ",", "config", ".", "endpoint", ",", "config", ".", "values", ",", "&", "response", ",", "api", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "response", ".", "Channel", ",", "response", ".", "getMessageTimestamp", "(", ")", ",", "response", ".", "Text", ",", "response", ".", "Err", "(", ")", "\n", "}" ]

[ "SendMessageContext", "more", "flexible", "method", "for", "configuring", "messages", "with", "a", "custom", "context", "." ]

[ "func", "MsgOptionPost", "(", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "endpoint", "=", "config", ".", "apiurl", "+", "string", "(", "chatPostMessage", ")", "\n", "config", ".", "values", ".", "Del", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionPost", "posts", "a", "messages", "this", "is", "the", "default", "." ]

[ "func", "MsgOptionPostEphemeral", "(", "userID", "string", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "endpoint", "=", "config", ".", "apiurl", "+", "string", "(", "chatPostEphemeral", ")", "\n", "MsgOptionUser", "(", "userID", ")", "(", "config", ")", "\n", "config", ".", "values", ".", "Del", "(", "\"", "\"", ")", "\n\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionPostEphemeral", "-", "posts", "an", "ephemeral", "message", "to", "the", "provided", "user", "." ]

[ "func", "MsgOptionMeMessage", "(", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "endpoint", "=", "config", ".", "apiurl", "+", "string", "(", "chatMeMessage", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionMeMessage", "posts", "a", "me", "message", "type", "from", "the", "calling", "user" ]

[ "func", "MsgOptionUpdate", "(", "timestamp", "string", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "endpoint", "=", "config", ".", "apiurl", "+", "string", "(", "chatUpdate", ")", "\n", "config", ".", "values", ".", "Add", "(", "\"", "\"", ",", "timestamp", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionUpdate", "updates", "a", "message", "based", "on", "the", "timestamp", "." ]

[ "func", "MsgOptionDelete", "(", "timestamp", "string", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "endpoint", "=", "config", ".", "apiurl", "+", "string", "(", "chatDelete", ")", "\n", "config", ".", "values", ".", "Add", "(", "\"", "\"", ",", "timestamp", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionDelete", "deletes", "a", "message", "based", "on", "the", "timestamp", "." ]

[ "func", "MsgOptionUnfurl", "(", "timestamp", "string", ",", "unfurls", "map", "[", "string", "]", "Attachment", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "endpoint", "=", "config", ".", "apiurl", "+", "string", "(", "chatUnfurl", ")", "\n", "config", ".", "values", ".", "Add", "(", "\"", "\"", ",", "timestamp", ")", "\n", "unfurlsStr", ",", "err", ":=", "json", ".", "Marshal", "(", "unfurls", ")", "\n", "if", "err", "==", "nil", "{", "config", ".", "values", ".", "Add", "(", "\"", "\"", ",", "string", "(", "unfurlsStr", ")", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "}" ]

[ "MsgOptionUnfurl", "unfurls", "a", "message", "based", "on", "the", "timestamp", "." ]

[ "func", "MsgOptionAsUser", "(", "b", "bool", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "if", "b", "!=", "DEFAULT_MESSAGE_ASUSER", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionAsUser", "whether", "or", "not", "to", "send", "the", "message", "as", "the", "user", "." ]

[ "func", "MsgOptionUser", "(", "userID", "string", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "userID", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionUser", "set", "the", "user", "for", "the", "message", "." ]

[ "func", "MsgOptionUsername", "(", "username", "string", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "username", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionUsername", "set", "the", "username", "for", "the", "message", "." ]

[ "func", "MsgOptionText", "(", "text", "string", ",", "escape", "bool", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "if", "escape", "{", "text", "=", "slackutilsx", ".", "EscapeMessage", "(", "text", ")", "\n", "}", "\n", "config", ".", "values", ".", "Add", "(", "\"", "\"", ",", "text", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionText", "provide", "the", "text", "for", "the", "message", "optionally", "escape", "the", "provided", "text", "." ]

[ "func", "MsgOptionAttachments", "(", "attachments", "...", "Attachment", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "if", "attachments", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "attachments", ",", "err", ":=", "json", ".", "Marshal", "(", "attachments", ")", "\n", "if", "err", "==", "nil", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "string", "(", "attachments", ")", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "}" ]

[ "MsgOptionAttachments", "provide", "attachments", "for", "the", "message", "." ]

[ "func", "MsgOptionBlocks", "(", "blocks", "...", "Block", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "if", "blocks", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "blocks", ",", "err", ":=", "json", ".", "Marshal", "(", "blocks", ")", "\n", "if", "err", "==", "nil", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "string", "(", "blocks", ")", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "}" ]

[ "MsgOptionBlocks", "sets", "blocks", "for", "the", "message" ]

[ "func", "MsgOptionTS", "(", "ts", "string", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "ts", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionTS", "sets", "the", "thread", "TS", "of", "the", "message", "to", "enable", "creating", "or", "replying", "to", "a", "thread" ]

[ "func", "MsgOptionCompose", "(", "options", "...", "MsgOption", ")", "MsgOption", "{", "return", "func", "(", "c", "*", "sendConfig", ")", "error", "{", "for", "_", ",", "opt", ":=", "range", "options", "{", "if", "err", ":=", "opt", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionCompose", "combines", "multiple", "options", "into", "a", "single", "option", "." ]

[ "func", "MsgOptionParse", "(", "b", "bool", ")", "MsgOption", "{", "return", "func", "(", "c", "*", "sendConfig", ")", "error", "{", "var", "v", "string", "\n", "if", "b", "{", "v", "=", "\"", "\"", "\n", "}", "else", "{", "v", "=", "\"", "\"", "\n", "}", "\n", "c", ".", "values", ".", "Set", "(", "\"", "\"", ",", "v", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionParse", "set", "parse", "option", "." ]

[ "func", "MsgOptionIconURL", "(", "iconURL", "string", ")", "MsgOption", "{", "return", "func", "(", "c", "*", "sendConfig", ")", "error", "{", "c", ".", "values", ".", "Set", "(", "\"", "\"", ",", "iconURL", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionIconURL", "sets", "an", "icon", "URL" ]

[ "func", "MsgOptionIconEmoji", "(", "iconEmoji", "string", ")", "MsgOption", "{", "return", "func", "(", "c", "*", "sendConfig", ")", "error", "{", "c", ".", "values", ".", "Set", "(", "\"", "\"", ",", "iconEmoji", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionIconEmoji", "sets", "an", "icon", "emoji" ]

[ "func", "MsgOptionPostMessageParameters", "(", "params", "PostMessageParameters", ")", "MsgOption", "{", "return", "func", "(", "config", "*", "sendConfig", ")", "error", "{", "if", "params", ".", "Username", "!=", "DEFAULT_MESSAGE_USERNAME", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "params", ".", "Username", ")", "\n", "}", "\n\n", "// chat.postEphemeral support", "if", "params", ".", "User", "!=", "DEFAULT_MESSAGE_USERNAME", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "params", ".", "User", ")", "\n", "}", "\n\n", "// never generates an error.", "MsgOptionAsUser", "(", "params", ".", "AsUser", ")", "(", "config", ")", "\n\n", "if", "params", ".", "Parse", "!=", "DEFAULT_MESSAGE_PARSE", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "params", ".", "Parse", ")", "\n", "}", "\n", "if", "params", ".", "LinkNames", "!=", "DEFAULT_MESSAGE_LINK_NAMES", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "params", ".", "UnfurlLinks", "!=", "DEFAULT_MESSAGE_UNFURL_LINKS", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// I want to send a message with explicit `as_user` `true` and `unfurl_links` `false` in request.", "// Because setting `as_user` to `true` will change the default value for `unfurl_links` to `true` on Slack API side.", "if", "params", ".", "AsUser", "!=", "DEFAULT_MESSAGE_ASUSER", "&&", "params", ".", "UnfurlLinks", "==", "DEFAULT_MESSAGE_UNFURL_LINKS", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "params", ".", "UnfurlMedia", "!=", "DEFAULT_MESSAGE_UNFURL_MEDIA", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "params", ".", "IconURL", "!=", "DEFAULT_MESSAGE_ICON_URL", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "params", ".", "IconURL", ")", "\n", "}", "\n", "if", "params", ".", "IconEmoji", "!=", "DEFAULT_MESSAGE_ICON_EMOJI", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "params", ".", "IconEmoji", ")", "\n", "}", "\n", "if", "params", ".", "Markdown", "!=", "DEFAULT_MESSAGE_MARKDOWN", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "params", ".", "ThreadTimestamp", "!=", "DEFAULT_MESSAGE_THREAD_TIMESTAMP", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "params", ".", "ThreadTimestamp", ")", "\n", "}", "\n", "if", "params", ".", "ReplyBroadcast", "!=", "DEFAULT_MESSAGE_REPLY_BROADCAST", "{", "config", ".", "values", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "MsgOptionPostMessageParameters", "maintain", "backwards", "compatibility", "." ]

[ "func", "(", "api", "*", "Client", ")", "GetPermalink", "(", "params", "*", "PermalinkParameters", ")", "(", "string", ",", "error", ")", "{", "return", "api", ".", "GetPermalinkContext", "(", "context", ".", "Background", "(", ")", ",", "params", ")", "\n", "}" ]

[ "GetPermalink", "returns", "the", "permalink", "for", "a", "message", ".", "It", "takes", "PermalinkParameters", "and", "returns", "a", "string", "containing", "the", "permalink", ".", "It", "returns", "an", "error", "if", "unable", "to", "retrieve", "the", "permalink", "." ]

[ "func", "(", "api", "*", "Client", ")", "GetPermalinkContext", "(", "ctx", "context", ".", "Context", ",", "params", "*", "PermalinkParameters", ")", "(", "string", ",", "error", ")", "{", "values", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "api", ".", "token", "}", ",", "\"", "\"", ":", "{", "params", ".", "Channel", "}", ",", "\"", "\"", ":", "{", "params", ".", "Ts", "}", ",", "}", "\n\n", "response", ":=", "struct", "{", "Channel", "string", "`json:\"channel\"`", "\n", "Permalink", "string", "`json:\"permalink\"`", "\n", "SlackResponse", "\n", "}", "{", "}", "\n", "err", ":=", "api", ".", "getMethod", "(", "ctx", ",", "\"", "\"", ",", "values", ",", "&", "response", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "response", ".", "Permalink", ",", "response", ".", "Err", "(", ")", "\n", "}" ]

[ "GetPermalinkContext", "returns", "the", "permalink", "for", "a", "message", "using", "a", "custom", "context", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "ManageConnection", "(", ")", "{", "var", "(", "err", "error", "\n", "info", "*", "Info", "\n", "conn", "*", "websocket", ".", "Conn", "\n", ")", "\n\n", "for", "connectionCount", ":=", "0", ";", ";", "connectionCount", "++", "{", "// start trying to connect", "// the returned err is already passed onto the IncomingEvents channel", "if", "info", ",", "conn", ",", "err", "=", "rtm", ".", "connect", "(", "connectionCount", ",", "rtm", ".", "useRTMStart", ")", ";", "err", "!=", "nil", "{", "// when the connection is unsuccessful its fatal, and we need to bail out.", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "connectionCount", ",", "err", ")", "\n", "rtm", ".", "disconnect", "(", ")", "\n", "return", "\n", "}", "\n\n", "// lock to prevent data races with Disconnect particularly around isConnected", "// and conn.", "rtm", ".", "mu", ".", "Lock", "(", ")", "\n", "rtm", ".", "conn", "=", "conn", "\n", "rtm", ".", "info", "=", "info", "\n", "rtm", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "ConnectedEvent", "{", "ConnectionCount", ":", "connectionCount", ",", "Info", ":", "info", ",", "}", "}", "\n\n", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "connectionCount", ")", "\n\n", "// we're now connected so we can set up listeners", "go", "rtm", ".", "handleIncomingEvents", "(", ")", "\n\n", "// this should be a blocking call until the connection has ended", "rtm", ".", "handleEvents", "(", ")", "\n\n", "select", "{", "case", "<-", "rtm", ".", "disconnected", ":", "// after handle events returns we need to check if we're disconnected", "return", "\n", "default", ":", "// otherwise continue and run the loop again to reconnect", "}", "\n", "}", "\n", "}" ]

[ "ManageConnection", "can", "be", "called", "on", "a", "Slack", "RTM", "instance", "returned", "by", "the", "NewRTM", "method", ".", "It", "will", "connect", "to", "the", "slack", "RTM", "API", "and", "handle", "all", "incoming", "and", "outgoing", "events", ".", "If", "a", "connection", "fails", "then", "it", "will", "attempt", "to", "reconnect", "and", "will", "notify", "any", "listeners", "through", "an", "error", "event", "on", "the", "IncomingEvents", "channel", ".", "If", "the", "connection", "ends", "and", "the", "disconnect", "was", "unintentional", "then", "this", "will", "attempt", "to", "reconnect", ".", "This", "should", "only", "be", "called", "once", "per", "slack", "API!", "Otherwise", "expect", "undefined", "behavior", ".", "The", "defined", "error", "events", "are", "located", "in", "websocket_internals", ".", "go", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "connect", "(", "connectionCount", "int", ",", "useRTMStart", "bool", ")", "(", "*", "Info", ",", "*", "websocket", ".", "Conn", ",", "error", ")", "{", "const", "(", "errInvalidAuth", "=", "\"", "\"", "\n", "errInactiveAccount", "=", "\"", "\"", "\n", "errMissingAuthToken", "=", "\"", "\"", "\n", ")", "\n\n", "// used to provide exponential backoff wait time with jitter before trying", "// to connect to slack again", "boff", ":=", "&", "backoff", "{", "Max", ":", "5", "*", "time", ".", "Minute", ",", "}", "\n\n", "for", "{", "var", "(", "backoff", "time", ".", "Duration", "\n", ")", "\n\n", "// send connecting event", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "ConnectingEvent", "{", "Attempt", ":", "boff", ".", "attempts", "+", "1", ",", "ConnectionCount", ":", "connectionCount", ",", "}", "}", "\n\n", "// attempt to start the connection", "info", ",", "conn", ",", "err", ":=", "rtm", ".", "startRTMAndDial", "(", "useRTMStart", ")", "\n", "if", "err", "==", "nil", "{", "return", "info", ",", "conn", ",", "nil", "\n", "}", "\n\n", "// check for fatal errors", "switch", "err", ".", "Error", "(", ")", "{", "case", "errInvalidAuth", ",", "errInactiveAccount", ",", "errMissingAuthToken", ":", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "InvalidAuthEvent", "{", "}", "}", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "default", ":", "}", "\n\n", "switch", "actual", ":=", "err", ".", "(", "type", ")", "{", "case", "statusCodeError", ":", "if", "actual", ".", "Code", "==", "http", ".", "StatusNotFound", "{", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "InvalidAuthEvent", "{", "}", "}", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "case", "*", "RateLimitedError", ":", "backoff", "=", "actual", ".", "RetryAfter", "\n", "default", ":", "}", "\n\n", "backoff", "=", "timex", ".", "Max", "(", "backoff", ",", "boff", ".", "Duration", "(", ")", ")", "\n", "// any other errors are treated as recoverable and we try again after", "// sending the event along the IncomingEvents channel", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "ConnectionErrorEvent", "{", "Attempt", ":", "boff", ".", "attempts", ",", "Backoff", ":", "backoff", ",", "ErrorObj", ":", "err", ",", "}", "}", "\n\n", "// check if Disconnect() has been invoked.", "select", "{", "case", "intentional", ":=", "<-", "rtm", ".", "killChannel", ":", "if", "intentional", "{", "rtm", ".", "killConnection", "(", "intentional", ")", "\n", "return", "nil", ",", "nil", ",", "ErrRTMDisconnected", "\n", "}", "\n", "case", "<-", "rtm", ".", "disconnected", ":", "return", "nil", ",", "nil", ",", "ErrRTMDisconnected", "\n", "default", ":", "}", "\n\n", "// get time we should wait before attempting to connect again", "rtm", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "boff", ".", "attempts", ",", "err", ",", "backoff", ")", "\n", "time", ".", "Sleep", "(", "backoff", ")", "\n", "}", "\n", "}" ]

[ "connect", "attempts", "to", "connect", "to", "the", "slack", "websocket", "API", ".", "It", "handles", "any", "errors", "that", "occur", "while", "connecting", "and", "will", "return", "once", "a", "connection", "has", "been", "successfully", "opened", ".", "If", "useRTMStart", "is", "false", "then", "it", "uses", "rtm", ".", "connect", "to", "create", "the", "connection", "otherwise", "it", "uses", "rtm", ".", "start", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "startRTMAndDial", "(", "useRTMStart", "bool", ")", "(", "info", "*", "Info", ",", "_", "*", "websocket", ".", "Conn", ",", "err", "error", ")", "{", "var", "(", "url", "string", "\n", ")", "\n\n", "if", "useRTMStart", "{", "rtm", ".", "Debugf", "(", "\"", "\"", ")", "\n", "info", ",", "url", ",", "err", "=", "rtm", ".", "StartRTM", "(", ")", "\n", "}", "else", "{", "rtm", ".", "Debugf", "(", "\"", "\"", ")", "\n", "info", ",", "url", ",", "err", "=", "rtm", ".", "ConnectRTM", "(", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "// install connection parameters", "u", ",", "err", ":=", "stdurl", ".", "Parse", "(", "url", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "u", ".", "RawQuery", "=", "rtm", ".", "connParams", ".", "Encode", "(", ")", "\n", "url", "=", "u", ".", "String", "(", ")", "\n\n", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "url", ")", "\n", "// Only use HTTPS for connections to prevent MITM attacks on the connection.", "upgradeHeader", ":=", "http", ".", "Header", "{", "}", "\n", "upgradeHeader", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "dialer", ":=", "websocket", ".", "DefaultDialer", "\n", "if", "rtm", ".", "dialer", "!=", "nil", "{", "dialer", "=", "rtm", ".", "dialer", "\n", "}", "\n", "conn", ",", "_", ",", "err", ":=", "dialer", ".", "Dial", "(", "url", ",", "upgradeHeader", ")", "\n", "if", "err", "!=", "nil", "{", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "return", "info", ",", "conn", ",", "err", "\n", "}" ]

[ "startRTMAndDial", "attempts", "to", "connect", "to", "the", "slack", "websocket", ".", "If", "useRTMStart", "is", "true", "then", "it", "returns", "the", "full", "information", "returned", "by", "the", "rtm", ".", "start", "method", "on", "the", "slack", "API", ".", "Else", "it", "uses", "the", "rtm", ".", "connect", "method", "to", "connect" ]

[ "func", "(", "rtm", "*", "RTM", ")", "sendOutgoingMessage", "(", "msg", "OutgoingMessage", ")", "{", "rtm", ".", "Debugln", "(", "\"", "\"", ",", "msg", ")", "\n", "if", "len", "(", "[", "]", "rune", "(", "msg", ".", "Text", ")", ")", ">", "MaxMessageTextLength", "{", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "MessageTooLongEvent", "{", "Message", ":", "msg", ",", "MaxLength", ":", "MaxMessageTextLength", ",", "}", "}", "\n", "return", "\n", "}", "\n\n", "if", "err", ":=", "rtm", ".", "sendWithDeadline", "(", "msg", ")", ";", "err", "!=", "nil", "{", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "OutgoingErrorEvent", "{", "Message", ":", "msg", ",", "ErrorObj", ":", "err", ",", "}", "}", "\n", "// TODO force ping?", "}", "\n", "}" ]

[ "sendOutgoingMessage", "sends", "the", "given", "OutgoingMessage", "to", "the", "slack", "websocket", ".", "It", "does", "not", "currently", "detect", "if", "a", "outgoing", "message", "fails", "due", "to", "a", "disconnect", "and", "instead", "lets", "a", "future", "failed", "PING", "detect", "the", "failed", "connection", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "ping", "(", ")", "error", "{", "id", ":=", "rtm", ".", "idGen", ".", "Next", "(", ")", "\n", "rtm", ".", "Debugln", "(", "\"", "\"", ",", "id", ")", "\n", "msg", ":=", "&", "Ping", "{", "ID", ":", "id", ",", "Type", ":", "\"", "\"", ",", "Timestamp", ":", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "}", "\n\n", "if", "err", ":=", "rtm", ".", "sendWithDeadline", "(", "msg", ")", ";", "err", "!=", "nil", "{", "rtm", ".", "Debugf", "(", "\"", "\"", ",", "id", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ping", "sends", "a", "PING", "message", "to", "the", "RTM", "s", "websocket", ".", "If", "the", "PING", "message", "fails", "to", "send", "then", "this", "returns", "an", "error", "signifying", "that", "the", "connection", "should", "be", "considered", "disconnected", ".", "This", "does", "not", "handle", "incoming", "PONG", "responses", "but", "does", "store", "the", "time", "of", "each", "successful", "PING", "send", "so", "latency", "can", "be", "detected", "upon", "a", "PONG", "response", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "receiveIncomingEvent", "(", ")", "error", "{", "event", ":=", "json", ".", "RawMessage", "{", "}", "\n", "err", ":=", "rtm", ".", "conn", ".", "ReadJSON", "(", "&", "event", ")", "\n", "switch", "{", "case", "err", "==", "io", ".", "ErrUnexpectedEOF", ":", "// EOF's don't seem to signify a failed connection so instead we ignore", "// them here and detect a failed connection upon attempting to send a", "// 'PING' message", "// trigger a 'PING' to detect potential websocket disconnect", "select", "{", "case", "rtm", ".", "forcePing", "<-", "true", ":", "case", "<-", "rtm", ".", "disconnected", ":", "}", "\n", "case", "err", "!=", "nil", ":", "// All other errors from ReadJSON come from NextReader, and should", "// kill the read loop and force a reconnect.", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "IncomingEventError", "{", "ErrorObj", ":", "err", ",", "}", "}", "\n\n", "select", "{", "case", "rtm", ".", "killChannel", "<-", "false", ":", "case", "<-", "rtm", ".", "disconnected", ":", "}", "\n\n", "return", "err", "\n", "case", "len", "(", "event", ")", "==", "0", ":", "rtm", ".", "Debugln", "(", "\"", "\"", ")", "\n", "default", ":", "rtm", ".", "Debugln", "(", "\"", "\"", ",", "string", "(", "event", ")", ")", "\n", "select", "{", "case", "rtm", ".", "rawEvents", "<-", "event", ":", "case", "<-", "rtm", ".", "disconnected", ":", "rtm", ".", "Debugln", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "receiveIncomingEvent", "attempts", "to", "receive", "an", "event", "from", "the", "RTM", "s", "websocket", ".", "This", "will", "block", "until", "a", "frame", "is", "available", "from", "the", "websocket", ".", "If", "the", "read", "from", "the", "websocket", "results", "in", "a", "fatal", "error", "this", "function", "will", "return", "non", "-", "nil", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "handleRawEvent", "(", "rawEvent", "json", ".", "RawMessage", ")", "string", "{", "event", ":=", "&", "Event", "{", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "rawEvent", ",", "event", ")", "\n", "if", "err", "!=", "nil", "{", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "UnmarshallingErrorEvent", "{", "err", "}", "}", "\n", "return", "\"", "\"", "\n", "}", "\n\n", "switch", "event", ".", "Type", "{", "case", "rtmEventTypeAck", ":", "rtm", ".", "handleAck", "(", "rawEvent", ")", "\n", "case", "rtmEventTypeHello", ":", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "HelloEvent", "{", "}", "}", "\n", "case", "rtmEventTypePong", ":", "rtm", ".", "handlePong", "(", "rawEvent", ")", "\n", "case", "rtmEventTypeGoodbye", ":", "// just return the event type up for goodbye, will be handled by caller.", "case", "rtmEventTypeDesktopNotification", ":", "rtm", ".", "Debugln", "(", "\"", "\"", ")", "\n", "default", ":", "rtm", ".", "handleEvent", "(", "event", ".", "Type", ",", "rawEvent", ")", "\n", "}", "\n\n", "return", "event", ".", "Type", "\n", "}" ]

[ "handleRawEvent", "takes", "a", "raw", "JSON", "message", "received", "from", "the", "slack", "websocket", "and", "handles", "the", "encoded", "event", ".", "returns", "the", "event", "type", "of", "the", "message", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "handleAck", "(", "event", "json", ".", "RawMessage", ")", "{", "ack", ":=", "&", "AckMessage", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "event", ",", "ack", ")", ";", "err", "!=", "nil", "{", "rtm", ".", "Debugln", "(", "\"", "\"", ",", "err", ")", "\n", "rtm", ".", "Debugln", "(", "\"", "\"", ",", "string", "(", "event", ")", ")", "\n", "return", "\n", "}", "\n\n", "if", "ack", ".", "Ok", "{", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "ack", "}", "\n", "}", "else", "if", "ack", ".", "RTMResponse", ".", "Error", "!=", "nil", "{", "// As there is no documentation for RTM error-codes, this", "// identification of a rate-limit warning is very brittle.", "if", "ack", ".", "RTMResponse", ".", "Error", ".", "Code", "==", "-", "1", "&&", "ack", ".", "RTMResponse", ".", "Error", ".", "Msg", "==", "\"", "\"", "{", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "RateLimitEvent", "{", "}", "}", "\n", "}", "else", "{", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "AckErrorEvent", "{", "ack", ".", "Error", "}", "}", "\n", "}", "\n", "}", "else", "{", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "AckErrorEvent", "{", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "}", "}", "\n", "}", "\n", "}" ]

[ "handleAck", "handles", "an", "incoming", "ACK", "message", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "handlePong", "(", "event", "json", ".", "RawMessage", ")", "{", "var", "(", "p", "Pong", "\n", ")", "\n\n", "rtm", ".", "resetDeadman", "(", ")", "\n\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "event", ",", "&", "p", ")", ";", "err", "!=", "nil", "{", "rtm", ".", "Client", ".", "log", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "latency", ":=", "time", ".", "Since", "(", "time", ".", "Unix", "(", "p", ".", "Timestamp", ",", "0", ")", ")", "\n", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "LatencyReport", "{", "Value", ":", "latency", "}", "}", "\n", "}" ]

[ "handlePong", "handles", "an", "incoming", "PONG", "message", "which", "should", "be", "in", "response", "to", "a", "previously", "sent", "PING", "message", ".", "This", "is", "then", "used", "to", "compute", "the", "connection", "s", "latency", "." ]

[ "func", "(", "rtm", "*", "RTM", ")", "handleEvent", "(", "typeStr", "string", ",", "event", "json", ".", "RawMessage", ")", "{", "v", ",", "exists", ":=", "EventMapping", "[", "typeStr", "]", "\n", "if", "!", "exists", "{", "rtm", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "typeStr", ",", "string", "(", "event", ")", ")", "\n", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "typeStr", ",", "string", "(", "event", ")", ")", "\n", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "UnmarshallingErrorEvent", "{", "err", "}", "}", "\n", "return", "\n", "}", "\n", "t", ":=", "reflect", ".", "TypeOf", "(", "v", ")", "\n", "recvEvent", ":=", "reflect", ".", "New", "(", "t", ")", ".", "Interface", "(", ")", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "event", ",", "recvEvent", ")", "\n", "if", "err", "!=", "nil", "{", "rtm", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "typeStr", ",", "string", "(", "event", ")", ")", "\n", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "typeStr", ",", "string", "(", "event", ")", ")", "\n", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "\"", "\"", ",", "&", "UnmarshallingErrorEvent", "{", "err", "}", "}", "\n", "return", "\n", "}", "\n", "rtm", ".", "IncomingEvents", "<-", "RTMEvent", "{", "typeStr", ",", "recvEvent", "}", "\n", "}" ]

[ "handleEvent", "is", "the", "default", "response", "to", "an", "event", "that", "does", "not", "have", "a", "special", "case", ".", "It", "matches", "the", "command", "s", "name", "to", "a", "mapping", "of", "defined", "events", "and", "then", "sends", "the", "corresponding", "event", "struct", "to", "the", "IncomingEvents", "channel", ".", "If", "the", "event", "type", "is", "not", "found", "or", "the", "event", "cannot", "be", "unmarshalled", "into", "the", "correct", "struct", "then", "this", "sends", "an", "UnmarshallingErrorEvent", "to", "the", "IncomingEvents", "channel", "." ]

[ "func", "(", "api", "*", "Client", ")", "AddPin", "(", "channel", "string", ",", "item", "ItemRef", ")", "error", "{", "return", "api", ".", "AddPinContext", "(", "context", ".", "Background", "(", ")", ",", "channel", ",", "item", ")", "\n", "}" ]

[ "AddPin", "pins", "an", "item", "in", "a", "channel" ]

[ "func", "(", "api", "*", "Client", ")", "AddPinContext", "(", "ctx", "context", ".", "Context", ",", "channel", "string", ",", "item", "ItemRef", ")", "error", "{", "values", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "channel", "}", ",", "\"", "\"", ":", "{", "api", ".", "token", "}", ",", "}", "\n", "if", "item", ".", "Timestamp", "!=", "\"", "\"", "{", "values", ".", "Set", "(", "\"", "\"", ",", "item", ".", "Timestamp", ")", "\n", "}", "\n", "if", "item", ".", "File", "!=", "\"", "\"", "{", "values", ".", "Set", "(", "\"", "\"", ",", "item", ".", "File", ")", "\n", "}", "\n", "if", "item", ".", "Comment", "!=", "\"", "\"", "{", "values", ".", "Set", "(", "\"", "\"", ",", "item", ".", "Comment", ")", "\n", "}", "\n\n", "response", ":=", "&", "SlackResponse", "{", "}", "\n", "if", "err", ":=", "api", ".", "postMethod", "(", "ctx", ",", "\"", "\"", ",", "values", ",", "response", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "response", ".", "Err", "(", ")", "\n", "}" ]

[ "AddPinContext", "pins", "an", "item", "in", "a", "channel", "with", "a", "custom", "context" ]

[ "func", "(", "api", "*", "Client", ")", "RemovePin", "(", "channel", "string", ",", "item", "ItemRef", ")", "error", "{", "return", "api", ".", "RemovePinContext", "(", "context", ".", "Background", "(", ")", ",", "channel", ",", "item", ")", "\n", "}" ]

[ "RemovePin", "un", "-", "pins", "an", "item", "from", "a", "channel" ]

[ "func", "(", "api", "*", "Client", ")", "ListPins", "(", "channel", "string", ")", "(", "[", "]", "Item", ",", "*", "Paging", ",", "error", ")", "{", "return", "api", ".", "ListPinsContext", "(", "context", ".", "Background", "(", ")", ",", "channel", ")", "\n", "}" ]

[ "ListPins", "returns", "information", "about", "the", "items", "a", "user", "reacted", "to", "." ]

[ "func", "(", "api", "*", "Client", ")", "ListPinsContext", "(", "ctx", "context", ".", "Context", ",", "channel", "string", ")", "(", "[", "]", "Item", ",", "*", "Paging", ",", "error", ")", "{", "values", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "channel", "}", ",", "\"", "\"", ":", "{", "api", ".", "token", "}", ",", "}", "\n\n", "response", ":=", "&", "listPinsResponseFull", "{", "}", "\n", "err", ":=", "api", ".", "postMethod", "(", "ctx", ",", "\"", "\"", ",", "values", ",", "response", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "if", "!", "response", ".", "Ok", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "response", ".", "Error", ")", "\n", "}", "\n", "return", "response", ".", "Items", ",", "&", "response", ".", "Paging", ",", "nil", "\n", "}" ]

[ "ListPinsContext", "returns", "information", "about", "the", "items", "a", "user", "reacted", "to", "with", "a", "custom", "context", "." ]

[ "func", "(", "api", "*", "Client", ")", "CreateUserGroup", "(", "userGroup", "UserGroup", ")", "(", "UserGroup", ",", "error", ")", "{", "return", "api", ".", "CreateUserGroupContext", "(", "context", ".", "Background", "(", ")", ",", "userGroup", ")", "\n", "}" ]

[ "CreateUserGroup", "creates", "a", "new", "user", "group" ]

[ "func", "(", "api", "*", "Client", ")", "CreateUserGroupContext", "(", "ctx", "context", ".", "Context", ",", "userGroup", "UserGroup", ")", "(", "UserGroup", ",", "error", ")", "{", "values", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "api", ".", "token", "}", ",", "\"", "\"", ":", "{", "userGroup", ".", "Name", "}", ",", "}", "\n\n", "if", "userGroup", ".", "Handle", "!=", "\"", "\"", "{", "values", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "userGroup", ".", "Handle", "}", "\n", "}", "\n\n", "if", "userGroup", ".", "Description", "!=", "\"", "\"", "{", "values", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "userGroup", ".", "Description", "}", "\n", "}", "\n\n", "if", "len", "(", "userGroup", ".", "Prefs", ".", "Channels", ")", ">", "0", "{", "values", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "strings", ".", "Join", "(", "userGroup", ".", "Prefs", ".", "Channels", ",", "\"", "\"", ")", "}", "\n", "}", "\n\n", "response", ",", "err", ":=", "api", ".", "userGroupRequest", "(", "ctx", ",", "\"", "\"", ",", "values", ")", "\n", "if", "err", "!=", "nil", "{", "return", "UserGroup", "{", "}", ",", "err", "\n", "}", "\n", "return", "response", ".", "UserGroup", ",", "nil", "\n", "}" ]

[ "CreateUserGroupContext", "creates", "a", "new", "user", "group", "with", "a", "custom", "context" ]

[ "func", "(", "api", "*", "Client", ")", "DisableUserGroup", "(", "userGroup", "string", ")", "(", "UserGroup", ",", "error", ")", "{", "return", "api", ".", "DisableUserGroupContext", "(", "context", ".", "Background", "(", ")", ",", "userGroup", ")", "\n", "}" ]

[ "DisableUserGroup", "disables", "an", "existing", "user", "group" ]

[ "func", "(", "api", "*", "Client", ")", "EnableUserGroup", "(", "userGroup", "string", ")", "(", "UserGroup", ",", "error", ")", "{", "return", "api", ".", "EnableUserGroupContext", "(", "context", ".", "Background", "(", ")", ",", "userGroup", ")", "\n", "}" ]

[ "EnableUserGroup", "enables", "an", "existing", "user", "group" ]

[ "func", "(", "api", "*", "Client", ")", "EnableUserGroupContext", "(", "ctx", "context", ".", "Context", ",", "userGroup", "string", ")", "(", "UserGroup", ",", "error", ")", "{", "values", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "api", ".", "token", "}", ",", "\"", "\"", ":", "{", "userGroup", "}", ",", "}", "\n\n", "response", ",", "err", ":=", "api", ".", "userGroupRequest", "(", "ctx", ",", "\"", "\"", ",", "values", ")", "\n", "if", "err", "!=", "nil", "{", "return", "UserGroup", "{", "}", ",", "err", "\n", "}", "\n", "return", "response", ".", "UserGroup", ",", "nil", "\n", "}" ]

[ "EnableUserGroupContext", "enables", "an", "existing", "user", "group", "with", "a", "custom", "context" ]

[ "func", "(", "api", "*", "Client", ")", "GetUserGroups", "(", "options", "...", "GetUserGroupsOption", ")", "(", "[", "]", "UserGroup", ",", "error", ")", "{", "return", "api", ".", "GetUserGroupsContext", "(", "context", ".", "Background", "(", ")", ",", "options", "...", ")", "\n", "}" ]

[ "GetUserGroups", "returns", "a", "list", "of", "user", "groups", "for", "the", "team" ]

[ "func", "(", "api", "*", "Client", ")", "GetUserGroupsContext", "(", "ctx", "context", ".", "Context", ",", "options", "...", "GetUserGroupsOption", ")", "(", "[", "]", "UserGroup", ",", "error", ")", "{", "params", ":=", "GetUserGroupsParams", "{", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "options", "{", "opt", "(", "&", "params", ")", "\n", "}", "\n\n", "values", ":=", "url", ".", "Values", "{", "\"", "\"", ":", "{", "api", ".", "token", "}", ",", "}", "\n", "if", "params", ".", "IncludeCount", "{", "values", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "params", ".", "IncludeDisabled", "{", "values", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "params", ".", "IncludeUsers", "{", "values", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n\n", "response", ",", "err", ":=", "api", ".", "userGroupRequest", "(", "ctx", ",", "\"", "\"", ",", "values", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "response", ".", "UserGroups", ",", "nil", "\n", "}" ]

[ "GetUserGroupsContext", "returns", "a", "list", "of", "user", "groups", "for", "the", "team", "with", "a", "custom", "context" ]

[ "func", "(", "api", "*", "Client", ")", "UpdateUserGroup", "(", "userGroup", "UserGroup", ")", "(", "UserGroup", ",", "error", ")", "{", "return", "api", ".", "UpdateUserGroupContext", "(", "context", ".", "Background", "(", ")", ",", "userGroup", ")", "\n", "}" ]

[ "UpdateUserGroup", "will", "update", "an", "existing", "user", "group" ]

[ "func", "(", "api", "*", "Client", ")", "GetUserGroupMembers", "(", "userGroup", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "api", ".", "GetUserGroupMembersContext", "(", "context", ".", "Background", "(", ")", ",", "userGroup", ")", "\n", "}" ]

[ "GetUserGroupMembers", "will", "retrieve", "the", "current", "list", "of", "users", "in", "a", "group" ]

[ "func", "(", "api", "*", "Client", ")", "UpdateUserGroupMembers", "(", "userGroup", "string", ",", "members", "string", ")", "(", "UserGroup", ",", "error", ")", "{", "return", "api", ".", "UpdateUserGroupMembersContext", "(", "context", ".", "Background", "(", ")", ",", "userGroup", ",", "members", ")", "\n", "}" ]

[ "UpdateUserGroupMembers", "will", "update", "the", "members", "of", "an", "existing", "user", "group" ]

[ "func", "SlashCommandParse", "(", "r", "*", "http", ".", "Request", ")", "(", "s", "SlashCommand", ",", "err", "error", ")", "{", "if", "err", "=", "r", ".", "ParseForm", "(", ")", ";", "err", "!=", "nil", "{", "return", "s", ",", "err", "\n", "}", "\n", "s", ".", "Token", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "TeamID", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "TeamDomain", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "EnterpriseID", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "EnterpriseName", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "ChannelID", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "ChannelName", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "UserID", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "UserName", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "Command", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "Text", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "ResponseURL", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "s", ".", "TriggerID", "=", "r", ".", "PostForm", ".", "Get", "(", "\"", "\"", ")", "\n", "return", "s", ",", "nil", "\n", "}" ]

[ "SlashCommandParse", "will", "parse", "the", "request", "of", "the", "slash", "command" ]

[ "func", "(", "s", "SlashCommand", ")", "ValidateToken", "(", "verificationTokens", "...", "string", ")", "bool", "{", "for", "_", ",", "token", ":=", "range", "verificationTokens", "{", "if", "s", ".", "Token", "==", "token", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "ValidateToken", "validates", "verificationTokens" ]

[ "func", "NewCoordinate", "(", "config", "*", "Config", ")", "*", "Coordinate", "{", "return", "&", "Coordinate", "{", "Vec", ":", "make", "(", "[", "]", "float64", ",", "config", ".", "Dimensionality", ")", ",", "Error", ":", "config", ".", "VivaldiErrorMax", ",", "Adjustment", ":", "0.0", ",", "Height", ":", "config", ".", "HeightMin", ",", "}", "\n", "}" ]

[ "NewCoordinate", "creates", "a", "new", "coordinate", "at", "the", "origin", "using", "the", "given", "config", "to", "supply", "key", "initial", "values", "." ]

[ "func", "(", "c", "*", "Coordinate", ")", "Clone", "(", ")", "*", "Coordinate", "{", "vec", ":=", "make", "(", "[", "]", "float64", ",", "len", "(", "c", ".", "Vec", ")", ")", "\n", "copy", "(", "vec", ",", "c", ".", "Vec", ")", "\n", "return", "&", "Coordinate", "{", "Vec", ":", "vec", ",", "Error", ":", "c", ".", "Error", ",", "Adjustment", ":", "c", ".", "Adjustment", ",", "Height", ":", "c", ".", "Height", ",", "}", "\n", "}" ]

[ "Clone", "creates", "an", "independent", "copy", "of", "this", "coordinate", "." ]

[ "func", "componentIsValid", "(", "f", "float64", ")", "bool", "{", "return", "!", "math", ".", "IsInf", "(", "f", ",", "0", ")", "&&", "!", "math", ".", "IsNaN", "(", "f", ")", "\n", "}" ]

[ "componentIsValid", "returns", "false", "if", "a", "floating", "point", "value", "is", "a", "NaN", "or", "an", "infinity", "." ]

[ "func", "(", "c", "*", "Coordinate", ")", "IsCompatibleWith", "(", "other", "*", "Coordinate", ")", "bool", "{", "return", "len", "(", "c", ".", "Vec", ")", "==", "len", "(", "other", ".", "Vec", ")", "\n", "}" ]

[ "IsCompatibleWith", "checks", "to", "see", "if", "the", "two", "coordinates", "are", "compatible", "dimensionally", ".", "If", "this", "returns", "true", "then", "you", "are", "guaranteed", "to", "not", "get", "any", "runtime", "errors", "operating", "on", "them", "." ]

[ "func", "(", "c", "*", "Coordinate", ")", "ApplyForce", "(", "config", "*", "Config", ",", "force", "float64", ",", "other", "*", "Coordinate", ")", "*", "Coordinate", "{", "if", "!", "c", ".", "IsCompatibleWith", "(", "other", ")", "{", "panic", "(", "DimensionalityConflictError", "{", "}", ")", "\n", "}", "\n\n", "ret", ":=", "c", ".", "Clone", "(", ")", "\n", "unit", ",", "mag", ":=", "unitVectorAt", "(", "c", ".", "Vec", ",", "other", ".", "Vec", ")", "\n", "ret", ".", "Vec", "=", "add", "(", "ret", ".", "Vec", ",", "mul", "(", "unit", ",", "force", ")", ")", "\n", "if", "mag", ">", "zeroThreshold", "{", "ret", ".", "Height", "=", "(", "ret", ".", "Height", "+", "other", ".", "Height", ")", "*", "force", "/", "mag", "+", "ret", ".", "Height", "\n", "ret", ".", "Height", "=", "math", ".", "Max", "(", "ret", ".", "Height", ",", "config", ".", "HeightMin", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "ApplyForce", "returns", "the", "result", "of", "applying", "the", "force", "from", "the", "direction", "of", "the", "other", "coordinate", "." ]

[ "func", "(", "c", "*", "Coordinate", ")", "DistanceTo", "(", "other", "*", "Coordinate", ")", "time", ".", "Duration", "{", "if", "!", "c", ".", "IsCompatibleWith", "(", "other", ")", "{", "panic", "(", "DimensionalityConflictError", "{", "}", ")", "\n", "}", "\n\n", "dist", ":=", "c", ".", "rawDistanceTo", "(", "other", ")", "\n", "adjustedDist", ":=", "dist", "+", "c", ".", "Adjustment", "+", "other", ".", "Adjustment", "\n", "if", "adjustedDist", ">", "0.0", "{", "dist", "=", "adjustedDist", "\n", "}", "\n", "return", "time", ".", "Duration", "(", "dist", "*", "secondsToNanoseconds", ")", "\n", "}" ]

[ "DistanceTo", "returns", "the", "distance", "between", "this", "coordinate", "and", "the", "other", "coordinate", "including", "adjustments", "." ]

[ "func", "(", "c", "*", "Coordinate", ")", "rawDistanceTo", "(", "other", "*", "Coordinate", ")", "float64", "{", "return", "magnitude", "(", "diff", "(", "c", ".", "Vec", ",", "other", ".", "Vec", ")", ")", "+", "c", ".", "Height", "+", "other", ".", "Height", "\n", "}" ]

[ "rawDistanceTo", "returns", "the", "Vivaldi", "distance", "between", "this", "coordinate", "and", "the", "other", "coordinate", "in", "seconds", "not", "including", "adjustments", ".", "This", "assumes", "the", "dimensions", "have", "already", "been", "checked", "to", "be", "compatible", "." ]

[ "func", "add", "(", "vec1", "[", "]", "float64", ",", "vec2", "[", "]", "float64", ")", "[", "]", "float64", "{", "ret", ":=", "make", "(", "[", "]", "float64", ",", "len", "(", "vec1", ")", ")", "\n", "for", "i", ":=", "range", "ret", "{", "ret", "[", "i", "]", "=", "vec1", "[", "i", "]", "+", "vec2", "[", "i", "]", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "add", "returns", "the", "sum", "of", "vec1", "and", "vec2", ".", "This", "assumes", "the", "dimensions", "have", "already", "been", "checked", "to", "be", "compatible", "." ]

[ "func", "diff", "(", "vec1", "[", "]", "float64", ",", "vec2", "[", "]", "float64", ")", "[", "]", "float64", "{", "ret", ":=", "make", "(", "[", "]", "float64", ",", "len", "(", "vec1", ")", ")", "\n", "for", "i", ":=", "range", "ret", "{", "ret", "[", "i", "]", "=", "vec1", "[", "i", "]", "-", "vec2", "[", "i", "]", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "diff", "returns", "the", "difference", "between", "the", "vec1", "and", "vec2", ".", "This", "assumes", "the", "dimensions", "have", "already", "been", "checked", "to", "be", "compatible", "." ]

[ "func", "mul", "(", "vec", "[", "]", "float64", ",", "factor", "float64", ")", "[", "]", "float64", "{", "ret", ":=", "make", "(", "[", "]", "float64", ",", "len", "(", "vec", ")", ")", "\n", "for", "i", ":=", "range", "vec", "{", "ret", "[", "i", "]", "=", "vec", "[", "i", "]", "*", "factor", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "mul", "returns", "vec", "multiplied", "by", "a", "scalar", "factor", "." ]

[ "func", "magnitude", "(", "vec", "[", "]", "float64", ")", "float64", "{", "sum", ":=", "0.0", "\n", "for", "i", ":=", "range", "vec", "{", "sum", "+=", "vec", "[", "i", "]", "*", "vec", "[", "i", "]", "\n", "}", "\n", "return", "math", ".", "Sqrt", "(", "sum", ")", "\n", "}" ]

[ "magnitude", "computes", "the", "magnitude", "of", "the", "vec", "." ]

[ "func", "unitVectorAt", "(", "vec1", "[", "]", "float64", ",", "vec2", "[", "]", "float64", ")", "(", "[", "]", "float64", ",", "float64", ")", "{", "ret", ":=", "diff", "(", "vec1", ",", "vec2", ")", "\n\n", "// If the coordinates aren't on top of each other we can normalize.", "if", "mag", ":=", "magnitude", "(", "ret", ")", ";", "mag", ">", "zeroThreshold", "{", "return", "mul", "(", "ret", ",", "1.0", "/", "mag", ")", ",", "mag", "\n", "}", "\n\n", "// Otherwise, just return a random unit vector.", "for", "i", ":=", "range", "ret", "{", "ret", "[", "i", "]", "=", "rand", ".", "Float64", "(", ")", "-", "0.5", "\n", "}", "\n", "if", "mag", ":=", "magnitude", "(", "ret", ")", ";", "mag", ">", "zeroThreshold", "{", "return", "mul", "(", "ret", ",", "1.0", "/", "mag", ")", ",", "0.0", "\n", "}", "\n\n", "// And finally just give up and make a unit vector along the first", "// dimension. This should be exceedingly rare.", "ret", "=", "make", "(", "[", "]", "float64", ",", "len", "(", "ret", ")", ")", "\n", "ret", "[", "0", "]", "=", "1.0", "\n", "return", "ret", ",", "0.0", "\n", "}" ]

[ "unitVectorAt", "returns", "a", "unit", "vector", "pointing", "at", "vec1", "from", "vec2", ".", "If", "the", "two", "positions", "are", "the", "same", "then", "a", "random", "unit", "vector", "is", "returned", ".", "We", "also", "return", "the", "distance", "between", "the", "points", "for", "use", "in", "the", "later", "height", "calculation", "." ]

[ "func", "newSerfQueries", "(", "serf", "*", "Serf", ",", "logger", "*", "log", ".", "Logger", ",", "outCh", "chan", "<-", "Event", ",", "shutdownCh", "<-", "chan", "struct", "{", "}", ")", "(", "chan", "<-", "Event", ",", "error", ")", "{", "inCh", ":=", "make", "(", "chan", "Event", ",", "1024", ")", "\n", "q", ":=", "&", "serfQueries", "{", "inCh", ":", "inCh", ",", "logger", ":", "logger", ",", "outCh", ":", "outCh", ",", "serf", ":", "serf", ",", "shutdownCh", ":", "shutdownCh", ",", "}", "\n", "go", "q", ".", "stream", "(", ")", "\n", "return", "inCh", ",", "nil", "\n", "}" ]

[ "newSerfQueries", "is", "used", "to", "create", "a", "new", "serfQueries", ".", "We", "return", "an", "event", "channel", "that", "is", "ingested", "and", "forwarded", "to", "an", "outCh", ".", "Any", "Queries", "that", "have", "the", "InternalQueryPrefix", "are", "handled", "instead", "of", "forwarded", "." ]

[ "func", "(", "s", "*", "serfQueries", ")", "stream", "(", ")", "{", "for", "{", "select", "{", "case", "e", ":=", "<-", "s", ".", "inCh", ":", "// Check if this is a query we should process", "if", "q", ",", "ok", ":=", "e", ".", "(", "*", "Query", ")", ";", "ok", "&&", "strings", ".", "HasPrefix", "(", "q", ".", "Name", ",", "InternalQueryPrefix", ")", "{", "go", "s", ".", "handleQuery", "(", "q", ")", "\n\n", "}", "else", "if", "s", ".", "outCh", "!=", "nil", "{", "s", ".", "outCh", "<-", "e", "\n", "}", "\n\n", "case", "<-", "s", ".", "shutdownCh", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "stream", "is", "a", "long", "running", "routine", "to", "ingest", "the", "event", "stream" ]

[ "func", "(", "s", "*", "serfQueries", ")", "handleQuery", "(", "q", "*", "Query", ")", "{", "// Get the queryName after the initial prefix", "queryName", ":=", "q", ".", "Name", "[", "len", "(", "InternalQueryPrefix", ")", ":", "]", "\n", "switch", "queryName", "{", "case", "pingQuery", ":", "// Nothing to do, we will ack the query", "case", "conflictQuery", ":", "s", ".", "handleConflict", "(", "q", ")", "\n", "case", "installKeyQuery", ":", "s", ".", "handleInstallKey", "(", "q", ")", "\n", "case", "useKeyQuery", ":", "s", ".", "handleUseKey", "(", "q", ")", "\n", "case", "removeKeyQuery", ":", "s", ".", "handleRemoveKey", "(", "q", ")", "\n", "case", "listKeysQuery", ":", "s", ".", "handleListKeys", "(", "q", ")", "\n", "default", ":", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "queryName", ")", "\n", "}", "\n", "}" ]

[ "handleQuery", "is", "invoked", "when", "we", "get", "an", "internal", "query" ]

[ "func", "(", "s", "*", "serfQueries", ")", "handleConflict", "(", "q", "*", "Query", ")", "{", "// The target node name is the payload", "node", ":=", "string", "(", "q", ".", "Payload", ")", "\n\n", "// Do not respond to the query if it is about us", "if", "node", "==", "s", ".", "serf", ".", "config", ".", "NodeName", "{", "return", "\n", "}", "\n", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "node", ")", "\n\n", "// Look for the member info", "var", "out", "*", "Member", "\n", "s", ".", "serf", ".", "memberLock", ".", "Lock", "(", ")", "\n", "if", "member", ",", "ok", ":=", "s", ".", "serf", ".", "members", "[", "node", "]", ";", "ok", "{", "out", "=", "&", "member", ".", "Member", "\n", "}", "\n", "s", ".", "serf", ".", "memberLock", ".", "Unlock", "(", ")", "\n\n", "// Encode the response", "buf", ",", "err", ":=", "encodeMessage", "(", "messageConflictResponseType", ",", "out", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// Send our answer", "if", "err", ":=", "q", ".", "Respond", "(", "buf", ")", ";", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "handleConflict", "is", "invoked", "when", "we", "get", "a", "query", "that", "is", "attempting", "to", "disambiguate", "a", "name", "conflict", ".", "They", "payload", "is", "a", "node", "name", "and", "the", "response", "should", "the", "address", "we", "believe", "that", "node", "is", "at", "if", "any", "." ]

[ "func", "(", "s", "*", "serfQueries", ")", "sendKeyResponse", "(", "q", "*", "Query", ",", "resp", "*", "nodeKeyResponse", ")", "{", "switch", "q", ".", "Name", "{", "case", "internalQueryName", "(", "listKeysQuery", ")", ":", "raw", ",", "qresp", ",", "err", ":=", "s", ".", "keyListResponseWithCorrectSize", "(", "q", ",", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "err", ":=", "q", ".", "respondWithMessageAndResponse", "(", "raw", ",", "qresp", ")", ";", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "default", ":", "buf", ",", "err", ":=", "encodeMessage", "(", "messageKeyResponseType", ",", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "err", ":=", "q", ".", "Respond", "(", "buf", ")", ";", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "sendKeyResponse", "handles", "responding", "to", "key", "-", "related", "queries", "." ]

[ "func", "(", "s", "*", "serfQueries", ")", "handleInstallKey", "(", "q", "*", "Query", ")", "{", "response", ":=", "nodeKeyResponse", "{", "Result", ":", "false", "}", "\n", "keyring", ":=", "s", ".", "serf", ".", "config", ".", "MemberlistConfig", ".", "Keyring", "\n", "req", ":=", "keyRequest", "{", "}", "\n\n", "err", ":=", "decodeMessage", "(", "q", ".", "Payload", "[", "1", ":", "]", ",", "&", "req", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "goto", "SEND", "\n", "}", "\n\n", "if", "!", "s", ".", "serf", ".", "EncryptionEnabled", "(", ")", "{", "response", ".", "Message", "=", "\"", "\"", "\n", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ")", "\n", "goto", "SEND", "\n", "}", "\n\n", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "keyring", ".", "AddKey", "(", "req", ".", "Key", ")", ";", "err", "!=", "nil", "{", "response", ".", "Message", "=", "err", ".", "Error", "(", ")", "\n", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "goto", "SEND", "\n", "}", "\n\n", "if", "s", ".", "serf", ".", "config", ".", "KeyringFile", "!=", "\"", "\"", "{", "if", "err", ":=", "s", ".", "serf", ".", "writeKeyringFile", "(", ")", ";", "err", "!=", "nil", "{", "response", ".", "Message", "=", "err", ".", "Error", "(", ")", "\n", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "goto", "SEND", "\n", "}", "\n", "}", "\n\n", "response", ".", "Result", "=", "true", "\n\n", "SEND", ":", "s", ".", "sendKeyResponse", "(", "q", ",", "&", "response", ")", "\n", "}" ]

[ "handleInstallKey", "is", "invoked", "whenever", "a", "new", "encryption", "key", "is", "received", "from", "another", "member", "in", "the", "cluster", "and", "handles", "the", "process", "of", "installing", "it", "onto", "the", "memberlist", "keyring", ".", "This", "type", "of", "query", "may", "fail", "if", "the", "provided", "key", "does", "not", "fit", "the", "constraints", "that", "memberlist", "enforces", ".", "If", "the", "query", "fails", "the", "response", "will", "contain", "the", "error", "message", "so", "that", "it", "may", "be", "relayed", "." ]

[ "func", "(", "s", "*", "serfQueries", ")", "handleListKeys", "(", "q", "*", "Query", ")", "{", "response", ":=", "nodeKeyResponse", "{", "Result", ":", "false", "}", "\n", "keyring", ":=", "s", ".", "serf", ".", "config", ".", "MemberlistConfig", ".", "Keyring", "\n\n", "if", "!", "s", ".", "serf", ".", "EncryptionEnabled", "(", ")", "{", "response", ".", "Message", "=", "\"", "\"", "\n", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ")", "\n", "goto", "SEND", "\n", "}", "\n\n", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ")", "\n", "for", "_", ",", "keyBytes", ":=", "range", "keyring", ".", "GetKeys", "(", ")", "{", "// Encode the keys before sending the response. This should help take", "// some the burden of doing this off of the asking member.", "key", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "keyBytes", ")", "\n", "response", ".", "Keys", "=", "append", "(", "response", ".", "Keys", ",", "key", ")", "\n", "}", "\n", "response", ".", "Result", "=", "true", "\n\n", "SEND", ":", "s", ".", "sendKeyResponse", "(", "q", ",", "&", "response", ")", "\n", "}" ]

[ "handleListKeys", "is", "invoked", "when", "a", "query", "is", "received", "to", "return", "a", "list", "of", "all", "installed", "keys", "the", "Serf", "instance", "knows", "of", ".", "For", "performance", "the", "keys", "are", "encoded", "to", "base64", "on", "each", "of", "the", "members", "to", "remove", "this", "burden", "from", "the", "node", "asking", "for", "the", "results", "." ]

[ "func", "(", "s", "*", "Serf", ")", "DefaultQueryParams", "(", ")", "*", "QueryParam", "{", "return", "&", "QueryParam", "{", "FilterNodes", ":", "nil", ",", "FilterTags", ":", "nil", ",", "RequestAck", ":", "false", ",", "Timeout", ":", "s", ".", "DefaultQueryTimeout", "(", ")", ",", "}", "\n", "}" ]

[ "DefaultQueryParam", "is", "used", "to", "return", "the", "default", "query", "parameters" ]

[ "func", "(", "q", "*", "QueryParam", ")", "encodeFilters", "(", ")", "(", "[", "]", "[", "]", "byte", ",", "error", ")", "{", "var", "filters", "[", "]", "[", "]", "byte", "\n\n", "// Add the node filter", "if", "len", "(", "q", ".", "FilterNodes", ")", ">", "0", "{", "if", "buf", ",", "err", ":=", "encodeFilter", "(", "filterNodeType", ",", "q", ".", "FilterNodes", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "{", "filters", "=", "append", "(", "filters", ",", "buf", ")", "\n", "}", "\n", "}", "\n\n", "// Add the tag filters", "for", "tag", ",", "expr", ":=", "range", "q", ".", "FilterTags", "{", "filt", ":=", "filterTag", "{", "tag", ",", "expr", "}", "\n", "if", "buf", ",", "err", ":=", "encodeFilter", "(", "filterTagType", ",", "&", "filt", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "{", "filters", "=", "append", "(", "filters", ",", "buf", ")", "\n", "}", "\n", "}", "\n\n", "return", "filters", ",", "nil", "\n", "}" ]

[ "encodeFilters", "is", "used", "to", "convert", "the", "filters", "into", "the", "wire", "format" ]

[ "func", "newQueryResponse", "(", "n", "int", ",", "q", "*", "messageQuery", ")", "*", "QueryResponse", "{", "resp", ":=", "&", "QueryResponse", "{", "deadline", ":", "time", ".", "Now", "(", ")", ".", "Add", "(", "q", ".", "Timeout", ")", ",", "id", ":", "q", ".", "ID", ",", "lTime", ":", "q", ".", "LTime", ",", "respCh", ":", "make", "(", "chan", "NodeResponse", ",", "n", ")", ",", "responses", ":", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", ",", "}", "\n", "if", "q", ".", "Ack", "(", ")", "{", "resp", ".", "ackCh", "=", "make", "(", "chan", "string", ",", "n", ")", "\n", "resp", ".", "acks", "=", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", "\n", "}", "\n", "return", "resp", "\n", "}" ]

[ "newQueryResponse", "is", "used", "to", "construct", "a", "new", "query", "response" ]

[ "func", "(", "r", "*", "QueryResponse", ")", "Close", "(", ")", "{", "r", ".", "closeLock", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "closeLock", ".", "Unlock", "(", ")", "\n", "if", "r", ".", "closed", "{", "return", "\n", "}", "\n", "r", ".", "closed", "=", "true", "\n", "if", "r", ".", "ackCh", "!=", "nil", "{", "close", "(", "r", ".", "ackCh", ")", "\n", "}", "\n", "if", "r", ".", "respCh", "!=", "nil", "{", "close", "(", "r", ".", "respCh", ")", "\n", "}", "\n", "}" ]

[ "Close", "is", "used", "to", "close", "the", "query", "which", "will", "close", "the", "underlying", "channels", "and", "prevent", "further", "deliveries" ]

[ "func", "(", "r", "*", "QueryResponse", ")", "Finished", "(", ")", "bool", "{", "r", ".", "closeLock", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "closeLock", ".", "Unlock", "(", ")", "\n", "return", "r", ".", "closed", "||", "time", ".", "Now", "(", ")", ".", "After", "(", "r", ".", "deadline", ")", "\n", "}" ]

[ "Finished", "returns", "if", "the", "query", "is", "finished", "running" ]

[ "func", "(", "r", "*", "QueryResponse", ")", "sendResponse", "(", "nr", "NodeResponse", ")", "error", "{", "r", ".", "closeLock", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "closeLock", ".", "Unlock", "(", ")", "\n", "if", "r", ".", "closed", "{", "return", "nil", "\n", "}", "\n", "select", "{", "case", "r", ".", "respCh", "<-", "nr", ":", "r", ".", "responses", "[", "nr", ".", "From", "]", "=", "struct", "{", "}", "{", "}", "\n", "default", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "sendResponse", "sends", "a", "response", "on", "the", "response", "channel", "ensuring", "the", "channel", "is", "not", "closed", "." ]

[ "func", "(", "s", "*", "Serf", ")", "shouldProcessQuery", "(", "filters", "[", "]", "[", "]", "byte", ")", "bool", "{", "for", "_", ",", "filter", ":=", "range", "filters", "{", "switch", "filterType", "(", "filter", "[", "0", "]", ")", "{", "case", "filterNodeType", ":", "// Decode the filter", "var", "nodes", "filterNode", "\n", "if", "err", ":=", "decodeMessage", "(", "filter", "[", "1", ":", "]", ",", "&", "nodes", ")", ";", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n\n", "// Check if we are being targeted", "found", ":=", "false", "\n", "for", "_", ",", "n", ":=", "range", "nodes", "{", "if", "n", "==", "s", ".", "config", ".", "NodeName", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "return", "false", "\n", "}", "\n\n", "case", "filterTagType", ":", "// Decode the filter", "var", "filt", "filterTag", "\n", "if", "err", ":=", "decodeMessage", "(", "filter", "[", "1", ":", "]", ",", "&", "filt", ")", ";", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n\n", "// Check if we match this regex", "tags", ":=", "s", ".", "config", ".", "Tags", "\n", "matched", ",", "err", ":=", "regexp", ".", "MatchString", "(", "filt", ".", "Expr", ",", "tags", "[", "filt", ".", "Tag", "]", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "filt", ".", "Expr", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "if", "!", "matched", "{", "return", "false", "\n", "}", "\n\n", "default", ":", "s", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "filter", "[", "0", "]", ")", "\n", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "shouldProcessQuery", "checks", "if", "a", "query", "should", "be", "proceeded", "given", "a", "set", "of", "filers", "." ]

[ "func", "(", "s", "*", "Serf", ")", "relayResponse", "(", "relayFactor", "uint8", ",", "addr", "net", ".", "UDPAddr", ",", "resp", "*", "messageQueryResponse", ")", "error", "{", "if", "relayFactor", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Needs to be worth it; we need to have at least relayFactor *other*", "// nodes. If you have a tiny cluster then the relayFactor shouldn't", "// be needed.", "members", ":=", "s", ".", "Members", "(", ")", "\n", "if", "len", "(", "members", ")", "<", "int", "(", "relayFactor", ")", "+", "1", "{", "return", "nil", "\n", "}", "\n\n", "// Prep the relay message, which is a wrapped version of the original.", "raw", ",", "err", ":=", "encodeRelayMessage", "(", "messageQueryResponseType", ",", "addr", ",", "&", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "raw", ")", ">", "s", ".", "config", ".", "QueryResponseSizeLimit", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "config", ".", "QueryResponseSizeLimit", ")", "\n", "}", "\n\n", "// Relay to a random set of peers.", "localName", ":=", "s", ".", "LocalMember", "(", ")", ".", "Name", "\n", "relayMembers", ":=", "kRandomMembers", "(", "int", "(", "relayFactor", ")", ",", "members", ",", "func", "(", "m", "Member", ")", "bool", "{", "return", "m", ".", "Status", "!=", "StatusAlive", "||", "m", ".", "ProtocolMax", "<", "5", "||", "m", ".", "Name", "==", "localName", "\n", "}", ")", "\n", "for", "_", ",", "m", ":=", "range", "relayMembers", "{", "relayAddr", ":=", "net", ".", "UDPAddr", "{", "IP", ":", "m", ".", "Addr", ",", "Port", ":", "int", "(", "m", ".", "Port", ")", "}", "\n", "if", "err", ":=", "s", ".", "memberlist", ".", "SendTo", "(", "&", "relayAddr", ",", "raw", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "relayResponse", "will", "relay", "a", "copy", "of", "the", "given", "response", "to", "up", "to", "relayFactor", "other", "members", "." ]

[ "func", "kRandomMembers", "(", "k", "int", ",", "members", "[", "]", "Member", ",", "filterFunc", "func", "(", "Member", ")", "bool", ")", "[", "]", "Member", "{", "n", ":=", "len", "(", "members", ")", "\n", "kMembers", ":=", "make", "(", "[", "]", "Member", ",", "0", ",", "k", ")", "\n", "OUTER", ":", "// Probe up to 3*n times, with large n this is not necessary", "// since k << n, but with small n we want search to be", "// exhaustive", "for", "i", ":=", "0", ";", "i", "<", "3", "*", "n", "&&", "len", "(", "kMembers", ")", "<", "k", ";", "i", "++", "{", "// Get random member", "idx", ":=", "rand", ".", "Intn", "(", "n", ")", "\n", "member", ":=", "members", "[", "idx", "]", "\n\n", "// Give the filter a shot at it.", "if", "filterFunc", "!=", "nil", "&&", "filterFunc", "(", "member", ")", "{", "continue", "OUTER", "\n", "}", "\n\n", "// Check if we have this member already", "for", "j", ":=", "0", ";", "j", "<", "len", "(", "kMembers", ")", ";", "j", "++", "{", "if", "member", ".", "Name", "==", "kMembers", "[", "j", "]", ".", "Name", "{", "continue", "OUTER", "\n", "}", "\n", "}", "\n\n", "// Append the member", "kMembers", "=", "append", "(", "kMembers", ",", "member", ")", "\n", "}", "\n\n", "return", "kMembers", "\n", "}" ]

[ "kRandomMembers", "selects", "up", "to", "k", "members", "from", "a", "given", "list", "optionally", "filtering", "by", "the", "given", "filterFunc" ]

[ "func", "NewAgentMDNS", "(", "agent", "*", "Agent", ",", "logOutput", "io", ".", "Writer", ",", "replay", "bool", ",", "node", ",", "discover", "string", ",", "iface", "*", "net", ".", "Interface", ",", "bind", "net", ".", "IP", ",", "port", "int", ")", "(", "*", "AgentMDNS", ",", "error", ")", "{", "// Create the service", "service", ",", "err", ":=", "mdns", ".", "NewMDNSService", "(", "node", ",", "mdnsName", "(", "discover", ")", ",", "\"", "\"", ",", "\"", "\"", ",", "port", ",", "[", "]", "net", ".", "IP", "{", "bind", "}", ",", "[", "]", "string", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "discover", ")", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Configure mdns server", "conf", ":=", "&", "mdns", ".", "Config", "{", "Zone", ":", "service", ",", "Iface", ":", "iface", ",", "}", "\n\n", "// Create the server", "server", ",", "err", ":=", "mdns", ".", "NewServer", "(", "conf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Initialize the AgentMDNS", "m", ":=", "&", "AgentMDNS", "{", "agent", ":", "agent", ",", "discover", ":", "discover", ",", "logger", ":", "log", ".", "New", "(", "logOutput", ",", "\"", "\"", ",", "log", ".", "LstdFlags", ")", ",", "seen", ":", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", ",", "server", ":", "server", ",", "replay", ":", "replay", ",", "iface", ":", "iface", ",", "}", "\n\n", "// Start the background workers", "go", "m", ".", "run", "(", ")", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "NewAgentMDNS", "is", "used", "to", "create", "a", "new", "AgentMDNS" ]

[ "func", "(", "m", "*", "AgentMDNS", ")", "run", "(", ")", "{", "hosts", ":=", "make", "(", "chan", "*", "mdns", ".", "ServiceEntry", ",", "32", ")", "\n", "poll", ":=", "time", ".", "After", "(", "0", ")", "\n", "var", "quiet", "<-", "chan", "time", ".", "Time", "\n", "var", "join", "[", "]", "string", "\n\n", "for", "{", "select", "{", "case", "h", ":=", "<-", "hosts", ":", "// Format the host address", "addr", ":=", "net", ".", "TCPAddr", "{", "IP", ":", "h", ".", "Addr", ",", "Port", ":", "h", ".", "Port", "}", "\n", "addrS", ":=", "addr", ".", "String", "(", ")", "\n\n", "// Skip if we've handled this host already", "if", "_", ",", "ok", ":=", "m", ".", "seen", "[", "addrS", "]", ";", "ok", "{", "continue", "\n", "}", "\n\n", "// Queue for handling", "join", "=", "append", "(", "join", ",", "addrS", ")", "\n", "quiet", "=", "time", ".", "After", "(", "mdnsQuietInterval", ")", "\n\n", "case", "<-", "quiet", ":", "// Attempt the join", "n", ",", "err", ":=", "m", ".", "agent", ".", "Join", "(", "join", ",", "m", ".", "replay", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "n", ">", "0", "{", "m", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n\n", "// Mark all as seen", "for", "_", ",", "n", ":=", "range", "join", "{", "m", ".", "seen", "[", "n", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "join", "=", "nil", "\n\n", "case", "<-", "poll", ":", "poll", "=", "time", ".", "After", "(", "mdnsPollInterval", ")", "\n", "go", "m", ".", "poll", "(", "hosts", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "run", "is", "a", "long", "running", "goroutine", "that", "scans", "for", "new", "hosts", "periodically" ]

[ "func", "(", "m", "*", "AgentMDNS", ")", "poll", "(", "hosts", "chan", "*", "mdns", ".", "ServiceEntry", ")", "{", "params", ":=", "mdns", ".", "QueryParam", "{", "Service", ":", "mdnsName", "(", "m", ".", "discover", ")", ",", "Interface", ":", "m", ".", "iface", ",", "Entries", ":", "hosts", ",", "}", "\n", "if", "err", ":=", "mdns", ".", "Query", "(", "&", "params", ")", ";", "err", "!=", "nil", "{", "m", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "poll", "is", "invoked", "periodically", "to", "check", "for", "new", "hosts" ]

[ "func", "DefaultConfig", "(", ")", "*", "Config", "{", "return", "&", "Config", "{", "Dimensionality", ":", "8", ",", "VivaldiErrorMax", ":", "1.5", ",", "VivaldiCE", ":", "0.25", ",", "VivaldiCC", ":", "0.25", ",", "AdjustmentWindowSize", ":", "20", ",", "HeightMin", ":", "10.0e-6", ",", "LatencyFilterSize", ":", "3", ",", "GravityRho", ":", "150.0", ",", "}", "\n", "}" ]

[ "DefaultConfig", "returns", "a", "Config", "that", "has", "some", "default", "values", "suitable", "for", "basic", "testing", "of", "the", "algorithm", "but", "not", "tuned", "to", "any", "particular", "type", "of", "cluster", "." ]

[ "func", "(", "l", "*", "LamportClock", ")", "Witness", "(", "v", "LamportTime", ")", "{", "WITNESS", ":", "// If the other value is old, we do not need to do anything", "cur", ":=", "atomic", ".", "LoadUint64", "(", "&", "l", ".", "counter", ")", "\n", "other", ":=", "uint64", "(", "v", ")", "\n", "if", "other", "<", "cur", "{", "return", "\n", "}", "\n\n", "// Ensure that our local clock is at least one ahead.", "if", "!", "atomic", ".", "CompareAndSwapUint64", "(", "&", "l", ".", "counter", ",", "cur", ",", "other", "+", "1", ")", "{", "// The CAS failed, so we just retry. Eventually our CAS should", "// succeed or a future witness will pass us by and our witness", "// will end.", "goto", "WITNESS", "\n", "}", "\n", "}" ]

[ "Witness", "is", "called", "to", "update", "our", "local", "clock", "if", "necessary", "after", "witnessing", "a", "clock", "value", "received", "from", "another", "process" ]

[ "func", "Create", "(", "agentConf", "*", "Config", ",", "conf", "*", "serf", ".", "Config", ",", "logOutput", "io", ".", "Writer", ")", "(", "*", "Agent", ",", "error", ")", "{", "// Ensure we have a log sink", "if", "logOutput", "==", "nil", "{", "logOutput", "=", "os", ".", "Stderr", "\n", "}", "\n\n", "// Setup the underlying loggers", "conf", ".", "MemberlistConfig", ".", "LogOutput", "=", "logOutput", "\n", "conf", ".", "MemberlistConfig", ".", "EnableCompression", "=", "agentConf", ".", "EnableCompression", "\n", "conf", ".", "LogOutput", "=", "logOutput", "\n\n", "// Create a channel to listen for events from Serf", "eventCh", ":=", "make", "(", "chan", "serf", ".", "Event", ",", "64", ")", "\n", "conf", ".", "EventCh", "=", "eventCh", "\n\n", "// Setup the agent", "agent", ":=", "&", "Agent", "{", "conf", ":", "conf", ",", "agentConf", ":", "agentConf", ",", "eventCh", ":", "eventCh", ",", "eventHandlers", ":", "make", "(", "map", "[", "EventHandler", "]", "struct", "{", "}", ")", ",", "logger", ":", "log", ".", "New", "(", "logOutput", ",", "\"", "\"", ",", "log", ".", "LstdFlags", ")", ",", "shutdownCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n\n", "// Restore agent tags from a tags file", "if", "agentConf", ".", "TagsFile", "!=", "\"", "\"", "{", "if", "err", ":=", "agent", ".", "loadTagsFile", "(", "agentConf", ".", "TagsFile", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// Load in a keyring file if provided", "if", "agentConf", ".", "KeyringFile", "!=", "\"", "\"", "{", "if", "err", ":=", "agent", ".", "loadKeyringFile", "(", "agentConf", ".", "KeyringFile", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "agent", ",", "nil", "\n", "}" ]

[ "Start", "creates", "a", "new", "agent", "potentially", "returning", "an", "error" ]

[ "func", "(", "a", "*", "Agent", ")", "Start", "(", ")", "error", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ")", "\n\n", "// Create serf first", "serf", ",", "err", ":=", "serf", ".", "Create", "(", "a", ".", "conf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "a", ".", "serf", "=", "serf", "\n\n", "// Start event loop", "go", "a", ".", "eventLoop", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Start", "is", "used", "to", "initiate", "the", "event", "listeners", ".", "It", "is", "separate", "from", "create", "so", "that", "there", "isn", "t", "a", "race", "condition", "between", "creating", "the", "agent", "and", "registering", "handlers" ]

[ "func", "(", "a", "*", "Agent", ")", "Leave", "(", ")", "error", "{", "if", "a", ".", "serf", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "a", ".", "logger", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "a", ".", "serf", ".", "Leave", "(", ")", "\n", "}" ]

[ "Leave", "prepares", "for", "a", "graceful", "shutdown", "of", "the", "agent", "and", "its", "processes" ]

[ "func", "(", "a", "*", "Agent", ")", "Shutdown", "(", ")", "error", "{", "a", ".", "shutdownLock", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "shutdownLock", ".", "Unlock", "(", ")", "\n\n", "if", "a", ".", "shutdown", "{", "return", "nil", "\n", "}", "\n\n", "if", "a", ".", "serf", "==", "nil", "{", "goto", "EXIT", "\n", "}", "\n\n", "a", ".", "logger", ".", "Println", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "a", ".", "serf", ".", "Shutdown", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "EXIT", ":", "a", ".", "logger", ".", "Println", "(", "\"", "\"", ")", "\n", "a", ".", "shutdown", "=", "true", "\n", "close", "(", "a", ".", "shutdownCh", ")", "\n", "return", "nil", "\n", "}" ]

[ "Shutdown", "closes", "this", "agent", "and", "all", "of", "its", "processes", ".", "Should", "be", "preceded", "by", "a", "Leave", "for", "a", "graceful", "shutdown", "." ]

[ "func", "(", "a", "*", "Agent", ")", "Join", "(", "addrs", "[", "]", "string", ",", "replay", "bool", ")", "(", "n", "int", ",", "err", "error", ")", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "addrs", ",", "replay", ")", "\n", "ignoreOld", ":=", "!", "replay", "\n", "n", ",", "err", "=", "a", ".", "serf", ".", "Join", "(", "addrs", ",", "ignoreOld", ")", "\n", "if", "n", ">", "0", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Join", "asks", "the", "Serf", "instance", "to", "join", ".", "See", "the", "Serf", ".", "Join", "function", "." ]

[ "func", "(", "a", "*", "Agent", ")", "UserEvent", "(", "name", "string", ",", "payload", "[", "]", "byte", ",", "coalesce", "bool", ")", "error", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "name", ",", "coalesce", ",", "string", "(", "payload", ")", ")", "\n", "err", ":=", "a", ".", "serf", ".", "UserEvent", "(", "name", ",", "payload", ",", "coalesce", ")", "\n", "if", "err", "!=", "nil", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "UserEvent", "sends", "a", "UserEvent", "on", "Serf", "see", "Serf", ".", "UserEvent", "." ]

[ "func", "(", "a", "*", "Agent", ")", "Query", "(", "name", "string", ",", "payload", "[", "]", "byte", ",", "params", "*", "serf", ".", "QueryParam", ")", "(", "*", "serf", ".", "QueryResponse", ",", "error", ")", "{", "// Prevent the use of the internal prefix", "if", "strings", ".", "HasPrefix", "(", "name", ",", "serf", ".", "InternalQueryPrefix", ")", "{", "// Allow the special \"ping\" query", "if", "name", "!=", "serf", ".", "InternalQueryPrefix", "+", "\"", "\"", "||", "payload", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "serf", ".", "InternalQueryPrefix", ")", "\n", "}", "\n", "}", "\n", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "name", ",", "string", "(", "payload", ")", ")", "\n", "resp", ",", "err", ":=", "a", ".", "serf", ".", "Query", "(", "name", ",", "payload", ",", "params", ")", "\n", "if", "err", "!=", "nil", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "resp", ",", "err", "\n", "}" ]

[ "Query", "sends", "a", "Query", "on", "Serf", "see", "Serf", ".", "Query", "." ]

[ "func", "(", "a", "*", "Agent", ")", "RegisterEventHandler", "(", "eh", "EventHandler", ")", "{", "a", ".", "eventHandlersLock", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "eventHandlersLock", ".", "Unlock", "(", ")", "\n\n", "a", ".", "eventHandlers", "[", "eh", "]", "=", "struct", "{", "}", "{", "}", "\n", "a", ".", "eventHandlerList", "=", "nil", "\n", "for", "eh", ":=", "range", "a", ".", "eventHandlers", "{", "a", ".", "eventHandlerList", "=", "append", "(", "a", ".", "eventHandlerList", ",", "eh", ")", "\n", "}", "\n", "}" ]

[ "RegisterEventHandler", "adds", "an", "event", "handler", "to", "receive", "event", "notifications" ]

[ "func", "(", "a", "*", "Agent", ")", "DeregisterEventHandler", "(", "eh", "EventHandler", ")", "{", "a", ".", "eventHandlersLock", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "eventHandlersLock", ".", "Unlock", "(", ")", "\n\n", "delete", "(", "a", ".", "eventHandlers", ",", "eh", ")", "\n", "a", ".", "eventHandlerList", "=", "nil", "\n", "for", "eh", ":=", "range", "a", ".", "eventHandlers", "{", "a", ".", "eventHandlerList", "=", "append", "(", "a", ".", "eventHandlerList", ",", "eh", ")", "\n", "}", "\n", "}" ]

[ "DeregisterEventHandler", "removes", "an", "EventHandler", "and", "prevents", "more", "invocations" ]

[ "func", "(", "a", "*", "Agent", ")", "eventLoop", "(", ")", "{", "serfShutdownCh", ":=", "a", ".", "serf", ".", "ShutdownCh", "(", ")", "\n", "for", "{", "select", "{", "case", "e", ":=", "<-", "a", ".", "eventCh", ":", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "e", ".", "String", "(", ")", ")", "\n", "a", ".", "eventHandlersLock", ".", "Lock", "(", ")", "\n", "handlers", ":=", "a", ".", "eventHandlerList", "\n", "a", ".", "eventHandlersLock", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "eh", ":=", "range", "handlers", "{", "eh", ".", "HandleEvent", "(", "e", ")", "\n", "}", "\n\n", "case", "<-", "serfShutdownCh", ":", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ")", "\n", "a", ".", "Shutdown", "(", ")", "\n", "return", "\n\n", "case", "<-", "a", ".", "shutdownCh", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "eventLoop", "listens", "to", "events", "from", "Serf", "and", "fans", "out", "to", "event", "handlers" ]

[ "func", "(", "a", "*", "Agent", ")", "InstallKey", "(", "key", "string", ")", "(", "*", "serf", ".", "KeyResponse", ",", "error", ")", "{", "a", ".", "logger", ".", "Print", "(", "\"", "\"", ")", "\n", "manager", ":=", "a", ".", "serf", ".", "KeyManager", "(", ")", "\n", "return", "manager", ".", "InstallKey", "(", "key", ")", "\n", "}" ]

[ "InstallKey", "initiates", "a", "query", "to", "install", "a", "new", "key", "on", "all", "members" ]

[ "func", "(", "a", "*", "Agent", ")", "ListKeys", "(", ")", "(", "*", "serf", ".", "KeyResponse", ",", "error", ")", "{", "a", ".", "logger", ".", "Print", "(", "\"", "\"", ")", "\n", "manager", ":=", "a", ".", "serf", ".", "KeyManager", "(", ")", "\n", "return", "manager", ".", "ListKeys", "(", ")", "\n", "}" ]

[ "ListKeys", "sends", "a", "query", "to", "all", "members", "to", "return", "a", "list", "of", "their", "keys" ]

[ "func", "(", "a", "*", "Agent", ")", "SetTags", "(", "tags", "map", "[", "string", "]", "string", ")", "error", "{", "// Update the tags file if we have one", "if", "a", ".", "agentConf", ".", "TagsFile", "!=", "\"", "\"", "{", "if", "err", ":=", "a", ".", "writeTagsFile", "(", "tags", ")", ";", "err", "!=", "nil", "{", "a", ".", "logger", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Set the tags in Serf, start gossiping out", "return", "a", ".", "serf", ".", "SetTags", "(", "tags", ")", "\n", "}" ]

[ "SetTags", "is", "used", "to", "update", "the", "tags", ".", "The", "agent", "will", "make", "sure", "to", "persist", "tags", "if", "necessary", "before", "gossiping", "to", "the", "cluster", "." ]