Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.4k

[ "func", "(", "c", "*", "client", ")", "sendAccountUnsubToGateway", "(", "accName", "[", "]", "byte", ")", "{", "// Check if we have sent the A- or not.", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "e", ",", "sent", ":=", "c", ".", "gw", ".", "insim", "[", "string", "(", "accName", ")", "]", "\n", "if", "e", "!=", "nil", "||", "!", "sent", "{", "// Add a nil value to indicate that we have sent an A-", "// so that we know to send A+ when needed.", "c", ".", "gw", ".", "insim", "[", "string", "(", "accName", ")", "]", "=", "nil", "\n", "var", "protoa", "[", "256", "]", "byte", "\n", "proto", ":=", "protoa", "[", ":", "0", "]", "\n", "proto", "=", "append", "(", "proto", ",", "aUnsubBytes", "...", ")", "\n", "proto", "=", "append", "(", "proto", ",", "accName", "...", ")", "\n", "proto", "=", "append", "(", "proto", ",", "CR_LF", "...", ")", "\n", "c", ".", "sendProto", "(", "proto", ",", "false", ")", "\n", "if", "c", ".", "trace", "{", "c", ".", "traceOutOp", "(", "\"", "\"", ",", "proto", "[", ":", "len", "(", "proto", ")", "-", "LEN_CR_LF", "]", ")", "\n", "}", "\n", "}", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Helper", "that", "sends", "an", "A", "-", "to", "this", "remote", "gateway", "if", "not", "already", "done", ".", "This", "function", "should", "not", "be", "invoked", "directly", "but", "instead", "be", "invoked", "by", "functions", "holding", "the", "gateway", ".", "pasi", "s", "Lock", "." ]

[ "func", "getAccountFromGatewayCommand", "(", "c", "*", "client", ",", "info", "*", "Info", ",", "cmd", "string", ")", "string", "{", "if", "info", ".", "GatewayCmdPayload", "==", "nil", "{", "c", ".", "sendErrAndErr", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cmd", ")", ")", "\n", "c", ".", "closeConnection", "(", "ProtocolViolation", ")", "\n", "return", "\"", "\"", "\n", "}", "\n", "return", "string", "(", "info", ".", "GatewayCmdPayload", ")", "\n", "}" ]

[ "small", "helper", "to", "get", "the", "account", "name", "from", "the", "INFO", "command", "." ]

[ "func", "NewStdLogger", "(", "time", ",", "debug", ",", "trace", ",", "colors", ",", "pid", "bool", ")", "*", "Logger", "{", "flags", ":=", "0", "\n", "if", "time", "{", "flags", "=", "log", ".", "LstdFlags", "|", "log", ".", "Lmicroseconds", "\n", "}", "\n\n", "pre", ":=", "\"", "\"", "\n", "if", "pid", "{", "pre", "=", "pidPrefix", "(", ")", "\n", "}", "\n\n", "l", ":=", "&", "Logger", "{", "logger", ":", "log", ".", "New", "(", "os", ".", "Stderr", ",", "pre", ",", "flags", ")", ",", "debug", ":", "debug", ",", "trace", ":", "trace", ",", "}", "\n\n", "if", "colors", "{", "setColoredLabelFormats", "(", "l", ")", "\n", "}", "else", "{", "setPlainLabelFormats", "(", "l", ")", "\n", "}", "\n\n", "return", "l", "\n", "}" ]

[ "NewStdLogger", "creates", "a", "logger", "with", "output", "directed", "to", "Stderr" ]

[ "func", "NewFileLogger", "(", "filename", "string", ",", "time", ",", "debug", ",", "trace", ",", "pid", "bool", ")", "*", "Logger", "{", "fileflags", ":=", "os", ".", "O_WRONLY", "|", "os", ".", "O_APPEND", "|", "os", ".", "O_CREATE", "\n", "f", ",", "err", ":=", "os", ".", "OpenFile", "(", "filename", ",", "fileflags", ",", "0660", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "flags", ":=", "0", "\n", "if", "time", "{", "flags", "=", "log", ".", "LstdFlags", "|", "log", ".", "Lmicroseconds", "\n", "}", "\n\n", "pre", ":=", "\"", "\"", "\n", "if", "pid", "{", "pre", "=", "pidPrefix", "(", ")", "\n", "}", "\n\n", "l", ":=", "&", "Logger", "{", "logger", ":", "log", ".", "New", "(", "f", ",", "pre", ",", "flags", ")", ",", "debug", ":", "debug", ",", "trace", ":", "trace", ",", "logFile", ":", "f", ",", "}", "\n\n", "setPlainLabelFormats", "(", "l", ")", "\n", "return", "l", "\n", "}" ]

[ "NewFileLogger", "creates", "a", "logger", "with", "output", "directed", "to", "a", "file" ]

[ "func", "(", "l", "*", "Logger", ")", "Close", "(", ")", "error", "{", "if", "f", ":=", "l", ".", "logFile", ";", "f", "!=", "nil", "{", "l", ".", "logFile", "=", "nil", "\n", "return", "f", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "implements", "the", "io", ".", "Closer", "interface", "to", "clean", "up", "resources", "in", "the", "server", "s", "logger", "implementation", ".", "Caller", "must", "ensure", "threadsafety", "." ]

[ "func", "(", "l", "*", "Logger", ")", "Warnf", "(", "format", "string", ",", "v", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", ".", "Printf", "(", "l", ".", "warnLabel", "+", "format", ",", "v", "...", ")", "\n", "}" ]

[ "Warnf", "logs", "a", "notice", "statement" ]

[ "func", "(", "c", "*", "client", ")", "addReplySubTimeout", "(", "acc", "*", "Account", ",", "sub", "*", "subscription", ",", "d", "time", ".", "Duration", ")", "{", "if", "c", ".", "route", ".", "replySubs", "==", "nil", "{", "c", ".", "route", ".", "replySubs", "=", "make", "(", "map", "[", "*", "subscription", "]", "*", "time", ".", "Timer", ")", "\n", "}", "\n", "rs", ":=", "c", ".", "route", ".", "replySubs", "\n", "rs", "[", "sub", "]", "=", "time", ".", "AfterFunc", "(", "d", ",", "func", "(", ")", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "delete", "(", "rs", ",", "sub", ")", "\n", "sub", ".", "max", "=", "0", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "c", ".", "unsubscribe", "(", "acc", ",", "sub", ",", "true", ")", "\n", "}", ")", "\n", "}" ]

[ "This", "will", "add", "a", "timer", "to", "watch", "over", "remote", "reply", "subjects", "in", "case", "they", "fail", "to", "receive", "a", "response", ".", "The", "duration", "will", "be", "taken", "from", "the", "accounts", "map", "timeout", "to", "match", ".", "Lock", "should", "be", "held", "upon", "entering", "." ]

[ "func", "(", "c", "*", "client", ")", "removeReplySub", "(", "sub", "*", "subscription", ")", "{", "if", "sub", "==", "nil", "{", "return", "\n", "}", "\n", "// Lookup the account based on sub.sid.", "if", "i", ":=", "bytes", ".", "Index", "(", "sub", ".", "sid", ",", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "i", ">", "0", "{", "// First part of SID for route is account name.", "if", "acc", ",", "_", ":=", "c", ".", "srv", ".", "LookupAccount", "(", "string", "(", "sub", ".", "sid", "[", ":", "i", "]", ")", ")", ";", "acc", "!=", "nil", "{", "acc", ".", "sl", ".", "Remove", "(", "sub", ")", "\n", "}", "\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "c", ".", "removeReplySubTimeout", "(", "sub", ")", "\n", "delete", "(", "c", ".", "subs", ",", "string", "(", "sub", ".", "sid", ")", ")", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "}" ]

[ "removeReplySub", "is", "called", "when", "we", "trip", "the", "max", "on", "remoteReply", "subs", "." ]

[ "func", "(", "c", "*", "client", ")", "removeReplySubTimeout", "(", "sub", "*", "subscription", ")", "{", "// Remove any reply sub timer if it exists.", "if", "c", ".", "route", "==", "nil", "||", "c", ".", "route", ".", "replySubs", "==", "nil", "{", "return", "\n", "}", "\n", "if", "t", ",", "ok", ":=", "c", ".", "route", ".", "replySubs", "[", "sub", "]", ";", "ok", "{", "t", ".", "Stop", "(", ")", "\n", "delete", "(", "c", ".", "route", ".", "replySubs", ",", "sub", ")", "\n", "}", "\n", "}" ]

[ "removeReplySubTimeout", "will", "remove", "a", "timer", "if", "it", "exists", ".", "Lock", "should", "be", "held", "upon", "entering", "." ]

[ "func", "(", "c", "*", "client", ")", "processInboundRoutedMsg", "(", "msg", "[", "]", "byte", ")", "{", "// Update statistics", "c", ".", "in", ".", "msgs", "++", "\n", "// The msg includes the CR_LF, so pull back out for accounting.", "c", ".", "in", ".", "bytes", "+=", "int32", "(", "len", "(", "msg", ")", "-", "LEN_CR_LF", ")", "\n\n", "if", "c", ".", "trace", "{", "c", ".", "traceMsg", "(", "msg", ")", "\n", "}", "\n\n", "if", "c", ".", "opts", ".", "Verbose", "{", "c", ".", "sendOK", "(", ")", "\n", "}", "\n\n", "// Mostly under testing scenarios.", "if", "c", ".", "srv", "==", "nil", "{", "return", "\n", "}", "\n\n", "acc", ",", "r", ":=", "c", ".", "getAccAndResultFromCache", "(", ")", "\n", "if", "acc", "==", "nil", "{", "c", ".", "Debugf", "(", "\"", "\"", ",", "c", ".", "pa", ".", "account", ",", "c", ".", "pa", ".", "subject", ")", "\n", "return", "\n", "}", "\n\n", "// Check to see if we need to map/route to another account.", "if", "acc", ".", "imports", ".", "services", "!=", "nil", "{", "c", ".", "checkForImportServices", "(", "acc", ",", "msg", ")", "\n", "}", "\n\n", "// Check for no interest, short circuit if so.", "// This is the fanout scale.", "if", "len", "(", "r", ".", "psubs", ")", "+", "len", "(", "r", ".", "qsubs", ")", "==", "0", "{", "return", "\n", "}", "\n\n", "// Check to see if we have a routed message with a service reply.", "if", "isServiceReply", "(", "c", ".", "pa", ".", "reply", ")", "&&", "acc", "!=", "nil", "{", "// Need to add a sub here for local interest to send a response back", "// to the originating server/requestor where it will be re-mapped.", "sid", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "len", "(", "acc", ".", "Name", ")", "+", "len", "(", "c", ".", "pa", ".", "reply", ")", "+", "1", ")", "\n", "sid", "=", "append", "(", "sid", ",", "acc", ".", "Name", "...", ")", "\n", "sid", "=", "append", "(", "sid", ",", "' '", ")", "\n", "sid", "=", "append", "(", "sid", ",", "c", ".", "pa", ".", "reply", "...", ")", "\n", "// Copy off the reply since otherwise we are referencing a buffer that will be reused.", "reply", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "c", ".", "pa", ".", "reply", ")", ")", "\n", "copy", "(", "reply", ",", "c", ".", "pa", ".", "reply", ")", "\n", "sub", ":=", "&", "subscription", "{", "client", ":", "c", ",", "subject", ":", "reply", ",", "sid", ":", "sid", ",", "max", ":", "1", "}", "\n", "if", "err", ":=", "acc", ".", "sl", ".", "Insert", "(", "sub", ")", ";", "err", "!=", "nil", "{", "c", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "ttl", ":=", "acc", ".", "AutoExpireTTL", "(", ")", "\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "c", ".", "subs", "[", "string", "(", "sid", ")", "]", "=", "sub", "\n", "c", ".", "addReplySubTimeout", "(", "acc", ",", "sub", ",", "ttl", ")", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "}", "\n", "c", ".", "processMsgResults", "(", "acc", ",", "r", ",", "msg", ",", "c", ".", "pa", ".", "subject", ",", "c", ".", "pa", ".", "reply", ",", "pmrNoFlag", ")", "\n", "}" ]

[ "processInboundRouteMsg", "is", "called", "to", "process", "an", "inbound", "msg", "from", "a", "route", "." ]

[ "func", "(", "c", "*", "client", ")", "makeQFilter", "(", "qsubs", "[", "]", "[", "]", "*", "subscription", ")", "{", "qs", ":=", "make", "(", "[", "]", "[", "]", "byte", ",", "0", ",", "len", "(", "qsubs", ")", ")", "\n", "for", "_", ",", "qsub", ":=", "range", "qsubs", "{", "if", "len", "(", "qsub", ")", ">", "0", "{", "qs", "=", "append", "(", "qs", ",", "qsub", "[", "0", "]", ".", "queue", ")", "\n", "}", "\n", "}", "\n", "c", ".", "pa", ".", "queues", "=", "qs", "\n", "}" ]

[ "Helper", "function", "for", "routes", "and", "gateways", "to", "create", "qfilters", "need", "for", "converted", "subs", "from", "imports", "etc", "." ]

[ "func", "(", "c", "*", "client", ")", "processRouteInfo", "(", "info", "*", "Info", ")", "{", "// We may need to update route permissions and will need the account", "// sublist. Since getting the account requires server lock, do the", "// lookup now.", "// FIXME(dlc) - Add account scoping.", "gacc", ":=", "c", ".", "srv", ".", "globalAccount", "(", ")", "\n", "gacc", ".", "mu", ".", "RLock", "(", ")", "\n", "sl", ":=", "gacc", ".", "sl", "\n", "gacc", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "// Connection can be closed at any time (by auth timeout, etc).", "// Does not make sense to continue here if connection is gone.", "if", "c", ".", "route", "==", "nil", "||", "c", ".", "nc", "==", "nil", "{", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n\n", "s", ":=", "c", ".", "srv", "\n", "remoteID", ":=", "c", ".", "route", ".", "remoteID", "\n\n", "// Check if this is an INFO for gateways...", "if", "info", ".", "Gateway", "!=", "\"", "\"", "{", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "// If this server has no gateway configured, report error and return.", "if", "!", "s", ".", "gateway", ".", "enabled", "{", "// FIXME: Should this be a Fatalf()?", "s", ".", "Errorf", "(", "\"", "\"", ",", "info", ".", "Gateway", ",", "remoteID", ")", "\n", "return", "\n", "}", "\n", "s", ".", "processGatewayInfoFromRoute", "(", "info", ",", "remoteID", ",", "c", ")", "\n", "return", "\n", "}", "\n\n", "// We receive an INFO from a server that informs us about another server,", "// so the info.ID in the INFO protocol does not match the ID of this route.", "if", "remoteID", "!=", "\"", "\"", "&&", "remoteID", "!=", "info", ".", "ID", "{", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Process this implicit route. We will check that it is not an explicit", "// route and/or that it has not been connected already.", "s", ".", "processImplicitRoute", "(", "info", ")", "\n", "return", "\n", "}", "\n\n", "// Need to set this for the detection of the route to self to work", "// in closeConnection().", "c", ".", "route", ".", "remoteID", "=", "info", ".", "ID", "\n\n", "// Get the route's proto version", "c", ".", "opts", ".", "Protocol", "=", "info", ".", "Proto", "\n\n", "// Detect route to self.", "if", "c", ".", "route", ".", "remoteID", "==", "s", ".", "info", ".", "ID", "{", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "c", ".", "closeConnection", "(", "DuplicateRoute", ")", "\n", "return", "\n", "}", "\n\n", "// Copy over important information.", "c", ".", "route", ".", "authRequired", "=", "info", ".", "AuthRequired", "\n", "c", ".", "route", ".", "tlsRequired", "=", "info", ".", "TLSRequired", "\n", "c", ".", "route", ".", "gatewayURL", "=", "info", ".", "GatewayURL", "\n", "// When sent through route INFO, if the field is set, it should be of size 1.", "if", "len", "(", "info", ".", "LeafNodeURLs", ")", "==", "1", "{", "c", ".", "route", ".", "leafnodeURL", "=", "info", ".", "LeafNodeURLs", "[", "0", "]", "\n", "}", "\n\n", "// If this is an update due to config reload on the remote server,", "// need to possibly send local subs to the remote server.", "if", "c", ".", "flags", ".", "isSet", "(", "infoReceived", ")", "{", "c", ".", "updateRemoteRoutePerms", "(", "sl", ",", "info", ")", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n\n", "// Copy over permissions as well.", "c", ".", "opts", ".", "Import", "=", "info", ".", "Import", "\n", "c", ".", "opts", ".", "Export", "=", "info", ".", "Export", "\n\n", "// If we do not know this route's URL, construct one on the fly", "// from the information provided.", "if", "c", ".", "route", ".", "url", "==", "nil", "{", "// Add in the URL from host and port", "hp", ":=", "net", ".", "JoinHostPort", "(", "info", ".", "Host", ",", "strconv", ".", "Itoa", "(", "info", ".", "Port", ")", ")", "\n", "url", ",", "err", ":=", "url", ".", "Parse", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "hp", ")", ")", "\n", "if", "err", "!=", "nil", "{", "c", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "c", ".", "closeConnection", "(", "ParseError", ")", "\n", "return", "\n", "}", "\n", "c", ".", "route", ".", "url", "=", "url", "\n", "}", "\n\n", "// Mark that the INFO protocol has been received. Will allow", "// to detect INFO updates.", "c", ".", "flags", ".", "set", "(", "infoReceived", ")", "\n\n", "// Check to see if we have this remote already registered.", "// This can happen when both servers have routes to each other.", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "added", ",", "sendInfo", ":=", "s", ".", "addRoute", "(", "c", ",", "info", ")", ";", "added", "{", "c", ".", "Debugf", "(", "\"", "\"", ",", "info", ".", "ID", ")", "\n\n", "// Send our subs to the other side.", "s", ".", "sendSubsToRoute", "(", "c", ")", "\n\n", "// Send info about the known gateways to this route.", "s", ".", "sendGatewayConfigsToRoute", "(", "c", ")", "\n\n", "// sendInfo will be false if the route that we just accepted", "// is the only route there is.", "if", "sendInfo", "{", "// The incoming INFO from the route will have IP set", "// if it has Cluster.Advertise. In that case, use that", "// otherwise contruct it from the remote TCP address.", "if", "info", ".", "IP", "==", "\"", "\"", "{", "// Need to get the remote IP address.", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "switch", "conn", ":=", "c", ".", "nc", ".", "(", "type", ")", "{", "case", "*", "net", ".", "TCPConn", ",", "*", "tls", ".", "Conn", ":", "addr", ":=", "conn", ".", "RemoteAddr", "(", ")", ".", "(", "*", "net", ".", "TCPAddr", ")", "\n", "info", ".", "IP", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "net", ".", "JoinHostPort", "(", "addr", ".", "IP", ".", "String", "(", ")", ",", "strconv", ".", "Itoa", "(", "info", ".", "Port", ")", ")", ")", "\n", "default", ":", "info", ".", "IP", "=", "c", ".", "route", ".", "url", ".", "String", "(", ")", "\n", "}", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "// Now let the known servers know about this new route", "s", ".", "forwardNewRouteInfoToKnownServers", "(", "info", ")", "\n", "}", "\n", "// Unless disabled, possibly update the server's INFO protocol", "// and send to clients that know how to handle async INFOs.", "if", "!", "s", ".", "getOpts", "(", ")", ".", "Cluster", ".", "NoAdvertise", "{", "s", ".", "addClientConnectURLsAndSendINFOToClients", "(", "info", ".", "ClientConnectURLs", ")", "\n", "}", "\n", "}", "else", "{", "c", ".", "Debugf", "(", "\"", "\"", ",", "info", ".", "ID", ")", "\n", "c", ".", "closeConnection", "(", "DuplicateRoute", ")", "\n", "}", "\n", "}" ]

[ "Process", "the", "info", "message", "if", "we", "are", "a", "route", "." ]

[ "func", "(", "c", "*", "client", ")", "updateRemoteRoutePerms", "(", "sl", "*", "Sublist", ",", "info", "*", "Info", ")", "{", "// Interested only on Export permissions for the remote server.", "// Create \"fake\" clients that we will use to check permissions", "// using the old permissions...", "oldPerms", ":=", "&", "RoutePermissions", "{", "Export", ":", "c", ".", "opts", ".", "Export", "}", "\n", "oldPermsTester", ":=", "&", "client", "{", "}", "\n", "oldPermsTester", ".", "setRoutePermissions", "(", "oldPerms", ")", "\n", "// and the new ones.", "newPerms", ":=", "&", "RoutePermissions", "{", "Export", ":", "info", ".", "Export", "}", "\n", "newPermsTester", ":=", "&", "client", "{", "}", "\n", "newPermsTester", ".", "setRoutePermissions", "(", "newPerms", ")", "\n\n", "c", ".", "opts", ".", "Import", "=", "info", ".", "Import", "\n", "c", ".", "opts", ".", "Export", "=", "info", ".", "Export", "\n\n", "var", "(", "_localSubs", "[", "4096", "]", "*", "subscription", "\n", "localSubs", "=", "_localSubs", "[", ":", "0", "]", "\n", ")", "\n", "sl", ".", "localSubs", "(", "&", "localSubs", ")", "\n\n", "c", ".", "sendRouteSubProtos", "(", "localSubs", ",", "false", ",", "func", "(", "sub", "*", "subscription", ")", "bool", "{", "subj", ":=", "string", "(", "sub", ".", "subject", ")", "\n", "// If the remote can now export but could not before, and this server can import this", "// subject, then send SUB protocol.", "if", "newPermsTester", ".", "canExport", "(", "subj", ")", "&&", "!", "oldPermsTester", ".", "canExport", "(", "subj", ")", "&&", "c", ".", "canImport", "(", "subj", ")", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n", "}" ]

[ "Possibly", "sends", "local", "subscriptions", "interest", "to", "this", "route", "based", "on", "changes", "in", "the", "remote", "s", "Export", "permissions", ".", "Lock", "assumed", "held", "on", "entry" ]

[ "func", "(", "s", "*", "Server", ")", "sendAsyncInfoToClients", "(", ")", "{", "// If there are no clients supporting async INFO protocols, we are done.", "// Also don't send if we are shutting down...", "if", "s", ".", "cproto", "==", "0", "||", "s", ".", "shutdown", "{", "return", "\n", "}", "\n\n", "for", "_", ",", "c", ":=", "range", "s", ".", "clients", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "// Here, we are going to send only to the clients that are fully", "// registered (server has received CONNECT and first PING). For", "// clients that are not at this stage, this will happen in the", "// processing of the first PING (see client.processPing)", "if", "c", ".", "opts", ".", "Protocol", ">=", "ClientProtoInfo", "&&", "c", ".", "flags", ".", "isSet", "(", "firstPongSent", ")", "{", "// sendInfo takes care of checking if the connection is still", "// valid or not, so don't duplicate tests here.", "c", ".", "sendInfo", "(", "c", ".", "generateClientInfoJSON", "(", "s", ".", "copyInfo", "(", ")", ")", ")", "\n", "}", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "}" ]

[ "sendAsyncInfoToClients", "sends", "an", "INFO", "protocol", "to", "all", "connected", "clients", "that", "accept", "async", "INFO", "updates", ".", "The", "server", "lock", "is", "held", "on", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "processImplicitRoute", "(", "info", "*", "Info", ")", "{", "remoteID", ":=", "info", ".", "ID", "\n\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Don't connect to ourself", "if", "remoteID", "==", "s", ".", "info", ".", "ID", "{", "return", "\n", "}", "\n", "// Check if this route already exists", "if", "_", ",", "exists", ":=", "s", ".", "remotes", "[", "remoteID", "]", ";", "exists", "{", "return", "\n", "}", "\n", "// Check if we have this route as a configured route", "if", "s", ".", "hasThisRouteConfigured", "(", "info", ")", "{", "return", "\n", "}", "\n\n", "// Initiate the connection, using info.IP instead of info.URL here...", "r", ",", "err", ":=", "url", ".", "Parse", "(", "info", ".", "IP", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// Snapshot server options.", "opts", ":=", "s", ".", "getOpts", "(", ")", "\n\n", "if", "info", ".", "AuthRequired", "{", "r", ".", "User", "=", "url", ".", "UserPassword", "(", "opts", ".", "Cluster", ".", "Username", ",", "opts", ".", "Cluster", ".", "Password", ")", "\n", "}", "\n", "s", ".", "startGoRoutine", "(", "func", "(", ")", "{", "s", ".", "connectToRoute", "(", "r", ",", "false", ")", "}", ")", "\n", "}" ]

[ "This", "will", "process", "implicit", "route", "information", "received", "from", "another", "server", ".", "We", "will", "check", "to", "see", "if", "we", "have", "configured", "or", "are", "already", "connected", "and", "if", "so", "we", "will", "ignore", ".", "Otherwise", "we", "will", "attempt", "to", "connect", "." ]

[ "func", "(", "s", "*", "Server", ")", "forwardNewRouteInfoToKnownServers", "(", "info", "*", "Info", ")", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "b", ",", "_", ":=", "json", ".", "Marshal", "(", "info", ")", "\n", "infoJSON", ":=", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "InfoProto", ",", "b", ")", ")", "\n\n", "for", "_", ",", "r", ":=", "range", "s", ".", "routes", "{", "r", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "r", ".", "route", ".", "remoteID", "!=", "info", ".", "ID", "{", "r", ".", "sendInfo", "(", "infoJSON", ")", "\n", "}", "\n", "r", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "}" ]

[ "forwardNewRouteInfoToKnownServers", "sends", "the", "INFO", "protocol", "of", "the", "new", "route", "to", "all", "routes", "known", "by", "this", "server", ".", "In", "turn", "each", "server", "will", "contact", "this", "new", "route", "." ]

[ "func", "(", "c", "*", "client", ")", "setRoutePermissions", "(", "perms", "*", "RoutePermissions", ")", "{", "// Reset if some were set", "if", "perms", "==", "nil", "{", "c", ".", "perms", "=", "nil", "\n", "c", ".", "mperms", "=", "nil", "\n", "return", "\n", "}", "\n", "// Convert route permissions to user permissions.", "// The Import permission is mapped to Publish", "// and Export permission is mapped to Subscribe.", "// For meaning of Import/Export, see canImport and canExport.", "p", ":=", "&", "Permissions", "{", "Publish", ":", "perms", ".", "Import", ",", "Subscribe", ":", "perms", ".", "Export", ",", "}", "\n", "c", ".", "setPermissions", "(", "p", ")", "\n", "}" ]

[ "Initialize", "or", "reset", "cluster", "s", "permissions", ".", "This", "is", "for", "ROUTER", "connections", "only", ".", "Client", "lock", "is", "held", "on", "entry" ]

[ "func", "(", "c", "*", "client", ")", "removeRemoteSubs", "(", ")", "{", "// We need to gather these on a per account basis.", "// FIXME(dlc) - We should be smarter about this..", "as", ":=", "map", "[", "string", "]", "*", "asubs", "{", "}", "\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "srv", ":=", "c", ".", "srv", "\n", "subs", ":=", "c", ".", "subs", "\n", "c", ".", "subs", "=", "make", "(", "map", "[", "string", "]", "*", "subscription", ")", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "for", "key", ",", "sub", ":=", "range", "subs", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "sub", ".", "max", "=", "0", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "// Grab the account", "accountName", ":=", "strings", ".", "Fields", "(", "key", ")", "[", "0", "]", "\n", "ase", ":=", "as", "[", "accountName", "]", "\n", "if", "ase", "==", "nil", "{", "acc", ",", "_", ":=", "srv", ".", "LookupAccount", "(", "accountName", ")", "\n", "if", "acc", "==", "nil", "{", "continue", "\n", "}", "\n", "as", "[", "accountName", "]", "=", "&", "asubs", "{", "acc", ":", "acc", ",", "subs", ":", "[", "]", "*", "subscription", "{", "sub", "}", "}", "\n", "}", "else", "{", "ase", ".", "subs", "=", "append", "(", "ase", ".", "subs", ",", "sub", ")", "\n", "}", "\n", "if", "srv", ".", "gateway", ".", "enabled", "{", "srv", ".", "gatewayUpdateSubInterest", "(", "accountName", ",", "sub", ",", "-", "1", ")", "\n", "}", "\n", "}", "\n\n", "// Now remove the subs by batch for each account sublist.", "for", "_", ",", "ase", ":=", "range", "as", "{", "c", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "ase", ".", "subs", ")", ",", "ase", ".", "acc", ".", "Name", ")", "\n", "ase", ".", "acc", ".", "sl", ".", "RemoveBatch", "(", "ase", ".", "subs", ")", "\n", "}", "\n", "}" ]

[ "removeRemoteSubs", "will", "walk", "the", "subs", "and", "remove", "them", "from", "the", "appropriate", "account", "." ]

[ "func", "(", "s", "*", "Server", ")", "sendSubsToRoute", "(", "route", "*", "client", ")", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "// Estimated size of all protocols. It does not have to be accurate at all.", "eSize", ":=", "0", "\n", "// Send over our account subscriptions.", "// copy accounts into array first", "accs", ":=", "make", "(", "[", "]", "*", "Account", ",", "0", ",", "32", ")", "\n", "s", ".", "accounts", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "a", ":=", "v", ".", "(", "*", "Account", ")", "\n", "accs", "=", "append", "(", "accs", ",", "a", ")", "\n", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "// Proto looks like: \"RS+ <account name> <subject>[ <queue weight>]\\r\\n\"", "// If we wanted to have better estimates (or even accurate), we would", "// collect the subs here instead of capturing the accounts and then", "// later going over each account.", "eSize", "+=", "len", "(", "a", ".", "rm", ")", "*", "(", "4", "+", "len", "(", "a", ".", "Name", ")", "+", "256", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "true", "\n", "}", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "sendSubs", ":=", "func", "(", "accs", "[", "]", "*", "Account", ")", "{", "var", "raw", "[", "32", "]", "*", "subscription", "\n", "var", "closed", "bool", "\n\n", "route", ".", "mu", ".", "Lock", "(", ")", "\n", "for", "_", ",", "a", ":=", "range", "accs", "{", "subs", ":=", "raw", "[", ":", "0", "]", "\n\n", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "c", ":=", "a", ".", "randomClient", "(", ")", "\n", "if", "c", "==", "nil", "{", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "continue", "\n", "}", "\n", "for", "key", ",", "n", ":=", "range", "a", ".", "rm", "{", "// FIXME(dlc) - Just pass rme around.", "// Construct a sub on the fly. We need to place", "// a client (or im) to properly set the account.", "var", "subj", ",", "qn", "[", "]", "byte", "\n", "s", ":=", "strings", ".", "Split", "(", "key", ",", "\"", "\"", ")", "\n", "subj", "=", "[", "]", "byte", "(", "s", "[", "0", "]", ")", "\n", "if", "len", "(", "s", ")", ">", "1", "{", "qn", "=", "[", "]", "byte", "(", "s", "[", "1", "]", ")", "\n", "}", "\n", "// TODO(dlc) - This code needs to change, but even if left alone could be more", "// efficient with these tmp subs.", "sub", ":=", "&", "subscription", "{", "client", ":", "c", ",", "subject", ":", "subj", ",", "queue", ":", "qn", ",", "qw", ":", "n", "}", "\n", "subs", "=", "append", "(", "subs", ",", "sub", ")", "\n\n", "}", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "closed", "=", "route", ".", "sendRouteSubProtos", "(", "subs", ",", "false", ",", "func", "(", "sub", "*", "subscription", ")", "bool", "{", "return", "route", ".", "canImport", "(", "string", "(", "sub", ".", "subject", ")", ")", "\n", "}", ")", "\n\n", "if", "closed", "{", "route", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "route", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "!", "closed", "{", "route", ".", "Debugf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "// Decide if we call above function in go routine or in place.", "if", "eSize", ">", "sendRouteSubsInGoRoutineThreshold", "{", "s", ".", "startGoRoutine", "(", "func", "(", ")", "{", "sendSubs", "(", "accs", ")", "\n", "s", ".", "grWG", ".", "Done", "(", ")", "\n", "}", ")", "\n", "}", "else", "{", "sendSubs", "(", "accs", ")", "\n", "}", "\n", "}" ]

[ "sendSubsToRoute", "will", "send", "over", "our", "subject", "interest", "to", "the", "remote", "side", ".", "For", "each", "account", "we", "will", "send", "the", "complete", "interest", "for", "all", "subjects", "both", "normal", "as", "a", "binary", "and", "queue", "group", "weights", "." ]

[ "func", "(", "c", "*", "client", ")", "sendRouteSubProtos", "(", "subs", "[", "]", "*", "subscription", ",", "trace", "bool", ",", "filter", "func", "(", "sub", "*", "subscription", ")", "bool", ")", "bool", "{", "return", "c", ".", "sendRouteSubOrUnSubProtos", "(", "subs", ",", "true", ",", "trace", ",", "filter", ")", "\n", "}" ]

[ "Sends", "SUBs", "protocols", "for", "the", "given", "subscriptions", ".", "If", "a", "filter", "is", "specified", "it", "is", "invoked", "for", "each", "subscription", ".", "If", "the", "filter", "returns", "false", "the", "subscription", "is", "skipped", ".", "This", "function", "may", "release", "the", "route", "s", "lock", "due", "to", "flushing", "of", "outbound", "data", ".", "A", "boolean", "is", "returned", "to", "indicate", "if", "the", "connection", "has", "been", "closed", "during", "this", "call", ".", "Lock", "is", "held", "on", "entry", "." ]

[ "func", "(", "c", "*", "client", ")", "sendRouteUnSubProtos", "(", "subs", "[", "]", "*", "subscription", ",", "trace", "bool", ",", "filter", "func", "(", "sub", "*", "subscription", ")", "bool", ")", "bool", "{", "return", "c", ".", "sendRouteSubOrUnSubProtos", "(", "subs", ",", "false", ",", "trace", ",", "filter", ")", "\n", "}" ]

[ "Sends", "UNSUBs", "protocols", "for", "the", "given", "subscriptions", ".", "If", "a", "filter", "is", "specified", "it", "is", "invoked", "for", "each", "subscription", ".", "If", "the", "filter", "returns", "false", "the", "subscription", "is", "skipped", ".", "This", "function", "may", "release", "the", "route", "s", "lock", "due", "to", "flushing", "of", "outbound", "data", ".", "A", "boolean", "is", "returned", "to", "indicate", "if", "the", "connection", "has", "been", "closed", "during", "this", "call", ".", "Lock", "is", "held", "on", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "updateRouteSubscriptionMap", "(", "acc", "*", "Account", ",", "sub", "*", "subscription", ",", "delta", "int32", ")", "{", "if", "acc", "==", "nil", "||", "sub", "==", "nil", "{", "return", "\n", "}", "\n", "acc", ".", "mu", ".", "RLock", "(", ")", "\n", "rm", ":=", "acc", ".", "rm", "\n", "acc", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "// This is non-nil when we know we are in cluster mode.", "if", "rm", "==", "nil", "{", "return", "\n", "}", "\n\n", "// We only store state on local subs for transmission across all other routes.", "if", "sub", ".", "client", "==", "nil", "||", "(", "sub", ".", "client", ".", "kind", "!=", "CLIENT", "&&", "sub", ".", "client", ".", "kind", "!=", "SYSTEM", "&&", "sub", ".", "client", ".", "kind", "!=", "LEAF", ")", "{", "return", "\n", "}", "\n\n", "// Create the fast key which will use the subject or 'subject<spc>queue' for queue subscribers.", "var", "(", "_rkey", "[", "1024", "]", "byte", "\n", "key", "[", "]", "byte", "\n", "update", "bool", "\n", ")", "\n", "if", "sub", ".", "queue", "!=", "nil", "{", "// Just make the key subject spc group, e.g. 'foo bar'", "key", "=", "_rkey", "[", ":", "0", "]", "\n", "key", "=", "append", "(", "key", ",", "sub", ".", "subject", "...", ")", "\n", "key", "=", "append", "(", "key", ",", "byte", "(", "' '", ")", ")", "\n", "key", "=", "append", "(", "key", ",", "sub", ".", "queue", "...", ")", "\n", "// We always update for a queue subscriber since we need to send our relative weight.", "update", "=", "true", "\n", "}", "else", "{", "key", "=", "sub", ".", "subject", "\n", "}", "\n\n", "// Copy to hold outside acc lock.", "var", "n", "int32", "\n", "var", "ok", "bool", "\n\n", "acc", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "n", ",", "ok", "=", "rm", "[", "string", "(", "key", ")", "]", ";", "ok", "{", "n", "+=", "delta", "\n", "if", "n", "<=", "0", "{", "delete", "(", "rm", ",", "string", "(", "key", ")", ")", "\n", "update", "=", "true", "// Update for deleting (N->0)", "\n", "}", "else", "{", "rm", "[", "string", "(", "key", ")", "]", "=", "n", "\n", "}", "\n", "}", "else", "if", "delta", ">", "0", "{", "n", "=", "delta", "\n", "rm", "[", "string", "(", "key", ")", "]", "=", "delta", "\n", "update", "=", "true", "// Adding a new entry for normal sub means update (0->1)", "\n", "}", "\n", "acc", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "!", "update", "{", "return", "\n", "}", "\n", "// We need to send out this update.", "// If we are sending a queue sub, copy and place in the queue weight.", "if", "sub", ".", "queue", "!=", "nil", "{", "sub", ".", "client", ".", "mu", ".", "Lock", "(", ")", "\n", "nsub", ":=", "*", "sub", "\n", "sub", ".", "client", ".", "mu", ".", "Unlock", "(", ")", "\n", "nsub", ".", "qw", "=", "n", "\n", "sub", "=", "&", "nsub", "\n", "}", "\n\n", "// Note that queue unsubs where entry.n > 0 are still", "// subscribes with a smaller weight.", "if", "n", ">", "0", "{", "s", ".", "broadcastSubscribe", "(", "sub", ")", "\n", "}", "else", "{", "s", ".", "broadcastUnSubscribe", "(", "sub", ")", "\n", "}", "\n", "}" ]

[ "updateRouteSubscriptionMap", "will", "make", "sure", "to", "update", "the", "route", "map", "for", "the", "subscription", ".", "Will", "also", "forward", "to", "all", "routes", "if", "needed", "." ]

[ "func", "(", "s", "*", "Server", ")", "broadcastUnSubscribe", "(", "sub", "*", "subscription", ")", "{", "trace", ":=", "atomic", ".", "LoadInt32", "(", "&", "s", ".", "logging", ".", "trace", ")", "==", "1", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "subs", ":=", "[", "]", "*", "subscription", "{", "sub", "}", "\n", "for", "_", ",", "route", ":=", "range", "s", ".", "routes", "{", "route", ".", "mu", ".", "Lock", "(", ")", "\n", "route", ".", "sendRouteUnSubProtos", "(", "subs", ",", "trace", ",", "func", "(", "sub", "*", "subscription", ")", "bool", "{", "return", "route", ".", "canImport", "(", "string", "(", "sub", ".", "subject", ")", ")", "\n", "}", ")", "\n", "route", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "broadcastUnSubscribe", "will", "forward", "a", "client", "unsubscribe", "action", "to", "all", "active", "routes", "." ]

[ "func", "(", "s", "*", "Server", ")", "setRouteInfoHostPortAndIP", "(", ")", "error", "{", "if", "s", ".", "opts", ".", "Cluster", ".", "Advertise", "!=", "\"", "\"", "{", "advHost", ",", "advPort", ",", "err", ":=", "parseHostPort", "(", "s", ".", "opts", ".", "Cluster", ".", "Advertise", ",", "s", ".", "opts", ".", "Cluster", ".", "Port", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "s", ".", "routeInfo", ".", "Host", "=", "advHost", "\n", "s", ".", "routeInfo", ".", "Port", "=", "advPort", "\n", "s", ".", "routeInfo", ".", "IP", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "net", ".", "JoinHostPort", "(", "advHost", ",", "strconv", ".", "Itoa", "(", "advPort", ")", ")", ")", "\n", "}", "else", "{", "s", ".", "routeInfo", ".", "Host", "=", "s", ".", "opts", ".", "Cluster", ".", "Host", "\n", "s", ".", "routeInfo", ".", "Port", "=", "s", ".", "opts", ".", "Cluster", ".", "Port", "\n", "s", ".", "routeInfo", ".", "IP", "=", "\"", "\"", "\n", "}", "\n", "// (re)generate the routeInfoJSON byte array", "s", ".", "generateRouteInfoJSON", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Similar", "to", "setInfoHostPortAndGenerateJSON", "but", "for", "routeInfo", "." ]

[ "func", "(", "s", "*", "Server", ")", "routeStillValid", "(", "rURL", "*", "url", ".", "URL", ")", "bool", "{", "for", "_", ",", "ri", ":=", "range", "s", ".", "getOpts", "(", ")", ".", "Routes", "{", "if", "urlsAreEqual", "(", "ri", ",", "rURL", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Checks", "to", "make", "sure", "the", "route", "is", "still", "valid", "." ]

[ "func", "NewSysLogger", "(", "debug", ",", "trace", "bool", ")", "*", "SysLogger", "{", "if", "err", ":=", "eventlog", ".", "InstallAsEventCreate", "(", "natsEventSource", ",", "eventlog", ".", "Info", "|", "eventlog", ".", "Error", "|", "eventlog", ".", "Warning", ")", ";", "err", "!=", "nil", "{", "if", "!", "strings", ".", "Contains", "(", "err", ".", "Error", "(", ")", ",", "\"", "\"", ")", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "}", "\n\n", "w", ",", "err", ":=", "eventlog", ".", "Open", "(", "natsEventSource", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n\n", "return", "&", "SysLogger", "{", "writer", ":", "w", ",", "debug", ":", "debug", ",", "trace", ":", "trace", ",", "}", "\n", "}" ]

[ "NewSysLogger", "creates", "a", "log", "using", "the", "windows", "event", "logger" ]

[ "func", "NewRemoteSysLogger", "(", "fqn", "string", ",", "debug", ",", "trace", "bool", ")", "*", "SysLogger", "{", "w", ",", "err", ":=", "eventlog", ".", "OpenRemote", "(", "fqn", ",", "natsEventSource", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n\n", "return", "&", "SysLogger", "{", "writer", ":", "w", ",", "debug", ":", "debug", ",", "trace", ":", "trace", ",", "}", "\n", "}" ]

[ "NewRemoteSysLogger", "creates", "a", "remote", "event", "logger" ]

[ "func", "newClosedRingBuffer", "(", "max", "int", ")", "*", "closedRingBuffer", "{", "rb", ":=", "&", "closedRingBuffer", "{", "}", "\n", "rb", ".", "conns", "=", "make", "(", "[", "]", "*", "closedClient", ",", "max", ")", "\n", "return", "rb", "\n", "}" ]

[ "Create", "a", "new", "ring", "buffer", "with", "at", "most", "max", "items", "." ]

[ "func", "(", "rb", "*", "closedRingBuffer", ")", "append", "(", "cc", "*", "closedClient", ")", "{", "rb", ".", "conns", "[", "rb", ".", "next", "(", ")", "]", "=", "cc", "\n", "rb", ".", "total", "++", "\n", "}" ]

[ "Adds", "in", "a", "new", "closed", "connection", ".", "If", "there", "is", "no", "more", "room", "remove", "the", "oldest", "." ]

[ "func", "(", "rb", "*", "closedRingBuffer", ")", "closedClients", "(", ")", "[", "]", "*", "closedClient", "{", "dup", ":=", "make", "(", "[", "]", "*", "closedClient", ",", "rb", ".", "len", "(", ")", ")", "\n", "head", ":=", "rb", ".", "next", "(", ")", "\n", "if", "rb", ".", "total", "<=", "uint64", "(", "cap", "(", "rb", ".", "conns", ")", ")", "||", "head", "==", "0", "{", "copy", "(", "dup", ",", "rb", ".", "conns", "[", ":", "rb", ".", "len", "(", ")", "]", ")", "\n", "}", "else", "{", "fp", ":=", "rb", ".", "conns", "[", "head", ":", "]", "\n", "sp", ":=", "rb", ".", "conns", "[", ":", "head", "]", "\n", "copy", "(", "dup", ",", "fp", ")", "\n", "copy", "(", "dup", "[", "len", "(", "fp", ")", ":", "]", ",", "sp", ")", "\n", "}", "\n", "return", "dup", "\n", "}" ]

[ "This", "will", "return", "a", "sorted", "copy", "of", "the", "list", "which", "recipient", "can", "modify", ".", "If", "the", "contents", "of", "the", "client", "itself", "need", "to", "be", "modified", "meaning", "swapping", "in", "any", "optional", "items", "a", "copy", "should", "be", "made", ".", "We", "could", "introduce", "a", "new", "lock", "and", "hold", "that", "but", "since", "we", "return", "this", "list", "inside", "monitor", "which", "allows", "programatic", "access", "we", "do", "not", "know", "when", "it", "would", "be", "done", "." ]

[ "func", "Run", "(", "server", "*", "Server", ")", "error", "{", "if", "dockerized", "{", "server", ".", "Start", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "run", ":=", "svc", ".", "Run", "\n", "isInteractive", ",", "err", ":=", "svc", ".", "IsAnInteractiveSession", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "isInteractive", "{", "run", "=", "debug", ".", "Run", "\n", "}", "\n", "return", "run", "(", "serviceName", ",", "&", "winServiceWrapper", "{", "server", "}", ")", "\n", "}" ]

[ "Run", "starts", "the", "NATS", "server", "as", "a", "Windows", "service", "." ]

[ "func", "(", "a", "*", "Account", ")", "shallowCopy", "(", ")", "*", "Account", "{", "na", ":=", "NewAccount", "(", "a", ".", "Name", ")", "\n", "na", ".", "Nkey", "=", "a", ".", "Nkey", "\n", "na", ".", "Issuer", "=", "a", ".", "Issuer", "\n", "na", ".", "imports", "=", "a", ".", "imports", "\n", "na", ".", "exports", "=", "a", ".", "exports", "\n", "return", "na", "\n", "}" ]

[ "Used", "to", "create", "shallow", "copies", "of", "accounts", "for", "transfer", "from", "opts", "to", "real", "accounts", "in", "server", "struct", "." ]

[ "func", "(", "a", "*", "Account", ")", "NumConnections", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "nc", ":=", "len", "(", "a", ".", "clients", ")", "+", "int", "(", "a", ".", "nrclients", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "nc", "\n", "}" ]

[ "NumClients", "returns", "active", "number", "of", "clients", "for", "this", "account", "for", "all", "known", "servers", "." ]

[ "func", "(", "a", "*", "Account", ")", "NumLocalConnections", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "nlc", ":=", "a", ".", "numLocalConnections", "(", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "nlc", "\n", "}" ]

[ "NumLocalClients", "returns", "active", "number", "of", "clients", "for", "this", "account", "on", "this", "server", "." ]

[ "func", "(", "a", "*", "Account", ")", "numLocalConnections", "(", ")", "int", "{", "return", "len", "(", "a", ".", "clients", ")", "-", "int", "(", "a", ".", "sysclients", ")", "-", "int", "(", "a", ".", "nleafs", ")", "\n", "}" ]

[ "Do", "not", "account", "for", "the", "system", "accounts", "." ]

[ "func", "(", "a", "*", "Account", ")", "MaxTotalConnectionsReached", "(", ")", "bool", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "mtc", ":=", "a", ".", "maxTotalConnectionsReached", "(", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "mtc", "\n", "}" ]

[ "MaxTotalConnectionsReached", "returns", "if", "we", "have", "reached", "our", "limit", "for", "number", "of", "connections", "." ]

[ "func", "(", "a", "*", "Account", ")", "MaxActiveConnections", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "mconns", ":=", "int", "(", "a", ".", "mconns", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "mconns", "\n", "}" ]

[ "MaxActiveConnections", "return", "the", "set", "limit", "for", "the", "account", "system", "wide", "for", "total", "number", "of", "active", "connections", "." ]

[ "func", "(", "a", "*", "Account", ")", "NumLeafNodes", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "nln", ":=", "int", "(", "a", ".", "nleafs", "+", "a", ".", "nrleafs", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "nln", "\n", "}" ]

[ "NumLeafNodes", "returns", "the", "active", "number", "of", "local", "and", "remote", "leaf", "node", "connections", "." ]

[ "func", "(", "a", "*", "Account", ")", "NumRemoteLeafNodes", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "nrn", ":=", "int", "(", "a", ".", "nrleafs", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "nrn", "\n", "}" ]

[ "NumRemoteLeafNodes", "returns", "the", "active", "number", "of", "remote", "leaf", "node", "connections", "." ]

[ "func", "(", "a", "*", "Account", ")", "RoutedSubs", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "len", "(", "a", ".", "rm", ")", "\n", "}" ]

[ "RoutedSubs", "returns", "how", "many", "subjects", "we", "would", "send", "across", "a", "route", "when", "first", "connected", "or", "expressing", "interest", ".", "Local", "client", "subs", "." ]

[ "func", "(", "a", "*", "Account", ")", "TotalSubs", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "int", "(", "a", ".", "sl", ".", "Count", "(", ")", ")", "\n", "}" ]

[ "TotalSubs", "returns", "total", "number", "of", "Subscriptions", "for", "this", "account", "." ]

[ "func", "(", "a", "*", "Account", ")", "addClient", "(", "c", "*", "client", ")", "int", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "n", ":=", "len", "(", "a", ".", "clients", ")", "\n", "if", "a", ".", "clients", "!=", "nil", "{", "a", ".", "clients", "[", "c", "]", "=", "c", "\n", "}", "\n", "added", ":=", "n", "!=", "len", "(", "a", ".", "clients", ")", "\n", "if", "added", "{", "if", "c", ".", "kind", "==", "SYSTEM", "{", "a", ".", "sysclients", "++", "\n", "}", "else", "if", "c", ".", "kind", "==", "LEAF", "{", "a", ".", "nleafs", "++", "\n", "}", "\n", "}", "\n", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "c", "!=", "nil", "&&", "c", ".", "srv", "!=", "nil", "&&", "a", "!=", "c", ".", "srv", ".", "gacc", "&&", "added", "{", "c", ".", "srv", ".", "accConnsUpdate", "(", "a", ")", "\n", "}", "\n", "return", "n", "\n", "}" ]

[ "addClient", "keeps", "our", "accounting", "of", "local", "active", "clients", "or", "leafnodes", "updated", ".", "Returns", "previous", "total", "." ]

[ "func", "(", "a", "*", "Account", ")", "numServiceRoutes", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "len", "(", "a", ".", "imports", ".", "services", ")", "\n", "}" ]

[ "numServiceRoutes", "returns", "the", "number", "of", "service", "routes", "on", "this", "account", "." ]

[ "func", "(", "a", "*", "Account", ")", "removeServiceImport", "(", "subject", "string", ")", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "si", ",", "ok", ":=", "a", ".", "imports", ".", "services", "[", "subject", "]", "\n", "if", "ok", "&&", "si", "!=", "nil", "&&", "si", ".", "ae", "{", "a", ".", "nae", "--", "\n", "}", "\n", "delete", "(", "a", ".", "imports", ".", "services", ",", "subject", ")", "\n", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "a", ".", "srv", "!=", "nil", "&&", "a", ".", "srv", ".", "gateway", ".", "enabled", "{", "a", ".", "srv", ".", "gatewayHandleServiceImport", "(", "a", ",", "[", "]", "byte", "(", "subject", ")", ",", "nil", ",", "-", "1", ")", "\n", "}", "\n", "}" ]

[ "removeServiceImport", "will", "remove", "the", "route", "by", "subject", "." ]

[ "func", "(", "a", "*", "Account", ")", "MaxAutoExpireResponseMaps", "(", ")", "int", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "int", "(", "a", ".", "maxnae", ")", "\n", "}" ]

[ "MaxAutoExpireResponseMaps", "return", "the", "maximum", "number", "of", "auto", "expire", "response", "maps", "we", "will", "allow", "." ]

[ "func", "(", "a", "*", "Account", ")", "SetMaxAutoExpireResponseMaps", "(", "max", "int", ")", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "a", ".", "maxnae", "=", "int32", "(", "max", ")", "\n", "}" ]

[ "SetMaxAutoExpireResponseMaps", "sets", "the", "max", "outstanding", "auto", "expire", "response", "maps", "." ]

[ "func", "(", "a", "*", "Account", ")", "AutoExpireTTL", "(", ")", "time", ".", "Duration", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "a", ".", "maxaettl", "\n", "}" ]

[ "AutoExpireTTL", "returns", "the", "ttl", "for", "response", "maps", "." ]

[ "func", "(", "a", "*", "Account", ")", "SetAutoExpireTTL", "(", "ttl", "time", ".", "Duration", ")", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "a", ".", "maxaettl", "=", "ttl", "\n", "}" ]

[ "SetAutoExpireTTL", "sets", "the", "ttl", "for", "response", "maps", "." ]

[ "func", "(", "a", "*", "Account", ")", "autoExpireResponseMaps", "(", ")", "[", "]", "*", "serviceImport", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "if", "len", "(", "a", ".", "imports", ".", "services", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "aesis", ":=", "make", "(", "[", "]", "*", "serviceImport", ",", "0", ",", "len", "(", "a", ".", "imports", ".", "services", ")", ")", "\n", "for", "_", ",", "si", ":=", "range", "a", ".", "imports", ".", "services", "{", "if", "si", ".", "ae", "{", "aesis", "=", "append", "(", "aesis", ",", "si", ")", "\n", "}", "\n", "}", "\n", "sort", ".", "Slice", "(", "aesis", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "aesis", "[", "i", "]", ".", "ts", "<", "aesis", "[", "j", "]", ".", "ts", "\n", "}", ")", "\n", "return", "aesis", "\n", "}" ]

[ "Return", "a", "list", "of", "the", "current", "autoExpireResponseMaps", "." ]

[ "func", "(", "a", "*", "Account", ")", "addImplicitServiceImport", "(", "destination", "*", "Account", ",", "from", ",", "to", "string", ",", "autoexpire", "bool", ",", "claim", "*", "jwt", ".", "Import", ")", "error", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "a", ".", "imports", ".", "services", "==", "nil", "{", "a", ".", "imports", ".", "services", "=", "make", "(", "map", "[", "string", "]", "*", "serviceImport", ")", "\n", "}", "\n", "si", ":=", "&", "serviceImport", "{", "destination", ",", "from", ",", "to", ",", "autoexpire", ",", "0", ",", "claim", ",", "false", "}", "\n", "a", ".", "imports", ".", "services", "[", "from", "]", "=", "si", "\n", "if", "autoexpire", "{", "a", ".", "nae", "++", "\n", "si", ".", "ts", "=", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n", "if", "a", ".", "nae", ">", "a", ".", "maxnae", "&&", "!", "a", ".", "pruning", "{", "a", ".", "pruning", "=", "true", "\n", "go", "a", ".", "pruneAutoExpireResponseMaps", "(", ")", "\n", "}", "\n", "}", "\n", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Add", "a", "route", "to", "connect", "from", "an", "implicit", "route", "created", "for", "a", "response", "to", "a", "request", ".", "This", "does", "no", "checks", "and", "should", "be", "only", "called", "by", "the", "msg", "processing", "code", ".", "Use", "addServiceImport", "from", "above", "if", "responding", "to", "user", "input", "or", "config", "changes", "etc", "." ]

[ "func", "(", "a", "*", "Account", ")", "pruneAutoExpireResponseMaps", "(", ")", "{", "defer", "func", "(", ")", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "a", ".", "pruning", "=", "false", "\n", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "(", ")", "\n\n", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "ttl", ":=", "int64", "(", "a", ".", "maxaettl", "/", "time", ".", "Second", ")", "+", "1", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "for", "{", "sis", ":=", "a", ".", "autoExpireResponseMaps", "(", ")", "\n\n", "// Check ttl items.", "now", ":=", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n", "for", "i", ",", "si", ":=", "range", "sis", "{", "if", "now", "-", "si", ".", "ts", ">=", "ttl", "{", "a", ".", "removeServiceImport", "(", "si", ".", "from", ")", "\n", "}", "else", "{", "sis", "=", "sis", "[", "i", ":", "]", "\n", "break", "\n", "}", "\n", "}", "\n\n", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "numOver", ":=", "int", "(", "a", ".", "nae", "-", "a", ".", "maxnae", ")", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "if", "numOver", "<=", "0", "{", "return", "\n", "}", "else", "if", "numOver", ">=", "len", "(", "sis", ")", "{", "numOver", "=", "len", "(", "sis", ")", "-", "1", "\n", "}", "\n", "// These are in sorted order, remove at least numOver", "for", "_", ",", "si", ":=", "range", "sis", "[", ":", "numOver", "]", "{", "a", ".", "removeServiceImport", "(", "si", ".", "from", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "This", "will", "prune", "the", "list", "to", "below", "the", "threshold", "and", "remove", "all", "ttl", "d", "maps", "." ]

[ "func", "(", "a", "*", "Account", ")", "AddStreamImportWithClaim", "(", "account", "*", "Account", ",", "from", ",", "prefix", "string", ",", "imClaim", "*", "jwt", ".", "Import", ")", "error", "{", "if", "account", "==", "nil", "{", "return", "ErrMissingAccount", "\n", "}", "\n\n", "// First check to see if the account has authorized export of the subject.", "if", "!", "account", ".", "checkStreamImportAuthorized", "(", "a", ",", "from", ",", "imClaim", ")", "{", "return", "ErrStreamImportAuthorization", "\n", "}", "\n\n", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "a", ".", "imports", ".", "streams", "==", "nil", "{", "a", ".", "imports", ".", "streams", "=", "make", "(", "map", "[", "string", "]", "*", "streamImport", ")", "\n", "}", "\n", "if", "prefix", "!=", "\"", "\"", "&&", "prefix", "[", "len", "(", "prefix", ")", "-", "1", "]", "!=", "btsep", "{", "prefix", "=", "prefix", "+", "string", "(", "btsep", ")", "\n", "}", "\n", "// TODO(dlc) - collisions, etc.", "a", ".", "imports", ".", "streams", "[", "from", "]", "=", "&", "streamImport", "{", "account", ",", "from", ",", "prefix", ",", "imClaim", ",", "false", "}", "\n", "return", "nil", "\n", "}" ]

[ "AddStreamImportWithClaim", "will", "add", "in", "the", "stream", "import", "from", "a", "specific", "account", "with", "optional", "token", "." ]

[ "func", "(", "a", "*", "Account", ")", "AddStreamImport", "(", "account", "*", "Account", ",", "from", ",", "prefix", "string", ")", "error", "{", "return", "a", ".", "AddStreamImportWithClaim", "(", "account", ",", "from", ",", "prefix", ",", "nil", ")", "\n", "}" ]

[ "AddStreamImport", "will", "add", "in", "the", "stream", "import", "from", "a", "specific", "account", "." ]

[ "func", "(", "a", "*", "Account", ")", "AddStreamExport", "(", "subject", "string", ",", "accounts", "[", "]", "*", "Account", ")", "error", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "a", "==", "nil", "{", "return", "ErrMissingAccount", "\n", "}", "\n", "if", "a", ".", "exports", ".", "streams", "==", "nil", "{", "a", ".", "exports", ".", "streams", "=", "make", "(", "map", "[", "string", "]", "*", "exportAuth", ")", "\n", "}", "\n", "ea", ":=", "a", ".", "exports", ".", "streams", "[", "subject", "]", "\n", "if", "accounts", "!=", "nil", "{", "if", "ea", "==", "nil", "{", "ea", "=", "&", "exportAuth", "{", "}", "\n", "}", "\n", "// empty means auth required but will be import token.", "if", "len", "(", "accounts", ")", "==", "0", "{", "ea", ".", "tokenReq", "=", "true", "\n", "}", "else", "{", "if", "ea", ".", "approved", "==", "nil", "{", "ea", ".", "approved", "=", "make", "(", "map", "[", "string", "]", "*", "Account", ",", "len", "(", "accounts", ")", ")", "\n", "}", "\n", "for", "_", ",", "acc", ":=", "range", "accounts", "{", "ea", ".", "approved", "[", "acc", ".", "Name", "]", "=", "acc", "\n", "}", "\n", "}", "\n", "}", "\n", "a", ".", "exports", ".", "streams", "[", "subject", "]", "=", "ea", "\n", "return", "nil", "\n", "}" ]

[ "AddStreamExport", "will", "add", "an", "export", "to", "the", "account", ".", "If", "accounts", "is", "nil", "it", "will", "signify", "a", "public", "export", "meaning", "anyone", "can", "impoort", "." ]

[ "func", "(", "a", "*", "Account", ")", "checkStreamImportAuthorized", "(", "account", "*", "Account", ",", "subject", "string", ",", "imClaim", "*", "jwt", ".", "Import", ")", "bool", "{", "// Find the subject in the exports list.", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "a", ".", "checkStreamImportAuthorizedNoLock", "(", "account", ",", "subject", ",", "imClaim", ")", "\n", "}" ]

[ "Check", "if", "another", "account", "is", "authorized", "to", "import", "from", "us", "." ]

[ "func", "fetchActivation", "(", "url", "string", ")", "string", "{", "// FIXME(dlc) - Make configurable.", "c", ":=", "&", "http", ".", "Client", "{", "Timeout", ":", "2", "*", "time", ".", "Second", "}", "\n", "resp", ",", "err", ":=", "c", ".", "Get", "(", "url", ")", "\n", "if", "err", "!=", "nil", "||", "resp", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "body", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "string", "(", "body", ")", "\n", "}" ]

[ "Will", "fetch", "the", "activation", "token", "for", "an", "import", "." ]

[ "func", "(", "a", "*", "Account", ")", "streamActivationExpired", "(", "subject", "string", ")", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "if", "a", ".", "expired", "||", "a", ".", "imports", ".", "streams", "==", "nil", "{", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "\n", "}", "\n", "si", ":=", "a", ".", "imports", ".", "streams", "[", "subject", "]", "\n", "if", "si", "==", "nil", "||", "si", ".", "invalid", "{", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "\n", "}", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "if", "si", ".", "acc", ".", "checkActivation", "(", "a", ",", "si", ".", "claim", ",", "false", ")", "{", "// The token has been updated most likely and we are good to go.", "return", "\n", "}", "\n\n", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "si", ".", "invalid", "=", "true", "\n", "clients", ":=", "make", "(", "[", "]", "*", "client", ",", "0", ",", "len", "(", "a", ".", "clients", ")", ")", "\n", "for", "_", ",", "c", ":=", "range", "a", ".", "clients", "{", "clients", "=", "append", "(", "clients", ",", "c", ")", "\n", "}", "\n", "awcsti", ":=", "map", "[", "string", "]", "struct", "{", "}", "{", "a", ".", "Name", ":", "struct", "{", "}", "{", "}", "}", "\n", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "c", ":=", "range", "clients", "{", "c", ".", "processSubsOnConfigReload", "(", "awcsti", ")", "\n", "}", "\n", "}" ]

[ "These", "are", "import", "stream", "specific", "versions", "for", "when", "an", "activation", "expires", "." ]

[ "func", "(", "a", "*", "Account", ")", "serviceActivationExpired", "(", "subject", "string", ")", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "if", "a", ".", "expired", "||", "a", ".", "imports", ".", "services", "==", "nil", "{", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "\n", "}", "\n", "si", ":=", "a", ".", "imports", ".", "services", "[", "subject", "]", "\n", "if", "si", "==", "nil", "||", "si", ".", "invalid", "{", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "\n", "}", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "if", "si", ".", "acc", ".", "checkActivation", "(", "a", ",", "si", ".", "claim", ",", "false", ")", "{", "// The token has been updated most likely and we are good to go.", "return", "\n", "}", "\n\n", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "si", ".", "invalid", "=", "true", "\n", "a", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "These", "are", "import", "service", "specific", "versions", "for", "when", "an", "activation", "expires", "." ]

[ "func", "(", "a", "*", "Account", ")", "activationExpired", "(", "subject", "string", ",", "kind", "jwt", ".", "ExportType", ")", "{", "switch", "kind", "{", "case", "jwt", ".", "Stream", ":", "a", ".", "streamActivationExpired", "(", "subject", ")", "\n", "case", "jwt", ".", "Service", ":", "a", ".", "serviceActivationExpired", "(", "subject", ")", "\n", "}", "\n", "}" ]

[ "Fires", "for", "expired", "activation", "tokens", ".", "We", "could", "track", "this", "with", "timers", "etc", ".", "Instead", "we", "just", "re", "-", "analyze", "where", "we", "are", "and", "if", "we", "need", "to", "act", "." ]

[ "func", "(", "a", "*", "Account", ")", "checkActivation", "(", "acc", "*", "Account", ",", "claim", "*", "jwt", ".", "Import", ",", "expTimer", "bool", ")", "bool", "{", "if", "claim", "==", "nil", "||", "claim", ".", "Token", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "// Create a quick clone so we can inline Token JWT.", "clone", ":=", "*", "claim", "\n\n", "// We grab the token from a URL by hand here since we need expiration etc.", "if", "url", ",", "err", ":=", "url", ".", "Parse", "(", "clone", ".", "Token", ")", ";", "err", "==", "nil", "&&", "url", ".", "Scheme", "!=", "\"", "\"", "{", "clone", ".", "Token", "=", "fetchActivation", "(", "url", ".", "String", "(", ")", ")", "\n", "}", "\n", "vr", ":=", "jwt", ".", "CreateValidationResults", "(", ")", "\n", "clone", ".", "Validate", "(", "a", ".", "Name", ",", "vr", ")", "\n", "if", "vr", ".", "IsBlocking", "(", "true", ")", "{", "return", "false", "\n", "}", "\n", "act", ",", "err", ":=", "jwt", ".", "DecodeActivationClaims", "(", "clone", ".", "Token", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "vr", "=", "jwt", ".", "CreateValidationResults", "(", ")", "\n", "act", ".", "Validate", "(", "vr", ")", "\n", "if", "vr", ".", "IsBlocking", "(", "true", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "a", ".", "isIssuerClaimTrusted", "(", "act", ")", "{", "return", "false", "\n", "}", "\n", "if", "act", ".", "Expires", "!=", "0", "{", "tn", ":=", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n", "if", "act", ".", "Expires", "<=", "tn", "{", "return", "false", "\n", "}", "\n", "if", "expTimer", "{", "expiresAt", ":=", "time", ".", "Duration", "(", "act", ".", "Expires", "-", "tn", ")", "\n", "time", ".", "AfterFunc", "(", "expiresAt", "*", "time", ".", "Second", ",", "func", "(", ")", "{", "acc", ".", "activationExpired", "(", "string", "(", "act", ".", "ImportSubject", ")", ",", "claim", ".", "Type", ")", "\n", "}", ")", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "checkActivation", "will", "check", "the", "activation", "token", "for", "validity", "." ]

[ "func", "(", "a", "*", "Account", ")", "isIssuerClaimTrusted", "(", "claims", "*", "jwt", ".", "ActivationClaims", ")", "bool", "{", "// if no issuer account, issuer is the account", "if", "claims", ".", "IssuerAccount", "==", "\"", "\"", "{", "return", "true", "\n", "}", "\n", "// get the referenced account", "if", "a", ".", "srv", "!=", "nil", "{", "ia", ",", "err", ":=", "a", ".", "srv", ".", "lookupAccount", "(", "claims", ".", "IssuerAccount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "ia", ".", "hasIssuer", "(", "claims", ".", "Issuer", ")", "\n", "}", "\n", "// couldn't verify", "return", "false", "\n", "}" ]

[ "Returns", "true", "if", "the", "activation", "claim", "is", "trusted", ".", "That", "is", "the", "issuer", "matches", "the", "account", "or", "is", "an", "entry", "in", "the", "signing", "keys", "." ]

[ "func", "(", "a", "*", "Account", ")", "checkStreamImportsEqual", "(", "b", "*", "Account", ")", "bool", "{", "if", "len", "(", "a", ".", "imports", ".", "streams", ")", "!=", "len", "(", "b", ".", "imports", ".", "streams", ")", "{", "return", "false", "\n", "}", "\n", "for", "subj", ",", "aim", ":=", "range", "a", ".", "imports", ".", "streams", "{", "bim", ":=", "b", ".", "imports", ".", "streams", "[", "subj", "]", "\n", "if", "bim", "==", "nil", "{", "return", "false", "\n", "}", "\n", "if", "aim", ".", "acc", ".", "Name", "!=", "bim", ".", "acc", ".", "Name", "||", "aim", ".", "from", "!=", "bim", ".", "from", "||", "aim", ".", "prefix", "!=", "bim", ".", "prefix", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Returns", "true", "if", "a", "and", "b", "stream", "imports", "are", "the", "same", ".", "Note", "that", "the", "check", "is", "done", "with", "the", "account", "s", "name", "not", "the", "pointer", ".", "This", "is", "used", "during", "config", "reload", "where", "we", "are", "comparing", "current", "and", "new", "config", "in", "which", "pointers", "are", "different", ".", "No", "lock", "is", "acquired", "in", "this", "function", "so", "it", "is", "assumed", "that", "the", "import", "maps", "are", "not", "changed", "while", "this", "executes", "." ]

[ "func", "(", "a", "*", "Account", ")", "checkServiceImportAuthorizedNoLock", "(", "account", "*", "Account", ",", "subject", "string", ",", "imClaim", "*", "jwt", ".", "Import", ")", "bool", "{", "// Find the subject in the services list.", "if", "a", ".", "exports", ".", "services", "==", "nil", "||", "!", "IsValidLiteralSubject", "(", "subject", ")", "{", "return", "false", "\n", "}", "\n", "return", "a", ".", "checkExportApproved", "(", "account", ",", "subject", ",", "imClaim", ",", "a", ".", "exports", ".", "services", ")", "\n", "}" ]

[ "Check", "if", "another", "account", "is", "authorized", "to", "route", "requests", "to", "this", "service", "." ]

[ "func", "(", "a", "*", "Account", ")", "IsExpired", "(", ")", "bool", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "exp", ":=", "a", ".", "expired", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "exp", "\n", "}" ]

[ "IsExpired", "returns", "expiration", "status", "." ]

[ "func", "(", "a", "*", "Account", ")", "expiredTimeout", "(", ")", "{", "// Collect the clients.", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "a", ".", "expired", "=", "true", "\n", "a", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "cs", ":=", "make", "(", "[", "]", "*", "client", ",", "0", ",", "len", "(", "a", ".", "clients", ")", ")", "\n", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "for", "c", ":=", "range", "a", ".", "clients", "{", "cs", "=", "append", "(", "cs", ",", "c", ")", "\n", "}", "\n", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "for", "_", ",", "c", ":=", "range", "cs", "{", "c", ".", "accountAuthExpired", "(", ")", "\n", "}", "\n", "}" ]

[ "Called", "when", "an", "account", "has", "expired", "." ]

[ "func", "(", "a", "*", "Account", ")", "setExpirationTimer", "(", "d", "time", ".", "Duration", ")", "{", "a", ".", "etmr", "=", "time", ".", "AfterFunc", "(", "d", ",", "a", ".", "expiredTimeout", ")", "\n", "}" ]

[ "Sets", "the", "expiration", "timer", "for", "an", "account", "JWT", "that", "has", "it", "set", "." ]

[ "func", "(", "a", "*", "Account", ")", "checkExpiration", "(", "claims", "*", "jwt", ".", "ClaimsData", ")", "{", "a", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "a", ".", "clearExpirationTimer", "(", ")", "\n", "if", "claims", ".", "Expires", "==", "0", "{", "a", ".", "expired", "=", "false", "\n", "return", "\n", "}", "\n", "tn", ":=", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n", "if", "claims", ".", "Expires", "<=", "tn", "{", "a", ".", "expired", "=", "true", "\n", "return", "\n", "}", "\n", "expiresAt", ":=", "time", ".", "Duration", "(", "claims", ".", "Expires", "-", "tn", ")", "\n", "a", ".", "setExpirationTimer", "(", "expiresAt", "*", "time", ".", "Second", ")", "\n", "a", ".", "expired", "=", "false", "\n", "}" ]

[ "Check", "expiration", "and", "set", "the", "proper", "state", "as", "needed", "." ]

[ "func", "(", "a", "*", "Account", ")", "hasIssuer", "(", "issuer", "string", ")", "bool", "{", "a", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "mu", ".", "RUnlock", "(", ")", "\n", "// same issuer", "if", "a", ".", "Issuer", "==", "issuer", "{", "return", "true", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "a", ".", "signingKeys", ")", ";", "i", "++", "{", "if", "a", ".", "signingKeys", "[", "i", "]", "==", "issuer", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "hasIssuer", "returns", "true", "if", "the", "issuer", "matches", "the", "account", "issuer", "or", "it", "is", "a", "signing", "key", "for", "the", "account", "." ]

[ "func", "(", "s", "*", "Server", ")", "SetAccountResolver", "(", "ar", "AccountResolver", ")", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "accResolver", "=", "ar", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "SetAccountResolver", "will", "assign", "the", "account", "resolver", "." ]

[ "func", "(", "s", "*", "Server", ")", "AccountResolver", "(", ")", "AccountResolver", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "s", ".", "accResolver", "\n", "}" ]

[ "AccountResolver", "returns", "the", "registered", "account", "resolver", "." ]

[ "func", "(", "s", "*", "Server", ")", "UpdateAccountClaims", "(", "a", "*", "Account", ",", "ac", "*", "jwt", ".", "AccountClaims", ")", "{", "s", ".", "updateAccountClaims", "(", "a", ",", "ac", ")", "\n", "}" ]

[ "UpdateAccountClaims", "will", "call", "updateAccountClaims", "." ]

[ "func", "(", "s", "*", "Server", ")", "buildInternalAccount", "(", "ac", "*", "jwt", ".", "AccountClaims", ")", "*", "Account", "{", "acc", ":=", "NewAccount", "(", "ac", ".", "Subject", ")", "\n", "acc", ".", "Issuer", "=", "ac", ".", "Issuer", "\n", "s", ".", "updateAccountClaims", "(", "acc", ",", "ac", ")", "\n", "return", "acc", "\n", "}" ]

[ "Helper", "to", "build", "an", "internal", "account", "structure", "from", "a", "jwt", ".", "AccountClaims", "." ]

[ "func", "buildInternalNkeyUser", "(", "uc", "*", "jwt", ".", "UserClaims", ",", "acc", "*", "Account", ")", "*", "NkeyUser", "{", "nu", ":=", "&", "NkeyUser", "{", "Nkey", ":", "uc", ".", "Subject", ",", "Account", ":", "acc", "}", "\n", "if", "uc", ".", "IssuerAccount", "!=", "\"", "\"", "{", "nu", ".", "SigningKey", "=", "uc", ".", "Issuer", "\n", "}", "\n\n", "// Now check for permissions.", "var", "p", "*", "Permissions", "\n\n", "if", "len", "(", "uc", ".", "Pub", ".", "Allow", ")", ">", "0", "||", "len", "(", "uc", ".", "Pub", ".", "Deny", ")", ">", "0", "{", "if", "p", "==", "nil", "{", "p", "=", "&", "Permissions", "{", "}", "\n", "}", "\n", "p", ".", "Publish", "=", "&", "SubjectPermission", "{", "}", "\n", "p", ".", "Publish", ".", "Allow", "=", "uc", ".", "Pub", ".", "Allow", "\n", "p", ".", "Publish", ".", "Deny", "=", "uc", ".", "Pub", ".", "Deny", "\n", "}", "\n", "if", "len", "(", "uc", ".", "Sub", ".", "Allow", ")", ">", "0", "||", "len", "(", "uc", ".", "Sub", ".", "Deny", ")", ">", "0", "{", "if", "p", "==", "nil", "{", "p", "=", "&", "Permissions", "{", "}", "\n", "}", "\n", "p", ".", "Subscribe", "=", "&", "SubjectPermission", "{", "}", "\n", "p", ".", "Subscribe", ".", "Allow", "=", "uc", ".", "Sub", ".", "Allow", "\n", "p", ".", "Subscribe", ".", "Deny", "=", "uc", ".", "Sub", ".", "Deny", "\n", "}", "\n", "nu", ".", "Permissions", "=", "p", "\n", "return", "nu", "\n", "}" ]

[ "Helper", "to", "build", "internal", "NKeyUser", "." ]

[ "func", "(", "m", "*", "MemAccResolver", ")", "Fetch", "(", "name", "string", ")", "(", "string", ",", "error", ")", "{", "if", "j", ",", "ok", ":=", "m", ".", "sm", ".", "Load", "(", "name", ")", ";", "ok", "{", "return", "j", ".", "(", "string", ")", ",", "nil", "\n", "}", "\n", "return", "_EMPTY_", ",", "ErrMissingAccount", "\n", "}" ]

[ "Fetch", "will", "fetch", "the", "account", "jwt", "claims", "from", "the", "internal", "sync", ".", "Map", "." ]

[ "func", "(", "m", "*", "MemAccResolver", ")", "Store", "(", "name", ",", "jwt", "string", ")", "error", "{", "m", ".", "sm", ".", "Store", "(", "name", ",", "jwt", ")", "\n", "return", "nil", "\n", "}" ]

[ "Store", "will", "store", "the", "account", "jwt", "claims", "in", "the", "internal", "sync", ".", "Map", "." ]

[ "func", "NewURLAccResolver", "(", "url", "string", ")", "(", "*", "URLAccResolver", ",", "error", ")", "{", "if", "!", "strings", ".", "HasSuffix", "(", "url", ",", "\"", "\"", ")", "{", "url", "+=", "\"", "\"", "\n", "}", "\n", "// Do basic test to see if anyone is home.", "// FIXME(dlc) - Make timeout configurable post MVP.", "ur", ":=", "&", "URLAccResolver", "{", "url", ":", "url", ",", "c", ":", "&", "http", ".", "Client", "{", "Timeout", ":", "2", "*", "time", ".", "Second", "}", ",", "}", "\n", "if", "_", ",", "err", ":=", "ur", ".", "Fetch", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "ur", ",", "nil", "\n", "}" ]

[ "NewURLAccResolver", "returns", "a", "new", "resolver", "for", "the", "given", "base", "URL", "." ]

[ "func", "(", "ur", "*", "URLAccResolver", ")", "Fetch", "(", "name", "string", ")", "(", "string", ",", "error", ")", "{", "url", ":=", "ur", ".", "url", "+", "name", "\n", "resp", ",", "err", ":=", "ur", ".", "c", ".", "Get", "(", "url", ")", "\n", "if", "err", "!=", "nil", "{", "return", "_EMPTY_", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "}", "else", "if", "resp", "==", "nil", "{", "return", "_EMPTY_", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ")", "\n", "}", "else", "if", "resp", ".", "StatusCode", "!=", "http", ".", "StatusOK", "{", "return", "_EMPTY_", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "resp", ".", "Status", ")", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "body", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "_EMPTY_", ",", "err", "\n", "}", "\n", "return", "string", "(", "body", ")", ",", "nil", "\n", "}" ]

[ "Fetch", "will", "fetch", "the", "account", "jwt", "claims", "from", "the", "base", "url", "appending", "the", "account", "name", "onto", "the", "end", "." ]

[ "func", "ParseFile", "(", "fp", "string", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "fp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "p", ",", "err", ":=", "parse", "(", "string", "(", "data", ")", ",", "fp", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "p", ".", "mapping", ",", "nil", "\n", "}" ]

[ "ParseFile", "is", "a", "helper", "to", "open", "file", "etc", ".", "and", "parse", "the", "contents", "." ]

[ "func", "ParseFileWithChecks", "(", "fp", "string", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "fp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "p", ",", "err", ":=", "parse", "(", "string", "(", "data", ")", ",", "fp", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "p", ".", "mapping", ",", "nil", "\n", "}" ]

[ "ParseFileWithChecks", "is", "equivalent", "to", "ParseFile", "but", "runs", "in", "pedantic", "mode", "." ]

[ "func", "(", "p", "*", "parser", ")", "lookupVariable", "(", "varReference", "string", ")", "(", "interface", "{", "}", ",", "bool", ",", "error", ")", "{", "// Do special check to see if it is a raw bcrypt string.", "if", "strings", ".", "HasPrefix", "(", "varReference", ",", "bcryptPrefix", ")", "{", "return", "\"", "\"", "+", "varReference", ",", "true", ",", "nil", "\n", "}", "\n\n", "// Loop through contexts currently on the stack.", "for", "i", ":=", "len", "(", "p", ".", "ctxs", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "ctx", ":=", "p", ".", "ctxs", "[", "i", "]", "\n", "// Process if it is a map context", "if", "m", ",", "ok", ":=", "ctx", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ";", "ok", "{", "if", "v", ",", "ok", ":=", "m", "[", "varReference", "]", ";", "ok", "{", "return", "v", ",", "ok", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// If we are here, we have exhausted our context maps and still not found anything.", "// Parse from the environment.", "if", "vStr", ",", "ok", ":=", "os", ".", "LookupEnv", "(", "varReference", ")", ";", "ok", "{", "// Everything we get here will be a string value, so we need to process as a parser would.", "if", "vmap", ",", "err", ":=", "Parse", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pkey", ",", "vStr", ")", ")", ";", "err", "==", "nil", "{", "v", ",", "ok", ":=", "vmap", "[", "pkey", "]", "\n", "return", "v", ",", "ok", ",", "nil", "\n", "}", "else", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", ",", "nil", "\n", "}" ]

[ "lookupVariable", "will", "lookup", "a", "variable", "reference", ".", "It", "will", "use", "block", "scoping", "on", "keys", "it", "has", "seen", "before", "with", "the", "top", "level", "scoping", "being", "the", "environment", "variables", ".", "We", "ignore", "array", "contexts", "and", "only", "process", "the", "map", "contexts", "..", "Returns", "true", "for", "ok", "if", "it", "finds", "something", "similar", "to", "map", "." ]

[ "func", "(", "r", "*", "SublistResult", ")", "addSubToResult", "(", "sub", "*", "subscription", ")", "*", "SublistResult", "{", "// Copy since others may have a reference.", "nr", ":=", "copyResult", "(", "r", ")", "\n", "if", "sub", ".", "queue", "==", "nil", "{", "nr", ".", "psubs", "=", "append", "(", "nr", ".", "psubs", ",", "sub", ")", "\n", "}", "else", "{", "if", "i", ":=", "findQSlot", "(", "sub", ".", "queue", ",", "nr", ".", "qsubs", ")", ";", "i", ">=", "0", "{", "nr", ".", "qsubs", "[", "i", "]", "=", "append", "(", "nr", ".", "qsubs", "[", "i", "]", ",", "sub", ")", "\n", "}", "else", "{", "nr", ".", "qsubs", "=", "append", "(", "nr", ".", "qsubs", ",", "[", "]", "*", "subscription", "{", "sub", "}", ")", "\n", "}", "\n", "}", "\n", "return", "nr", "\n", "}" ]

[ "Adds", "a", "new", "sub", "to", "an", "existing", "result", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "addToCache", "(", "subject", "string", ",", "sub", "*", "subscription", ")", "{", "if", "s", ".", "cache", "==", "nil", "{", "return", "\n", "}", "\n", "// If literal we can direct match.", "if", "subjectIsLiteral", "(", "subject", ")", "{", "if", "v", ",", "ok", ":=", "s", ".", "cache", ".", "Load", "(", "subject", ")", ";", "ok", "{", "r", ":=", "v", ".", "(", "*", "SublistResult", ")", "\n", "s", ".", "cache", ".", "Store", "(", "subject", ",", "r", ".", "addSubToResult", "(", "sub", ")", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "s", ".", "cache", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "key", ":=", "k", ".", "(", "string", ")", "\n", "r", ":=", "v", ".", "(", "*", "SublistResult", ")", "\n", "if", "matchLiteral", "(", "key", ",", "subject", ")", "{", "s", ".", "cache", ".", "Store", "(", "key", ",", "r", ".", "addSubToResult", "(", "sub", ")", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "}" ]

[ "addToCache", "will", "add", "the", "new", "entry", "to", "the", "existing", "cache", "entries", "if", "needed", ".", "Assumes", "write", "lock", "is", "held", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "removeFromCache", "(", "subject", "string", ",", "sub", "*", "subscription", ")", "{", "if", "s", ".", "cache", "==", "nil", "{", "return", "\n", "}", "\n", "// If literal we can direct match.", "if", "subjectIsLiteral", "(", "subject", ")", "{", "// Load for accounting", "if", "_", ",", "ok", ":=", "s", ".", "cache", ".", "Load", "(", "subject", ")", ";", "ok", "{", "s", ".", "cache", ".", "Delete", "(", "subject", ")", "\n", "atomic", ".", "AddInt32", "(", "&", "s", ".", "cacheNum", ",", "-", "1", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "s", ".", "cache", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "key", ":=", "k", ".", "(", "string", ")", "\n", "if", "matchLiteral", "(", "key", ",", "subject", ")", "{", "// Since someone else may be referecing, can't modify the list", "// safely, just let it re-populate.", "s", ".", "cache", ".", "Delete", "(", "key", ")", "\n", "atomic", ".", "AddInt32", "(", "&", "s", ".", "cacheNum", ",", "-", "1", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "}" ]

[ "removeFromCache", "will", "remove", "the", "sub", "from", "any", "active", "cache", "entries", ".", "Assumes", "write", "lock", "is", "held", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "Match", "(", "subject", "string", ")", "*", "SublistResult", "{", "atomic", ".", "AddUint64", "(", "&", "s", ".", "matches", ",", "1", ")", "\n\n", "// Check cache first.", "if", "atomic", ".", "LoadInt32", "(", "&", "s", ".", "cacheNum", ")", ">", "0", "{", "if", "r", ",", "ok", ":=", "s", ".", "cache", ".", "Load", "(", "subject", ")", ";", "ok", "{", "atomic", ".", "AddUint64", "(", "&", "s", ".", "cacheHits", ",", "1", ")", "\n", "return", "r", ".", "(", "*", "SublistResult", ")", "\n", "}", "\n", "}", "\n\n", "tsa", ":=", "[", "32", "]", "string", "{", "}", "\n", "tokens", ":=", "tsa", "[", ":", "0", "]", "\n", "start", ":=", "0", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "subject", ")", ";", "i", "++", "{", "if", "subject", "[", "i", "]", "==", "btsep", "{", "tokens", "=", "append", "(", "tokens", ",", "subject", "[", "start", ":", "i", "]", ")", "\n", "start", "=", "i", "+", "1", "\n", "}", "\n", "}", "\n", "tokens", "=", "append", "(", "tokens", ",", "subject", "[", "start", ":", "]", ")", "\n\n", "// FIXME(dlc) - Make shared pool between sublist and client readLoop?", "result", ":=", "&", "SublistResult", "{", "}", "\n\n", "// Get result from the main structure and place into the shared cache.", "// Hold the read lock to avoid race between match and store.", "var", "n", "int32", "\n\n", "s", ".", "RLock", "(", ")", "\n", "matchLevel", "(", "s", ".", "root", ",", "tokens", ",", "result", ")", "\n", "// Check for empty result.", "if", "len", "(", "result", ".", "psubs", ")", "==", "0", "&&", "len", "(", "result", ".", "qsubs", ")", "==", "0", "{", "result", "=", "emptyResult", "\n", "}", "\n", "if", "s", ".", "cache", "!=", "nil", "{", "s", ".", "cache", ".", "Store", "(", "subject", ",", "result", ")", "\n", "n", "=", "atomic", ".", "AddInt32", "(", "&", "s", ".", "cacheNum", ",", "1", ")", "\n", "}", "\n", "s", ".", "RUnlock", "(", ")", "\n\n", "// Reduce the cache count if we have exceeded our set maximum.", "if", "n", ">", "slCacheMax", "&&", "atomic", ".", "CompareAndSwapInt32", "(", "&", "s", ".", "ccSweep", ",", "0", ",", "1", ")", "{", "go", "s", ".", "reduceCacheCount", "(", ")", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "Match", "will", "match", "all", "entries", "to", "the", "literal", "subject", ".", "It", "will", "return", "a", "set", "of", "results", "for", "both", "normal", "and", "queue", "subscribers", "." ]

[ "func", "isRemoteQSub", "(", "sub", "*", "subscription", ")", "bool", "{", "return", "sub", "!=", "nil", "&&", "sub", ".", "queue", "!=", "nil", "&&", "sub", ".", "client", "!=", "nil", "&&", "sub", ".", "client", ".", "kind", "==", "ROUTER", "\n", "}" ]

[ "Helper", "function", "for", "auto", "-", "expanding", "remote", "qsubs", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "UpdateRemoteQSub", "(", "sub", "*", "subscription", ")", "{", "// We could search to make sure we find it, but probably not worth", "// it unless we are thrashing the cache. Just remove from our L2 and update", "// the genid so L1 will be flushed.", "s", ".", "Lock", "(", ")", "\n", "s", ".", "removeFromCache", "(", "string", "(", "sub", ".", "subject", ")", ",", "sub", ")", "\n", "atomic", ".", "AddUint64", "(", "&", "s", ".", "genid", ",", "1", ")", "\n", "s", ".", "Unlock", "(", ")", "\n", "}" ]

[ "UpdateRemoteQSub", "should", "be", "called", "when", "we", "update", "the", "weight", "of", "an", "existing", "remote", "queue", "sub", "." ]

[ "func", "addNodeToResults", "(", "n", "*", "node", ",", "results", "*", "SublistResult", ")", "{", "// Normal subscriptions", "if", "n", ".", "plist", "!=", "nil", "{", "results", ".", "psubs", "=", "append", "(", "results", ".", "psubs", ",", "n", ".", "plist", "...", ")", "\n", "}", "else", "{", "for", "_", ",", "psub", ":=", "range", "n", ".", "psubs", "{", "results", ".", "psubs", "=", "append", "(", "results", ".", "psubs", ",", "psub", ")", "\n", "}", "\n", "}", "\n", "// Queue subscriptions", "for", "qname", ",", "qr", ":=", "range", "n", ".", "qsubs", "{", "if", "len", "(", "qr", ")", "==", "0", "{", "continue", "\n", "}", "\n", "// Need to find matching list in results", "var", "i", "int", "\n", "if", "i", "=", "findQSlot", "(", "[", "]", "byte", "(", "qname", ")", ",", "results", ".", "qsubs", ")", ";", "i", "<", "0", "{", "i", "=", "len", "(", "results", ".", "qsubs", ")", "\n", "nqsub", ":=", "make", "(", "[", "]", "*", "subscription", ",", "0", ",", "len", "(", "qr", ")", ")", "\n", "results", ".", "qsubs", "=", "append", "(", "results", ".", "qsubs", ",", "nqsub", ")", "\n", "}", "\n", "for", "_", ",", "sub", ":=", "range", "qr", "{", "if", "isRemoteQSub", "(", "sub", ")", "{", "ns", ":=", "atomic", ".", "LoadInt32", "(", "&", "sub", ".", "qw", ")", "\n", "// Shadow these subscriptions", "for", "n", ":=", "0", ";", "n", "<", "int", "(", "ns", ")", ";", "n", "++", "{", "results", ".", "qsubs", "[", "i", "]", "=", "append", "(", "results", ".", "qsubs", "[", "i", "]", ",", "sub", ")", "\n", "}", "\n", "}", "else", "{", "results", ".", "qsubs", "[", "i", "]", "=", "append", "(", "results", ".", "qsubs", "[", "i", "]", ",", "sub", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "This", "will", "add", "in", "a", "node", "s", "results", "to", "the", "total", "results", "." ]

[ "func", "findQSlot", "(", "queue", "[", "]", "byte", ",", "qsl", "[", "]", "[", "]", "*", "subscription", ")", "int", "{", "if", "queue", "==", "nil", "{", "return", "-", "1", "\n", "}", "\n", "for", "i", ",", "qr", ":=", "range", "qsl", "{", "if", "len", "(", "qr", ")", ">", "0", "&&", "bytes", ".", "Equal", "(", "queue", ",", "qr", "[", "0", "]", ".", "queue", ")", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "We", "do", "not", "use", "a", "map", "here", "since", "we", "want", "iteration", "to", "be", "past", "when", "processing", "publishes", "in", "L1", "on", "client", ".", "So", "we", "need", "to", "walk", "sequentially", "for", "now", ".", "Keep", "an", "eye", "on", "this", "in", "case", "we", "start", "getting", "large", "number", "of", "different", "queue", "subscribers", "for", "the", "same", "subject", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "remove", "(", "sub", "*", "subscription", ",", "shouldLock", "bool", ")", "error", "{", "subject", ":=", "string", "(", "sub", ".", "subject", ")", "\n", "tsa", ":=", "[", "32", "]", "string", "{", "}", "\n", "tokens", ":=", "tsa", "[", ":", "0", "]", "\n", "start", ":=", "0", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "subject", ")", ";", "i", "++", "{", "if", "subject", "[", "i", "]", "==", "btsep", "{", "tokens", "=", "append", "(", "tokens", ",", "subject", "[", "start", ":", "i", "]", ")", "\n", "start", "=", "i", "+", "1", "\n", "}", "\n", "}", "\n", "tokens", "=", "append", "(", "tokens", ",", "subject", "[", "start", ":", "]", ")", "\n\n", "if", "shouldLock", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "sfwc", ":=", "false", "\n", "l", ":=", "s", ".", "root", "\n", "var", "n", "*", "node", "\n\n", "// Track levels for pruning", "var", "lnts", "[", "32", "]", "lnt", "\n", "levels", ":=", "lnts", "[", ":", "0", "]", "\n\n", "for", "_", ",", "t", ":=", "range", "tokens", "{", "lt", ":=", "len", "(", "t", ")", "\n", "if", "lt", "==", "0", "||", "sfwc", "{", "return", "ErrInvalidSubject", "\n", "}", "\n", "if", "l", "==", "nil", "{", "return", "ErrNotFound", "\n", "}", "\n", "if", "lt", ">", "1", "{", "n", "=", "l", ".", "nodes", "[", "t", "]", "\n", "}", "else", "{", "switch", "t", "[", "0", "]", "{", "case", "pwc", ":", "n", "=", "l", ".", "pwc", "\n", "case", "fwc", ":", "n", "=", "l", ".", "fwc", "\n", "sfwc", "=", "true", "\n", "default", ":", "n", "=", "l", ".", "nodes", "[", "t", "]", "\n", "}", "\n", "}", "\n", "if", "n", "!=", "nil", "{", "levels", "=", "append", "(", "levels", ",", "lnt", "{", "l", ",", "n", ",", "t", "}", ")", "\n", "l", "=", "n", ".", "next", "\n", "}", "else", "{", "l", "=", "nil", "\n", "}", "\n", "}", "\n", "if", "!", "s", ".", "removeFromNode", "(", "n", ",", "sub", ")", "{", "return", "ErrNotFound", "\n", "}", "\n\n", "s", ".", "count", "--", "\n", "s", ".", "removes", "++", "\n\n", "for", "i", ":=", "len", "(", "levels", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "l", ",", "n", ",", "t", ":=", "levels", "[", "i", "]", ".", "l", ",", "levels", "[", "i", "]", ".", "n", ",", "levels", "[", "i", "]", ".", "t", "\n", "if", "n", ".", "isEmpty", "(", ")", "{", "l", ".", "pruneNode", "(", "n", ",", "t", ")", "\n", "}", "\n", "}", "\n", "s", ".", "removeFromCache", "(", "subject", ",", "sub", ")", "\n", "atomic", ".", "AddUint64", "(", "&", "s", ".", "genid", ",", "1", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Raw", "low", "level", "remove", "can", "do", "batches", "with", "lock", "held", "outside", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "Remove", "(", "sub", "*", "subscription", ")", "error", "{", "return", "s", ".", "remove", "(", "sub", ",", "true", ")", "\n", "}" ]

[ "Remove", "will", "remove", "a", "subscription", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "RemoveBatch", "(", "subs", "[", "]", "*", "subscription", ")", "error", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "for", "_", ",", "sub", ":=", "range", "subs", "{", "if", "err", ":=", "s", ".", "remove", "(", "sub", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RemoveBatch", "will", "remove", "a", "list", "of", "subscriptions", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "RemoveAllForClient", "(", "c", "*", "client", ")", "{", "s", ".", "Lock", "(", ")", "\n", "removes", ":=", "s", ".", "removes", "\n", "s", ".", "removeClientSubs", "(", "s", ".", "root", ",", "c", ")", "\n", "if", "s", ".", "removes", "!=", "removes", "{", "atomic", ".", "AddUint64", "(", "&", "s", ".", "genid", ",", "1", ")", "\n", "}", "\n", "s", ".", "Unlock", "(", ")", "\n", "}" ]

[ "RemoveAllForClient", "will", "remove", "all", "subscriptions", "for", "a", "given", "client", "." ]

[ "func", "(", "l", "*", "level", ")", "pruneNode", "(", "n", "*", "node", ",", "t", "string", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "if", "n", "==", "l", ".", "fwc", "{", "l", ".", "fwc", "=", "nil", "\n", "}", "else", "if", "n", "==", "l", ".", "pwc", "{", "l", ".", "pwc", "=", "nil", "\n", "}", "else", "{", "delete", "(", "l", ".", "nodes", ",", "t", ")", "\n", "}", "\n", "}" ]

[ "pruneNode", "is", "used", "to", "prune", "an", "empty", "node", "from", "the", "tree", "." ]

[ "func", "(", "l", "*", "level", ")", "numNodes", "(", ")", "int", "{", "num", ":=", "len", "(", "l", ".", "nodes", ")", "\n", "if", "l", ".", "pwc", "!=", "nil", "{", "num", "++", "\n", "}", "\n", "if", "l", ".", "fwc", "!=", "nil", "{", "num", "++", "\n", "}", "\n", "return", "num", "\n", "}" ]

[ "Return", "the", "number", "of", "nodes", "for", "the", "given", "level", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "Count", "(", ")", "uint32", "{", "s", ".", "RLock", "(", ")", "\n", "defer", "s", ".", "RUnlock", "(", ")", "\n", "return", "s", ".", "count", "\n", "}" ]

[ "Count", "returns", "the", "number", "of", "subscriptions", "." ]

[ "func", "(", "s", "*", "Sublist", ")", "Stats", "(", ")", "*", "SublistStats", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "st", ":=", "&", "SublistStats", "{", "}", "\n", "st", ".", "NumSubs", "=", "s", ".", "count", "\n", "st", ".", "NumCache", "=", "uint32", "(", "atomic", ".", "LoadInt32", "(", "&", "s", ".", "cacheNum", ")", ")", "\n", "st", ".", "NumInserts", "=", "s", ".", "inserts", "\n", "st", ".", "NumRemoves", "=", "s", ".", "removes", "\n", "st", ".", "NumMatches", "=", "atomic", ".", "LoadUint64", "(", "&", "s", ".", "matches", ")", "\n", "if", "st", ".", "NumMatches", ">", "0", "{", "st", ".", "CacheHitRate", "=", "float64", "(", "atomic", ".", "LoadUint64", "(", "&", "s", ".", "cacheHits", ")", ")", "/", "float64", "(", "st", ".", "NumMatches", ")", "\n", "}", "\n\n", "// whip through cache for fanout stats, this can be off if cache is full and doing evictions.", "tot", ",", "max", ":=", "0", ",", "0", "\n", "clen", ":=", "0", "\n", "s", ".", "cache", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "clen", "++", "\n", "r", ":=", "v", ".", "(", "*", "SublistResult", ")", "\n", "l", ":=", "len", "(", "r", ".", "psubs", ")", "+", "len", "(", "r", ".", "qsubs", ")", "\n", "tot", "+=", "l", "\n", "if", "l", ">", "max", "{", "max", "=", "l", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "st", ".", "MaxFanout", "=", "uint32", "(", "max", ")", "\n", "if", "tot", ">", "0", "{", "st", ".", "AvgFanout", "=", "float64", "(", "tot", ")", "/", "float64", "(", "clen", ")", "\n", "}", "\n", "return", "st", "\n", "}" ]

[ "Stats", "will", "return", "a", "stats", "structure", "for", "the", "current", "state", "." ]

[ "func", "visitLevel", "(", "l", "*", "level", ",", "depth", "int", ")", "int", "{", "if", "l", "==", "nil", "||", "l", ".", "numNodes", "(", ")", "==", "0", "{", "return", "depth", "\n", "}", "\n\n", "depth", "++", "\n", "maxDepth", ":=", "depth", "\n\n", "for", "_", ",", "n", ":=", "range", "l", ".", "nodes", "{", "if", "n", "==", "nil", "{", "continue", "\n", "}", "\n", "newDepth", ":=", "visitLevel", "(", "n", ".", "next", ",", "depth", ")", "\n", "if", "newDepth", ">", "maxDepth", "{", "maxDepth", "=", "newDepth", "\n", "}", "\n", "}", "\n", "if", "l", ".", "pwc", "!=", "nil", "{", "pwcDepth", ":=", "visitLevel", "(", "l", ".", "pwc", ".", "next", ",", "depth", ")", "\n", "if", "pwcDepth", ">", "maxDepth", "{", "maxDepth", "=", "pwcDepth", "\n", "}", "\n", "}", "\n", "if", "l", ".", "fwc", "!=", "nil", "{", "fwcDepth", ":=", "visitLevel", "(", "l", ".", "fwc", ".", "next", ",", "depth", ")", "\n", "if", "fwcDepth", ">", "maxDepth", "{", "maxDepth", "=", "fwcDepth", "\n", "}", "\n", "}", "\n", "return", "maxDepth", "\n", "}" ]

[ "visitLevel", "is", "used", "to", "descend", "the", "Sublist", "tree", "structure", "recursively", "." ]

[ "func", "subjectIsLiteral", "(", "subject", "string", ")", "bool", "{", "for", "i", ",", "c", ":=", "range", "subject", "{", "if", "c", "==", "pwc", "||", "c", "==", "fwc", "{", "if", "(", "i", "==", "0", "||", "subject", "[", "i", "-", "1", "]", "==", "btsep", ")", "&&", "(", "i", "+", "1", "==", "len", "(", "subject", ")", "||", "subject", "[", "i", "+", "1", "]", "==", "btsep", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Determine", "if", "the", "subject", "has", "any", "wildcards", ".", "Fast", "version", "does", "not", "check", "for", "valid", "subject", ".", "Used", "in", "caching", "layer", "." ]

[ "func", "IsValidSubject", "(", "subject", "string", ")", "bool", "{", "if", "subject", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "sfwc", ":=", "false", "\n", "tokens", ":=", "strings", ".", "Split", "(", "subject", ",", "tsep", ")", "\n", "for", "_", ",", "t", ":=", "range", "tokens", "{", "if", "len", "(", "t", ")", "==", "0", "||", "sfwc", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "t", ")", ">", "1", "{", "continue", "\n", "}", "\n", "switch", "t", "[", "0", "]", "{", "case", "fwc", ":", "sfwc", "=", "true", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsValidSubject", "returns", "true", "if", "a", "subject", "is", "valid", "false", "otherwise" ]

[ "func", "(", "s", "*", "Sublist", ")", "localSubs", "(", "subs", "*", "[", "]", "*", "subscription", ")", "{", "s", ".", "RLock", "(", ")", "\n", "s", ".", "collectLocalSubs", "(", "s", ".", "root", ",", "subs", ")", "\n", "s", ".", "RUnlock", "(", ")", "\n", "}" ]

[ "Return", "all", "local", "client", "subscriptions", ".", "Use", "the", "supplied", "slice", "." ]