Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.4k

[ "func", "(", "c", "*", "Consumer", ")", "QueryWatermarkOffsets", "(", "topic", "string", ",", "partition", "int32", ",", "timeoutMs", "int", ")", "(", "low", ",", "high", "int64", ",", "err", "error", ")", "{", "return", "queryWatermarkOffsets", "(", "c", ",", "topic", ",", "partition", ",", "timeoutMs", ")", "\n", "}" ]

[ "QueryWatermarkOffsets", "queries", "the", "broker", "for", "the", "low", "and", "high", "offsets", "for", "the", "given", "topic", "and", "partition", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "GetWatermarkOffsets", "(", "topic", "string", ",", "partition", "int32", ")", "(", "low", ",", "high", "int64", ",", "err", "error", ")", "{", "return", "getWatermarkOffsets", "(", "c", ",", "topic", ",", "partition", ")", "\n", "}" ]

[ "GetWatermarkOffsets", "returns", "the", "cached", "low", "and", "high", "offsets", "for", "the", "given", "topic", "and", "partition", ".", "The", "high", "offset", "is", "populated", "on", "every", "fetch", "response", "or", "via", "calling", "QueryWatermarkOffsets", ".", "The", "low", "offset", "is", "populated", "every", "statistics", ".", "interval", ".", "ms", "if", "that", "value", "is", "set", ".", "OffsetInvalid", "will", "be", "returned", "if", "there", "is", "no", "cached", "offset", "for", "either", "value", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "Assignment", "(", ")", "(", "partitions", "[", "]", "TopicPartition", ",", "err", "error", ")", "{", "var", "cParts", "*", "C", ".", "rd_kafka_topic_partition_list_t", "\n\n", "cErr", ":=", "C", ".", "rd_kafka_assignment", "(", "c", ".", "handle", ".", "rk", ",", "&", "cParts", ")", "\n", "if", "cErr", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "nil", ",", "newError", "(", "cErr", ")", "\n", "}", "\n", "defer", "C", ".", "rd_kafka_topic_partition_list_destroy", "(", "cParts", ")", "\n\n", "partitions", "=", "newTopicPartitionsFromCparts", "(", "cParts", ")", "\n\n", "return", "partitions", ",", "nil", "\n", "}" ]

[ "Assignment", "returns", "the", "current", "partition", "assignments" ]

[ "func", "(", "c", "*", "Consumer", ")", "Committed", "(", "partitions", "[", "]", "TopicPartition", ",", "timeoutMs", "int", ")", "(", "offsets", "[", "]", "TopicPartition", ",", "err", "error", ")", "{", "cparts", ":=", "newCPartsFromTopicPartitions", "(", "partitions", ")", "\n", "defer", "C", ".", "rd_kafka_topic_partition_list_destroy", "(", "cparts", ")", "\n", "cerr", ":=", "C", ".", "rd_kafka_committed", "(", "c", ".", "handle", ".", "rk", ",", "cparts", ",", "C", ".", "int", "(", "timeoutMs", ")", ")", "\n", "if", "cerr", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "nil", ",", "newError", "(", "cerr", ")", "\n", "}", "\n\n", "return", "newTopicPartitionsFromCparts", "(", "cparts", ")", ",", "nil", "\n", "}" ]

[ "Committed", "retrieves", "committed", "offsets", "for", "the", "given", "set", "of", "partitions" ]

[ "func", "(", "h", "*", "handle", ")", "waitTerminated", "(", "termCnt", "int", ")", "{", "// Wait for termCnt termination-done events from goroutines", "for", ";", "termCnt", ">", "0", ";", "termCnt", "--", "{", "_", "=", "<-", "h", ".", "terminatedChan", "\n", "}", "\n", "}" ]

[ "waitTerminated", "waits", "termination", "of", "background", "go", "-", "routines", ".", "termCnt", "is", "the", "number", "of", "goroutines", "expected", "to", "signal", "termination", "completion", "on", "h", ".", "terminatedChan" ]

[ "func", "(", "h", "*", "handle", ")", "getRkt0", "(", "topic", "string", ",", "ctopic", "*", "C", ".", "char", ",", "doLock", "bool", ")", "(", "crkt", "*", "C", ".", "rd_kafka_topic_t", ")", "{", "if", "doLock", "{", "h", ".", "rktCacheLock", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "rktCacheLock", ".", "Unlock", "(", ")", "\n", "}", "\n", "crkt", ",", "ok", ":=", "h", ".", "rktCache", "[", "topic", "]", "\n", "if", "ok", "{", "return", "crkt", "\n", "}", "\n\n", "if", "ctopic", "==", "nil", "{", "ctopic", "=", "C", ".", "CString", "(", "topic", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "ctopic", ")", ")", "\n", "}", "\n\n", "crkt", "=", "C", ".", "rd_kafka_topic_new", "(", "h", ".", "rk", ",", "ctopic", ",", "nil", ")", "\n", "if", "crkt", "==", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "topic", ",", "C", ".", "GoString", "(", "C", ".", "rd_kafka_err2str", "(", "C", ".", "rd_kafka_last_error", "(", ")", ")", ")", ")", ")", "\n", "}", "\n\n", "h", ".", "rktCache", "[", "topic", "]", "=", "crkt", "\n", "h", ".", "rktNameCache", "[", "crkt", "]", "=", "topic", "\n\n", "return", "crkt", "\n", "}" ]

[ "getRkt0", "finds", "or", "creates", "and", "returns", "a", "C", "topic_t", "object", "from", "the", "local", "cache", "." ]

[ "func", "(", "h", "*", "handle", ")", "getRkt", "(", "topic", "string", ")", "(", "crkt", "*", "C", ".", "rd_kafka_topic_t", ")", "{", "return", "h", ".", "getRkt0", "(", "topic", ",", "nil", ",", "true", ")", "\n", "}" ]

[ "getRkt", "finds", "or", "creates", "and", "returns", "a", "C", "topic_t", "object", "from", "the", "local", "cache", "." ]

[ "func", "(", "h", "*", "handle", ")", "getTopicNameFromRkt", "(", "crkt", "*", "C", ".", "rd_kafka_topic_t", ")", "(", "topic", "string", ")", "{", "h", ".", "rktCacheLock", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "rktCacheLock", ".", "Unlock", "(", ")", "\n\n", "topic", ",", "ok", ":=", "h", ".", "rktNameCache", "[", "crkt", "]", "\n", "if", "ok", "{", "return", "topic", "\n", "}", "\n\n", "// we need our own copy/refcount of the crkt", "ctopic", ":=", "C", ".", "rd_kafka_topic_name", "(", "crkt", ")", "\n", "topic", "=", "C", ".", "GoString", "(", "ctopic", ")", "\n\n", "crkt", "=", "h", ".", "getRkt0", "(", "topic", ",", "ctopic", ",", "false", "/* dont lock */", ")", "\n\n", "return", "topic", "\n", "}" ]

[ "getTopicNameFromRkt", "returns", "the", "topic", "name", "for", "a", "C", "topic_t", "object", "preferably", "using", "the", "local", "cache", "to", "avoid", "a", "cgo", "call", "." ]

[ "func", "(", "h", "*", "handle", ")", "cgoGet", "(", "cgoid", "int", ")", "(", "cg", "cgoif", ",", "found", "bool", ")", "{", "if", "cgoid", "==", "0", "{", "return", "nil", ",", "false", "\n", "}", "\n\n", "h", ".", "cgoLock", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "cgoLock", ".", "Unlock", "(", ")", "\n", "cg", ",", "found", "=", "h", ".", "cgomap", "[", "cgoid", "]", "\n", "if", "found", "{", "delete", "(", "h", ".", "cgomap", ",", "cgoid", ")", "\n", "}", "\n\n", "return", "cg", ",", "found", "\n", "}" ]

[ "cgoGet", "looks", "up", "cgoid", "in", "the", "cgo", "map", "deletes", "the", "reference", "from", "the", "map", "and", "returns", "the", "object", "if", "found", ".", "Else", "returns", "nil", "false", ".", "Thread", "-", "safe", "." ]

[ "func", "(", "c", "ErrorCode", ")", "String", "(", ")", "string", "{", "return", "C", ".", "GoString", "(", "C", ".", "rd_kafka_err2str", "(", "C", ".", "rd_kafka_resp_err_t", "(", "c", ")", ")", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "readable", "representation", "of", "an", "error", "code" ]

[ "func", "(", "h", "Header", ")", "String", "(", ")", "string", "{", "if", "h", ".", "Value", "==", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ".", "Key", ")", "\n", "}", "\n\n", "valueLen", ":=", "len", "(", "h", ".", "Value", ")", "\n", "if", "valueLen", "==", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ".", "Key", ")", "\n", "}", "\n\n", "truncSize", ":=", "valueLen", "\n", "trunc", ":=", "\"", "\"", "\n", "if", "valueLen", ">", "50", "+", "15", "{", "truncSize", "=", "50", "\n", "trunc", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "valueLen", "-", "truncSize", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ".", "Key", ",", "strconv", ".", "Quote", "(", "string", "(", "h", ".", "Value", "[", ":", "truncSize", "]", ")", ")", ",", "trunc", ")", "\n", "}" ]

[ "String", "returns", "the", "Header", "Key", "and", "data", "in", "a", "human", "representable", "possibly", "truncated", "form", "suitable", "for", "displaying", "to", "the", "user", "." ]

[ "func", "(", "t", "TopicResult", ")", "String", "(", ")", "string", "{", "if", "t", ".", "Error", ".", "code", "==", "0", "{", "return", "t", ".", "Topic", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "t", ".", "Topic", ",", "t", ".", "Error", ".", "str", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "a", "TopicResult", "." ]

[ "func", "(", "t", "ResourceType", ")", "String", "(", ")", "string", "{", "return", "C", ".", "GoString", "(", "C", ".", "rd_kafka_ResourceType_name", "(", "C", ".", "rd_kafka_ResourceType_t", "(", "t", ")", ")", ")", "\n", "}" ]

[ "String", "returns", "the", "human", "-", "readable", "representation", "of", "a", "ResourceType" ]

[ "func", "(", "t", "ConfigSource", ")", "String", "(", ")", "string", "{", "return", "C", ".", "GoString", "(", "C", ".", "rd_kafka_ConfigSource_name", "(", "C", ".", "rd_kafka_ConfigSource_t", "(", "t", ")", ")", ")", "\n", "}" ]

[ "String", "returns", "the", "human", "-", "readable", "representation", "of", "a", "ConfigSource", "type" ]

[ "func", "(", "c", "ConfigResource", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Type", ",", "c", ".", "Name", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "a", "ConfigResource" ]

[ "func", "(", "o", "AlterOperation", ")", "String", "(", ")", "string", "{", "switch", "o", "{", "case", "AlterOperationSet", ":", "return", "\"", "\"", "\n", "default", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int", "(", "o", ")", ")", "\n", "}", "\n", "}" ]

[ "String", "returns", "the", "human", "-", "readable", "representation", "of", "an", "AlterOperation" ]

[ "func", "StringMapToConfigEntries", "(", "stringMap", "map", "[", "string", "]", "string", ",", "operation", "AlterOperation", ")", "[", "]", "ConfigEntry", "{", "var", "ceList", "[", "]", "ConfigEntry", "\n\n", "for", "k", ",", "v", ":=", "range", "stringMap", "{", "ceList", "=", "append", "(", "ceList", ",", "ConfigEntry", "{", "Name", ":", "k", ",", "Value", ":", "v", ",", "Operation", ":", "operation", "}", ")", "\n", "}", "\n\n", "return", "ceList", "\n", "}" ]

[ "StringMapToConfigEntries", "creates", "a", "new", "map", "of", "ConfigEntry", "objects", "from", "the", "provided", "string", "map", ".", "The", "AlterOperation", "is", "set", "on", "each", "created", "entry", "." ]

[ "func", "(", "c", "ConfigEntry", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "c", ".", "Operation", ",", "c", ".", "Name", ",", "c", ".", "Value", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "a", "ConfigEntry", "." ]

[ "func", "(", "c", "ConfigEntryResult", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "c", ".", "Name", ",", "c", ".", "Value", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "a", "ConfigEntryResult", "." ]

[ "func", "configEntryResultFromC", "(", "cEntry", "*", "C", ".", "rd_kafka_ConfigEntry_t", ")", "(", "entry", "ConfigEntryResult", ")", "{", "entry", ".", "Name", "=", "C", ".", "GoString", "(", "C", ".", "rd_kafka_ConfigEntry_name", "(", "cEntry", ")", ")", "\n", "cValue", ":=", "C", ".", "rd_kafka_ConfigEntry_value", "(", "cEntry", ")", "\n", "if", "cValue", "!=", "nil", "{", "entry", ".", "Value", "=", "C", ".", "GoString", "(", "cValue", ")", "\n", "}", "\n", "entry", ".", "Source", "=", "ConfigSource", "(", "C", ".", "rd_kafka_ConfigEntry_source", "(", "cEntry", ")", ")", "\n", "entry", ".", "IsReadOnly", "=", "cint2bool", "(", "C", ".", "rd_kafka_ConfigEntry_is_read_only", "(", "cEntry", ")", ")", "\n", "entry", ".", "IsSensitive", "=", "cint2bool", "(", "C", ".", "rd_kafka_ConfigEntry_is_sensitive", "(", "cEntry", ")", ")", "\n", "entry", ".", "IsSynonym", "=", "cint2bool", "(", "C", ".", "rd_kafka_ConfigEntry_is_synonym", "(", "cEntry", ")", ")", "\n\n", "var", "cSynCnt", "C", ".", "size_t", "\n", "cSyns", ":=", "C", ".", "rd_kafka_ConfigEntry_synonyms", "(", "cEntry", ",", "&", "cSynCnt", ")", "\n", "if", "cSynCnt", ">", "0", "{", "entry", ".", "Synonyms", "=", "make", "(", "map", "[", "string", "]", "ConfigEntryResult", ")", "\n", "}", "\n\n", "for", "si", ":=", "0", ";", "si", "<", "int", "(", "cSynCnt", ")", ";", "si", "++", "{", "cSyn", ":=", "C", ".", "ConfigEntry_by_idx", "(", "cSyns", ",", "cSynCnt", ",", "C", ".", "size_t", "(", "si", ")", ")", "\n", "Syn", ":=", "configEntryResultFromC", "(", "cSyn", ")", "\n", "entry", ".", "Synonyms", "[", "Syn", ".", "Name", "]", "=", "Syn", "\n", "}", "\n\n", "return", "entry", "\n", "}" ]

[ "setFromC", "sets", "up", "a", "ConfigEntryResult", "from", "a", "C", "ConfigEntry" ]

[ "func", "(", "c", "ConfigResourceResult", ")", "String", "(", ")", "string", "{", "if", "c", ".", "Error", ".", "Code", "(", ")", "!=", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "c", ".", "Type", ",", "c", ".", "Name", ",", "c", ".", "Error", ")", "\n\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Type", ",", "c", ".", "Name", ",", "len", "(", "c", ".", "Config", ")", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "a", "ConfigResourceResult", "." ]

[ "func", "(", "a", "*", "AdminClient", ")", "waitResult", "(", "ctx", "context", ".", "Context", ",", "cQueue", "*", "C", ".", "rd_kafka_queue_t", ",", "cEventType", "C", ".", "rd_kafka_event_type_t", ")", "(", "rkev", "*", "C", ".", "rd_kafka_event_t", ",", "err", "error", ")", "{", "resultChan", ":=", "make", "(", "chan", "*", "C", ".", "rd_kafka_event_t", ")", "\n", "closeChan", ":=", "make", "(", "chan", "bool", ")", "// never written to, just closed", "\n\n", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "_", ",", "ok", ":=", "<-", "closeChan", ":", "if", "!", "ok", "{", "// Context cancelled/timed out", "close", "(", "resultChan", ")", "\n", "return", "\n", "}", "\n\n", "default", ":", "// Wait for result event for at most 50ms", "// to avoid blocking for too long if", "// context is cancelled.", "rkev", ":=", "C", ".", "rd_kafka_queue_poll", "(", "cQueue", ",", "50", ")", "\n", "if", "rkev", "!=", "nil", "{", "resultChan", "<-", "rkev", "\n", "close", "(", "resultChan", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "rkev", "=", "<-", "resultChan", ":", "// Result type check", "if", "cEventType", "!=", "C", ".", "rd_kafka_event_type", "(", "rkev", ")", "{", "err", "=", "newErrorFromString", "(", "ErrInvalidType", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "(", "int", ")", "(", "cEventType", ")", ",", "(", "int", ")", "(", "C", ".", "rd_kafka_event_type", "(", "rkev", ")", ")", ")", ")", "\n", "C", ".", "rd_kafka_event_destroy", "(", "rkev", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Generic error handling", "cErr", ":=", "C", ".", "rd_kafka_event_error", "(", "rkev", ")", "\n", "if", "cErr", "!=", "0", "{", "err", "=", "newErrorFromCString", "(", "cErr", ",", "C", ".", "rd_kafka_event_error_string", "(", "rkev", ")", ")", "\n", "C", ".", "rd_kafka_event_destroy", "(", "rkev", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "close", "(", "closeChan", ")", "\n", "return", "rkev", ",", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "// signal close to go-routine", "close", "(", "closeChan", ")", "\n", "// wait for close from go-routine to make sure it is done", "// using cQueue before we return.", "rkev", ",", "ok", ":=", "<-", "resultChan", "\n", "if", "ok", "{", "// throw away result since context was cancelled", "C", ".", "rd_kafka_event_destroy", "(", "rkev", ")", "\n", "}", "\n", "return", "nil", ",", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "waitResult", "waits", "for", "a", "result", "event", "on", "cQueue", "or", "the", "ctx", "to", "be", "cancelled", "whichever", "happens", "first", ".", "The", "returned", "result", "event", "is", "checked", "for", "errors", "its", "error", "is", "returned", "if", "set", "." ]

[ "func", "(", "a", "*", "AdminClient", ")", "cToTopicResults", "(", "cTopicRes", "*", "*", "C", ".", "rd_kafka_topic_result_t", ",", "cCnt", "C", ".", "size_t", ")", "(", "result", "[", "]", "TopicResult", ",", "err", "error", ")", "{", "result", "=", "make", "(", "[", "]", "TopicResult", ",", "int", "(", "cCnt", ")", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "int", "(", "cCnt", ")", ";", "i", "++", "{", "cTopic", ":=", "C", ".", "topic_result_by_idx", "(", "cTopicRes", ",", "cCnt", ",", "C", ".", "size_t", "(", "i", ")", ")", "\n", "result", "[", "i", "]", ".", "Topic", "=", "C", ".", "GoString", "(", "C", ".", "rd_kafka_topic_result_name", "(", "cTopic", ")", ")", "\n", "result", "[", "i", "]", ".", "Error", "=", "newErrorFromCString", "(", "C", ".", "rd_kafka_topic_result_error", "(", "cTopic", ")", ",", "C", ".", "rd_kafka_topic_result_error_string", "(", "cTopic", ")", ")", "\n", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "cToTopicResults", "converts", "a", "C", "topic_result_t", "array", "to", "Go", "TopicResult", "list", "." ]

[ "func", "(", "a", "*", "AdminClient", ")", "cConfigResourceToResult", "(", "cRes", "*", "*", "C", ".", "rd_kafka_ConfigResource_t", ",", "cCnt", "C", ".", "size_t", ")", "(", "result", "[", "]", "ConfigResourceResult", ",", "err", "error", ")", "{", "result", "=", "make", "(", "[", "]", "ConfigResourceResult", ",", "int", "(", "cCnt", ")", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "int", "(", "cCnt", ")", ";", "i", "++", "{", "cRes", ":=", "C", ".", "ConfigResource_by_idx", "(", "cRes", ",", "cCnt", ",", "C", ".", "size_t", "(", "i", ")", ")", "\n", "result", "[", "i", "]", ".", "Type", "=", "ResourceType", "(", "C", ".", "rd_kafka_ConfigResource_type", "(", "cRes", ")", ")", "\n", "result", "[", "i", "]", ".", "Name", "=", "C", ".", "GoString", "(", "C", ".", "rd_kafka_ConfigResource_name", "(", "cRes", ")", ")", "\n", "result", "[", "i", "]", ".", "Error", "=", "newErrorFromCString", "(", "C", ".", "rd_kafka_ConfigResource_error", "(", "cRes", ")", ",", "C", ".", "rd_kafka_ConfigResource_error_string", "(", "cRes", ")", ")", "\n", "var", "cConfigCnt", "C", ".", "size_t", "\n", "cConfigs", ":=", "C", ".", "rd_kafka_ConfigResource_configs", "(", "cRes", ",", "&", "cConfigCnt", ")", "\n", "if", "cConfigCnt", ">", "0", "{", "result", "[", "i", "]", ".", "Config", "=", "make", "(", "map", "[", "string", "]", "ConfigEntryResult", ")", "\n", "}", "\n", "for", "ci", ":=", "0", ";", "ci", "<", "int", "(", "cConfigCnt", ")", ";", "ci", "++", "{", "cEntry", ":=", "C", ".", "ConfigEntry_by_idx", "(", "cConfigs", ",", "cConfigCnt", ",", "C", ".", "size_t", "(", "ci", ")", ")", "\n", "entry", ":=", "configEntryResultFromC", "(", "cEntry", ")", "\n", "result", "[", "i", "]", ".", "Config", "[", "entry", ".", "Name", "]", "=", "entry", "\n", "}", "\n", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "cConfigResourceToResult", "converts", "a", "C", "ConfigResource", "result", "array", "to", "Go", "ConfigResourceResult" ]

[ "func", "(", "a", "*", "AdminClient", ")", "DeleteTopics", "(", "ctx", "context", ".", "Context", ",", "topics", "[", "]", "string", ",", "options", "...", "DeleteTopicsAdminOption", ")", "(", "result", "[", "]", "TopicResult", ",", "err", "error", ")", "{", "cTopics", ":=", "make", "(", "[", "]", "*", "C", ".", "rd_kafka_DeleteTopic_t", ",", "len", "(", "topics", ")", ")", "\n\n", "cErrstrSize", ":=", "C", ".", "size_t", "(", "512", ")", "\n", "cErrstr", ":=", "(", "*", "C", ".", "char", ")", "(", "C", ".", "malloc", "(", "cErrstrSize", ")", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cErrstr", ")", ")", "\n\n", "// Convert Go DeleteTopics to C DeleteTopics", "for", "i", ",", "topic", ":=", "range", "topics", "{", "cTopics", "[", "i", "]", "=", "C", ".", "rd_kafka_DeleteTopic_new", "(", "C", ".", "CString", "(", "topic", ")", ")", "\n", "if", "cTopics", "[", "i", "]", "==", "nil", "{", "return", "nil", ",", "newErrorFromString", "(", "ErrInvalidArg", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "topic", ")", ")", "\n", "}", "\n\n", "defer", "C", ".", "rd_kafka_DeleteTopic_destroy", "(", "cTopics", "[", "i", "]", ")", "\n", "}", "\n\n", "// Convert Go AdminOptions (if any) to C AdminOptions", "genericOptions", ":=", "make", "(", "[", "]", "AdminOption", ",", "len", "(", "options", ")", ")", "\n", "for", "i", ":=", "range", "options", "{", "genericOptions", "[", "i", "]", "=", "options", "[", "i", "]", "\n", "}", "\n", "cOptions", ",", "err", ":=", "adminOptionsSetup", "(", "a", ".", "handle", ",", "C", ".", "RD_KAFKA_ADMIN_OP_DELETETOPICS", ",", "genericOptions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "C", ".", "rd_kafka_AdminOptions_destroy", "(", "cOptions", ")", "\n\n", "// Create temporary queue for async operation", "cQueue", ":=", "C", ".", "rd_kafka_queue_new", "(", "a", ".", "handle", ".", "rk", ")", "\n", "defer", "C", ".", "rd_kafka_queue_destroy", "(", "cQueue", ")", "\n\n", "// Asynchronous call", "C", ".", "rd_kafka_DeleteTopics", "(", "a", ".", "handle", ".", "rk", ",", "(", "*", "*", "C", ".", "rd_kafka_DeleteTopic_t", ")", "(", "&", "cTopics", "[", "0", "]", ")", ",", "C", ".", "size_t", "(", "len", "(", "cTopics", ")", ")", ",", "cOptions", ",", "cQueue", ")", "\n\n", "// Wait for result, error or context timeout", "rkev", ",", "err", ":=", "a", ".", "waitResult", "(", "ctx", ",", "cQueue", ",", "C", ".", "RD_KAFKA_EVENT_DELETETOPICS_RESULT", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "C", ".", "rd_kafka_event_destroy", "(", "rkev", ")", "\n\n", "cRes", ":=", "C", ".", "rd_kafka_event_DeleteTopics_result", "(", "rkev", ")", "\n\n", "// Convert result from C to Go", "var", "cCnt", "C", ".", "size_t", "\n", "cTopicRes", ":=", "C", ".", "rd_kafka_DeleteTopics_result_topics", "(", "cRes", ",", "&", "cCnt", ")", "\n\n", "return", "a", ".", "cToTopicResults", "(", "cTopicRes", ",", "cCnt", ")", "\n", "}" ]

[ "DeleteTopics", "deletes", "a", "batch", "of", "topics", ".", "This", "operation", "is", "not", "transactional", "and", "may", "succeed", "for", "a", "subset", "of", "topics", "while", "failing", "others", ".", "It", "may", "take", "several", "seconds", "after", "the", "DeleteTopics", "result", "returns", "success", "for", "all", "the", "brokers", "to", "become", "aware", "that", "the", "topics", "are", "gone", ".", "During", "this", "time", "topic", "metadata", "and", "configuration", "may", "continue", "to", "return", "information", "about", "deleted", "topics", ".", "Requires", "broker", "version", ">", "=", "0", ".", "10", ".", "1", ".", "0" ]

[ "func", "(", "a", "*", "AdminClient", ")", "Close", "(", ")", "{", "if", "a", ".", "isDerived", "{", "// Derived AdminClient needs no cleanup.", "a", ".", "handle", "=", "&", "handle", "{", "}", "\n", "return", "\n", "}", "\n\n", "a", ".", "handle", ".", "cleanup", "(", ")", "\n\n", "C", ".", "rd_kafka_destroy", "(", "a", ".", "handle", ".", "rk", ")", "\n", "}" ]

[ "Close", "an", "AdminClient", "instance", "." ]

[ "func", "NewAdminClient", "(", "conf", "*", "ConfigMap", ")", "(", "*", "AdminClient", ",", "error", ")", "{", "err", ":=", "versionCheck", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "a", ":=", "&", "AdminClient", "{", "}", "\n", "a", ".", "handle", "=", "&", "handle", "{", "}", "\n\n", "// Convert ConfigMap to librdkafka conf_t", "cConf", ",", "err", ":=", "conf", ".", "convert", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "cErrstr", ":=", "(", "*", "C", ".", "char", ")", "(", "C", ".", "malloc", "(", "C", ".", "size_t", "(", "256", ")", ")", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cErrstr", ")", ")", "\n\n", "// Create librdkafka producer instance. The Producer is somewhat cheaper than", "// the consumer, but any instance type can be used for Admin APIs.", "a", ".", "handle", ".", "rk", "=", "C", ".", "rd_kafka_new", "(", "C", ".", "RD_KAFKA_PRODUCER", ",", "cConf", ",", "cErrstr", ",", "256", ")", "\n", "if", "a", ".", "handle", ".", "rk", "==", "nil", "{", "return", "nil", ",", "newErrorFromCString", "(", "C", ".", "RD_KAFKA_RESP_ERR__INVALID_ARG", ",", "cErrstr", ")", "\n", "}", "\n\n", "a", ".", "isDerived", "=", "false", "\n", "a", ".", "handle", ".", "setup", "(", ")", "\n\n", "return", "a", ",", "nil", "\n", "}" ]

[ "NewAdminClient", "creats", "a", "new", "AdminClient", "instance", "with", "a", "new", "underlying", "client", "instance" ]

[ "func", "NewAdminClientFromProducer", "(", "p", "*", "Producer", ")", "(", "a", "*", "AdminClient", ",", "err", "error", ")", "{", "if", "p", ".", "handle", ".", "rk", "==", "nil", "{", "return", "nil", ",", "newErrorFromString", "(", "ErrInvalidArg", ",", "\"", "\"", ")", "\n", "}", "\n\n", "a", "=", "&", "AdminClient", "{", "}", "\n", "a", ".", "handle", "=", "&", "p", ".", "handle", "\n", "a", ".", "isDerived", "=", "true", "\n", "return", "a", ",", "nil", "\n", "}" ]

[ "NewAdminClientFromProducer", "derives", "a", "new", "AdminClient", "from", "an", "existing", "Producer", "instance", ".", "The", "AdminClient", "will", "use", "the", "same", "configuration", "and", "connections", "as", "the", "parent", "instance", "." ]

[ "func", "NewAdminClientFromConsumer", "(", "c", "*", "Consumer", ")", "(", "a", "*", "AdminClient", ",", "err", "error", ")", "{", "if", "c", ".", "handle", ".", "rk", "==", "nil", "{", "return", "nil", ",", "newErrorFromString", "(", "ErrInvalidArg", ",", "\"", "\"", ")", "\n", "}", "\n\n", "a", "=", "&", "AdminClient", "{", "}", "\n", "a", ".", "handle", "=", "&", "c", ".", "handle", "\n", "a", ".", "isDerived", "=", "true", "\n", "return", "a", ",", "nil", "\n", "}" ]

[ "NewAdminClientFromConsumer", "derives", "a", "new", "AdminClient", "from", "an", "existing", "Consumer", "instance", ".", "The", "AdminClient", "will", "use", "the", "same", "configuration", "and", "connections", "as", "the", "parent", "instance", "." ]

[ "func", "(", "m", "ConfigMap", ")", "get", "(", "key", "string", ",", "defval", "ConfigValue", ")", "(", "ConfigValue", ",", "error", ")", "{", "if", "strings", ".", "HasPrefix", "(", "key", ",", "\"", "\"", ")", "{", "defconfCv", ",", "found", ":=", "m", "[", "\"", "\"", "]", "\n", "if", "!", "found", "{", "return", "defval", ",", "nil", "\n", "}", "\n", "return", "defconfCv", ".", "(", "ConfigMap", ")", ".", "get", "(", "strings", ".", "TrimPrefix", "(", "key", ",", "\"", "\"", ")", ",", "defval", ")", "\n", "}", "\n\n", "v", ",", "ok", ":=", "m", "[", "key", "]", "\n", "if", "!", "ok", "{", "return", "defval", ",", "nil", "\n", "}", "\n\n", "if", "defval", "!=", "nil", "&&", "reflect", ".", "TypeOf", "(", "defval", ")", "!=", "reflect", ".", "TypeOf", "(", "v", ")", "{", "return", "nil", ",", "newErrorFromString", "(", "ErrInvalidArg", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ",", "defval", ",", "v", ")", ")", "\n", "}", "\n\n", "return", "v", ",", "nil", "\n", "}" ]

[ "get", "finds", "key", "in", "the", "configmap", "and", "returns", "its", "value", ".", "If", "the", "key", "is", "not", "found", "defval", "is", "returned", ".", "If", "the", "key", "is", "found", "but", "the", "type", "is", "mismatched", "an", "error", "is", "returned", "." ]

[ "func", "queryWatermarkOffsets", "(", "H", "Handle", ",", "topic", "string", ",", "partition", "int32", ",", "timeoutMs", "int", ")", "(", "low", ",", "high", "int64", ",", "err", "error", ")", "{", "h", ":=", "H", ".", "gethandle", "(", ")", "\n\n", "ctopic", ":=", "C", ".", "CString", "(", "topic", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "ctopic", ")", ")", "\n\n", "var", "cLow", ",", "cHigh", "C", ".", "int64_t", "\n\n", "e", ":=", "C", ".", "rd_kafka_query_watermark_offsets", "(", "h", ".", "rk", ",", "ctopic", ",", "C", ".", "int32_t", "(", "partition", ")", ",", "&", "cLow", ",", "&", "cHigh", ",", "C", ".", "int", "(", "timeoutMs", ")", ")", "\n", "if", "e", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "0", ",", "0", ",", "newError", "(", "e", ")", "\n", "}", "\n\n", "low", "=", "int64", "(", "cLow", ")", "\n", "high", "=", "int64", "(", "cHigh", ")", "\n", "return", "low", ",", "high", ",", "nil", "\n", "}" ]

[ "queryWatermarkOffsets", "returns", "the", "broker", "s", "low", "and", "high", "offsets", "for", "the", "given", "topic", "and", "partition", "." ]

[ "func", "OffsetTail", "(", "relativeOffset", "Offset", ")", "Offset", "{", "return", "Offset", "(", "C", ".", "_c_rdkafka_offset_tail", "(", "C", ".", "int64_t", "(", "relativeOffset", ")", ")", ")", "\n", "}" ]

[ "OffsetTail", "returns", "the", "logical", "offset", "relativeOffset", "from", "current", "end", "of", "partition" ]

[ "func", "offsetsForTimes", "(", "H", "Handle", ",", "times", "[", "]", "TopicPartition", ",", "timeoutMs", "int", ")", "(", "offsets", "[", "]", "TopicPartition", ",", "err", "error", ")", "{", "cparts", ":=", "newCPartsFromTopicPartitions", "(", "times", ")", "\n", "defer", "C", ".", "rd_kafka_topic_partition_list_destroy", "(", "cparts", ")", "\n", "cerr", ":=", "C", ".", "rd_kafka_offsets_for_times", "(", "H", ".", "gethandle", "(", ")", ".", "rk", ",", "cparts", ",", "C", ".", "int", "(", "timeoutMs", ")", ")", "\n", "if", "cerr", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "nil", ",", "newError", "(", "cerr", ")", "\n", "}", "\n\n", "return", "newTopicPartitionsFromCparts", "(", "cparts", ")", ",", "nil", "\n", "}" ]

[ "offsetsForTimes", "looks", "up", "offsets", "by", "timestamp", "for", "the", "given", "partitions", ".", "The", "returned", "offset", "for", "each", "partition", "is", "the", "earliest", "offset", "whose", "timestamp", "is", "greater", "than", "or", "equal", "to", "the", "given", "timestamp", "in", "the", "corresponding", "partition", ".", "The", "timestamps", "to", "query", "are", "represented", "as", ".", "Offset", "in", "the", "times", "argument", "and", "the", "looked", "up", "offsets", "are", "represented", "as", ".", "Offset", "in", "the", "returned", "offsets", "list", ".", "The", "function", "will", "block", "for", "at", "most", "timeoutMs", "milliseconds", ".", "Duplicate", "Topic", "+", "Partitions", "are", "not", "supported", ".", "Per", "-", "partition", "errors", "may", "be", "returned", "in", "the", ".", "Error", "field", "." ]

[ "func", "(", "p", "*", "Producer", ")", "Len", "(", ")", "int", "{", "return", "len", "(", "p", ".", "produceChannel", ")", "+", "len", "(", "p", ".", "events", ")", "+", "int", "(", "C", ".", "rd_kafka_outq_len", "(", "p", ".", "handle", ".", "rk", ")", ")", "\n", "}" ]

[ "Len", "returns", "the", "number", "of", "messages", "and", "requests", "waiting", "to", "be", "transmitted", "to", "the", "broker", "as", "well", "as", "delivery", "reports", "queued", "for", "the", "application", ".", "Includes", "messages", "on", "ProduceChannel", "." ]

[ "func", "(", "p", "*", "Producer", ")", "Flush", "(", "timeoutMs", "int", ")", "int", "{", "termChan", ":=", "make", "(", "chan", "bool", ")", "// unused stand-in termChan", "\n\n", "d", ",", "_", ":=", "time", ".", "ParseDuration", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "timeoutMs", ")", ")", "\n", "tEnd", ":=", "time", ".", "Now", "(", ")", ".", "Add", "(", "d", ")", "\n", "for", "p", ".", "Len", "(", ")", ">", "0", "{", "remain", ":=", "tEnd", ".", "Sub", "(", "time", ".", "Now", "(", ")", ")", ".", "Seconds", "(", ")", "\n", "if", "remain", "<=", "0.0", "{", "return", "p", ".", "Len", "(", ")", "\n", "}", "\n\n", "p", ".", "handle", ".", "eventPoll", "(", "p", ".", "events", ",", "int", "(", "math", ".", "Min", "(", "100", ",", "remain", "*", "1000", ")", ")", ",", "1000", ",", "termChan", ")", "\n", "}", "\n\n", "return", "0", "\n", "}" ]

[ "Flush", "and", "wait", "for", "outstanding", "messages", "and", "requests", "to", "complete", "delivery", ".", "Includes", "messages", "on", "ProduceChannel", ".", "Runs", "until", "value", "reaches", "zero", "or", "on", "timeoutMs", ".", "Returns", "the", "number", "of", "outstanding", "events", "still", "un", "-", "flushed", "." ]

[ "func", "(", "p", "*", "Producer", ")", "Close", "(", ")", "{", "// Wait for poller() (signaled by closing pollerTermChan)", "// and channel_producer() (signaled by closing ProduceChannel)", "close", "(", "p", ".", "pollerTermChan", ")", "\n", "close", "(", "p", ".", "produceChannel", ")", "\n", "p", ".", "handle", ".", "waitTerminated", "(", "2", ")", "\n\n", "close", "(", "p", ".", "events", ")", "\n\n", "p", ".", "handle", ".", "cleanup", "(", ")", "\n\n", "C", ".", "rd_kafka_destroy", "(", "p", ".", "handle", ".", "rk", ")", "\n", "}" ]

[ "Close", "a", "Producer", "instance", ".", "The", "Producer", "object", "or", "its", "channels", "are", "no", "longer", "usable", "after", "this", "call", "." ]

[ "func", "channelProducer", "(", "p", "*", "Producer", ")", "{", "for", "m", ":=", "range", "p", ".", "produceChannel", "{", "err", ":=", "p", ".", "produce", "(", "m", ",", "C", ".", "RD_KAFKA_MSG_F_BLOCK", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "TopicPartition", ".", "Error", "=", "err", "\n", "p", ".", "events", "<-", "m", "\n", "}", "\n", "}", "\n\n", "p", ".", "handle", ".", "terminatedChan", "<-", "\"", "\"", "\n", "}" ]

[ "channel_producer", "serves", "the", "ProduceChannel", "channel" ]

[ "func", "poller", "(", "p", "*", "Producer", ",", "termChan", "chan", "bool", ")", "{", "out", ":", "for", "true", "{", "select", "{", "case", "_", "=", "<-", "termChan", ":", "break", "out", "\n\n", "default", ":", "_", ",", "term", ":=", "p", ".", "handle", ".", "eventPoll", "(", "p", ".", "events", ",", "100", ",", "1000", ",", "termChan", ")", "\n", "if", "term", "{", "break", "out", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n\n", "p", ".", "handle", ".", "terminatedChan", "<-", "\"", "\"", "\n\n", "}" ]

[ "poller", "polls", "the", "rd_kafka_t", "handle", "for", "events", "until", "signalled", "for", "termination" ]

[ "func", "(", "p", "*", "Producer", ")", "QueryWatermarkOffsets", "(", "topic", "string", ",", "partition", "int32", ",", "timeoutMs", "int", ")", "(", "low", ",", "high", "int64", ",", "err", "error", ")", "{", "return", "queryWatermarkOffsets", "(", "p", ",", "topic", ",", "partition", ",", "timeoutMs", ")", "\n", "}" ]

[ "QueryWatermarkOffsets", "returns", "the", "broker", "s", "low", "and", "high", "offsets", "for", "the", "given", "topic", "and", "partition", "." ]

[ "func", "(", "m", "*", "Message", ")", "String", "(", ")", "string", "{", "var", "topic", "string", "\n", "if", "m", ".", "TopicPartition", ".", "Topic", "!=", "nil", "{", "topic", "=", "*", "m", ".", "TopicPartition", ".", "Topic", "\n", "}", "else", "{", "topic", "=", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "topic", ",", "m", ".", "TopicPartition", ".", "Partition", ",", "m", ".", "TopicPartition", ".", "Offset", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "readable", "representation", "of", "a", "Message", ".", "Key", "and", "payload", "are", "not", "represented", "." ]

[ "func", "(", "h", "*", "handle", ")", "setupMessageFromC", "(", "msg", "*", "Message", ",", "cmsg", "*", "C", ".", "rd_kafka_message_t", ")", "{", "if", "cmsg", ".", "rkt", "!=", "nil", "{", "topic", ":=", "h", ".", "getTopicNameFromRkt", "(", "cmsg", ".", "rkt", ")", "\n", "msg", ".", "TopicPartition", ".", "Topic", "=", "&", "topic", "\n", "}", "\n", "msg", ".", "TopicPartition", ".", "Partition", "=", "int32", "(", "cmsg", ".", "partition", ")", "\n", "if", "cmsg", ".", "payload", "!=", "nil", "{", "msg", ".", "Value", "=", "C", ".", "GoBytes", "(", "unsafe", ".", "Pointer", "(", "cmsg", ".", "payload", ")", ",", "C", ".", "int", "(", "cmsg", ".", "len", ")", ")", "\n", "}", "\n", "if", "cmsg", ".", "key", "!=", "nil", "{", "msg", ".", "Key", "=", "C", ".", "GoBytes", "(", "unsafe", ".", "Pointer", "(", "cmsg", ".", "key", ")", ",", "C", ".", "int", "(", "cmsg", ".", "key_len", ")", ")", "\n", "}", "\n", "msg", ".", "TopicPartition", ".", "Offset", "=", "Offset", "(", "cmsg", ".", "offset", ")", "\n", "if", "cmsg", ".", "err", "!=", "0", "{", "msg", ".", "TopicPartition", ".", "Error", "=", "newError", "(", "cmsg", ".", "err", ")", "\n", "}", "\n", "}" ]

[ "setupMessageFromC", "sets", "up", "a", "message", "object", "from", "a", "C", "rd_kafka_message_t" ]

[ "func", "(", "h", "*", "handle", ")", "messageToC", "(", "msg", "*", "Message", ",", "cmsg", "*", "C", ".", "rd_kafka_message_t", ")", "{", "var", "valp", "unsafe", ".", "Pointer", "\n", "var", "keyp", "unsafe", ".", "Pointer", "\n\n", "// to circumvent Cgo constraints we need to allocate C heap memory", "// for both Value and Key (one allocation back to back)", "// and copy the bytes from Value and Key to the C memory.", "// We later tell librdkafka (in produce()) to free the", "// C memory pointer when it is done.", "var", "payload", "unsafe", ".", "Pointer", "\n\n", "valueLen", ":=", "0", "\n", "keyLen", ":=", "0", "\n", "if", "msg", ".", "Value", "!=", "nil", "{", "valueLen", "=", "len", "(", "msg", ".", "Value", ")", "\n", "}", "\n", "if", "msg", ".", "Key", "!=", "nil", "{", "keyLen", "=", "len", "(", "msg", ".", "Key", ")", "\n", "}", "\n\n", "allocLen", ":=", "valueLen", "+", "keyLen", "\n", "if", "allocLen", ">", "0", "{", "payload", "=", "C", ".", "malloc", "(", "C", ".", "size_t", "(", "allocLen", ")", ")", "\n", "if", "valueLen", ">", "0", "{", "copy", "(", "(", "*", "[", "1", "<<", "30", "]", "byte", ")", "(", "payload", ")", "[", "0", ":", "valueLen", "]", ",", "msg", ".", "Value", ")", "\n", "valp", "=", "payload", "\n", "}", "\n", "if", "keyLen", ">", "0", "{", "copy", "(", "(", "*", "[", "1", "<<", "30", "]", "byte", ")", "(", "payload", ")", "[", "valueLen", ":", "allocLen", "]", ",", "msg", ".", "Key", ")", "\n", "keyp", "=", "unsafe", ".", "Pointer", "(", "&", "(", "(", "*", "[", "1", "<<", "31", "]", "byte", ")", "(", "payload", ")", "[", "valueLen", "]", ")", ")", "\n", "}", "\n", "}", "\n\n", "cmsg", ".", "rkt", "=", "h", ".", "getRktFromMessage", "(", "msg", ")", "\n", "cmsg", ".", "partition", "=", "C", ".", "int32_t", "(", "msg", ".", "TopicPartition", ".", "Partition", ")", "\n", "cmsg", ".", "payload", "=", "valp", "\n", "cmsg", ".", "len", "=", "C", ".", "size_t", "(", "valueLen", ")", "\n", "cmsg", ".", "key", "=", "keyp", "\n", "cmsg", ".", "key_len", "=", "C", ".", "size_t", "(", "keyLen", ")", "\n", "cmsg", ".", "_private", "=", "nil", "\n", "}" ]

[ "messageToC", "sets", "up", "cmsg", "as", "a", "clone", "of", "msg" ]

[ "func", "(", "h", "*", "handle", ")", "messageToCDummy", "(", "msg", "*", "Message", ")", "{", "var", "cmsg", "C", ".", "rd_kafka_message_t", "\n", "h", ".", "messageToC", "(", "msg", ",", "&", "cmsg", ")", "\n", "}" ]

[ "used", "for", "testing", "messageToC", "performance" ]

[ "func", "(", "o", "*", "Options", ")", "Clone", "(", ")", "*", "Options", "{", "if", "o", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "clone", ":=", "&", "Options", "{", "}", "\n", "*", "clone", "=", "*", "o", "\n", "if", "o", ".", "Users", "!=", "nil", "{", "clone", ".", "Users", "=", "make", "(", "[", "]", "*", "User", ",", "len", "(", "o", ".", "Users", ")", ")", "\n", "for", "i", ",", "user", ":=", "range", "o", ".", "Users", "{", "clone", ".", "Users", "[", "i", "]", "=", "user", ".", "clone", "(", ")", "\n", "}", "\n", "}", "\n", "if", "o", ".", "Nkeys", "!=", "nil", "{", "clone", ".", "Nkeys", "=", "make", "(", "[", "]", "*", "NkeyUser", ",", "len", "(", "o", ".", "Nkeys", ")", ")", "\n", "for", "i", ",", "nkey", ":=", "range", "o", ".", "Nkeys", "{", "clone", ".", "Nkeys", "[", "i", "]", "=", "nkey", ".", "clone", "(", ")", "\n", "}", "\n", "}", "\n\n", "if", "o", ".", "Routes", "!=", "nil", "{", "clone", ".", "Routes", "=", "deepCopyURLs", "(", "o", ".", "Routes", ")", "\n", "}", "\n", "if", "o", ".", "TLSConfig", "!=", "nil", "{", "clone", ".", "TLSConfig", "=", "o", ".", "TLSConfig", ".", "Clone", "(", ")", "\n", "}", "\n", "if", "o", ".", "Cluster", ".", "TLSConfig", "!=", "nil", "{", "clone", ".", "Cluster", ".", "TLSConfig", "=", "o", ".", "Cluster", ".", "TLSConfig", ".", "Clone", "(", ")", "\n", "}", "\n", "if", "o", ".", "Gateway", ".", "TLSConfig", "!=", "nil", "{", "clone", ".", "Gateway", ".", "TLSConfig", "=", "o", ".", "Gateway", ".", "TLSConfig", ".", "Clone", "(", ")", "\n", "}", "\n", "if", "len", "(", "o", ".", "Gateway", ".", "Gateways", ")", ">", "0", "{", "clone", ".", "Gateway", ".", "Gateways", "=", "make", "(", "[", "]", "*", "RemoteGatewayOpts", ",", "len", "(", "o", ".", "Gateway", ".", "Gateways", ")", ")", "\n", "for", "i", ",", "g", ":=", "range", "o", ".", "Gateway", ".", "Gateways", "{", "clone", ".", "Gateway", ".", "Gateways", "[", "i", "]", "=", "g", ".", "clone", "(", ")", "\n", "}", "\n", "}", "\n", "// FIXME(dlc) - clone leaf node stuff.", "return", "clone", "\n", "}" ]

[ "Clone", "performs", "a", "deep", "copy", "of", "the", "Options", "struct", "returning", "a", "new", "clone", "with", "all", "values", "copied", "." ]

[ "func", "unwrapValue", "(", "v", "interface", "{", "}", ")", "(", "token", ",", "interface", "{", "}", ")", "{", "switch", "tk", ":=", "v", ".", "(", "type", ")", "{", "case", "token", ":", "return", "tk", ",", "tk", ".", "Value", "(", ")", "\n", "default", ":", "return", "nil", ",", "v", "\n", "}", "\n", "}" ]

[ "unwrapValue", "can", "be", "used", "to", "get", "the", "token", "and", "value", "from", "an", "item", "to", "be", "able", "to", "report", "the", "line", "number", "in", "case", "of", "an", "incorrect", "configuration", "." ]

[ "func", "getTLSConfig", "(", "tk", "token", ")", "(", "*", "tls", ".", "Config", ",", "*", "TLSConfigOpts", ",", "error", ")", "{", "tc", ",", "err", ":=", "parseTLS", "(", "tk", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "config", ",", "err", ":=", "GenTLSConfig", "(", "tc", ")", "\n", "if", "err", "!=", "nil", "{", "err", ":=", "&", "configErr", "{", "tk", ",", "err", ".", "Error", "(", ")", "}", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "// For clusters/gateways, we will force strict verification. We also act", "// as both client and server, so will mirror the rootCA to the", "// clientCA pool.", "config", ".", "ClientAuth", "=", "tls", ".", "RequireAndVerifyClientCert", "\n", "config", ".", "RootCAs", "=", "config", ".", "ClientCAs", "\n", "return", "config", ",", "tc", ",", "nil", "\n", "}" ]

[ "Parse", "TLS", "and", "returns", "a", "TLSConfig", "and", "TLSTimeout", ".", "Used", "by", "cluster", "and", "gateway", "parsing", "." ]

[ "func", "parseAccount", "(", "v", "map", "[", "string", "]", "interface", "{", "}", ",", "errors", ",", "warnings", "*", "[", "]", "error", ")", "(", "string", ",", "string", ",", "error", ")", "{", "var", "accountName", ",", "subject", "string", "\n", "for", "mk", ",", "mv", ":=", "range", "v", "{", "tk", ",", "mv", ":=", "unwrapValue", "(", "mv", ")", "\n", "switch", "strings", ".", "ToLower", "(", "mk", ")", "{", "case", "\"", "\"", ":", "accountName", "=", "mv", ".", "(", "string", ")", "\n", "case", "\"", "\"", ":", "subject", "=", "mv", ".", "(", "string", ")", "\n", "default", ":", "if", "!", "tk", ".", "IsUsedVariable", "(", ")", "{", "err", ":=", "&", "unknownConfigFieldErr", "{", "field", ":", "mk", ",", "configErr", ":", "configErr", "{", "token", ":", "tk", ",", "}", ",", "}", "\n", "*", "errors", "=", "append", "(", "*", "errors", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "accountName", ",", "subject", ",", "nil", "\n", "}" ]

[ "Helper", "to", "parse", "an", "embedded", "account", "description", "for", "imported", "services", "or", "streams", "." ]

[ "func", "parseAuthorization", "(", "v", "interface", "{", "}", ",", "opts", "*", "Options", ",", "errors", "*", "[", "]", "error", ",", "warnings", "*", "[", "]", "error", ")", "(", "*", "authorization", ",", "error", ")", "{", "var", "(", "am", "map", "[", "string", "]", "interface", "{", "}", "\n", "tk", "token", "\n", "auth", "=", "&", "authorization", "{", "}", "\n", ")", "\n\n", "_", ",", "v", "=", "unwrapValue", "(", "v", ")", "\n", "am", "=", "v", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "for", "mk", ",", "mv", ":=", "range", "am", "{", "tk", ",", "mv", "=", "unwrapValue", "(", "mv", ")", "\n", "switch", "strings", ".", "ToLower", "(", "mk", ")", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "auth", ".", "user", "=", "mv", ".", "(", "string", ")", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "auth", ".", "pass", "=", "mv", ".", "(", "string", ")", "\n", "case", "\"", "\"", ":", "auth", ".", "token", "=", "mv", ".", "(", "string", ")", "\n", "case", "\"", "\"", ":", "at", ":=", "float64", "(", "1", ")", "\n", "switch", "mv", ":=", "mv", ".", "(", "type", ")", "{", "case", "int64", ":", "at", "=", "float64", "(", "mv", ")", "\n", "case", "float64", ":", "at", "=", "mv", "\n", "}", "\n", "auth", ".", "timeout", "=", "at", "\n", "case", "\"", "\"", ":", "nkeys", ",", "users", ",", "err", ":=", "parseUsers", "(", "tk", ",", "opts", ",", "errors", ",", "warnings", ")", "\n", "if", "err", "!=", "nil", "{", "*", "errors", "=", "append", "(", "*", "errors", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "auth", ".", "users", "=", "users", "\n", "auth", ".", "nkeys", "=", "nkeys", "\n", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "permissions", ",", "err", ":=", "parseUserPermissions", "(", "tk", ",", "errors", ",", "warnings", ")", "\n", "if", "err", "!=", "nil", "{", "*", "errors", "=", "append", "(", "*", "errors", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "auth", ".", "defaultPermissions", "=", "permissions", "\n", "default", ":", "if", "!", "tk", ".", "IsUsedVariable", "(", ")", "{", "err", ":=", "&", "unknownConfigFieldErr", "{", "field", ":", "mk", ",", "configErr", ":", "configErr", "{", "token", ":", "tk", ",", "}", ",", "}", "\n", "*", "errors", "=", "append", "(", "*", "errors", ",", "err", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "// Now check for permission defaults with multiple users, etc.", "if", "auth", ".", "users", "!=", "nil", "&&", "auth", ".", "defaultPermissions", "!=", "nil", "{", "for", "_", ",", "user", ":=", "range", "auth", ".", "users", "{", "if", "user", ".", "Permissions", "==", "nil", "{", "user", ".", "Permissions", "=", "auth", ".", "defaultPermissions", "\n", "}", "\n", "}", "\n", "}", "\n\n", "}", "\n", "return", "auth", ",", "nil", "\n", "}" ]

[ "Helper", "function", "to", "parse", "Authorization", "configs", "." ]

[ "func", "parseVariablePermissions", "(", "v", "interface", "{", "}", ",", "errors", ",", "warnings", "*", "[", "]", "error", ")", "(", "*", "SubjectPermission", ",", "error", ")", "{", "switch", "vv", ":=", "v", ".", "(", "type", ")", "{", "case", "map", "[", "string", "]", "interface", "{", "}", ":", "// New style with allow and/or deny properties.", "return", "parseSubjectPermission", "(", "vv", ",", "errors", ",", "warnings", ")", "\n", "default", ":", "// Old style", "return", "parseOldPermissionStyle", "(", "v", ",", "errors", ",", "warnings", ")", "\n", "}", "\n", "}" ]

[ "Top", "level", "parser", "for", "authorization", "configurations", "." ]

[ "func", "parseOldPermissionStyle", "(", "v", "interface", "{", "}", ",", "errors", ",", "warnings", "*", "[", "]", "error", ")", "(", "*", "SubjectPermission", ",", "error", ")", "{", "subjects", ",", "err", ":=", "parseSubjects", "(", "v", ",", "errors", ",", "warnings", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "SubjectPermission", "{", "Allow", ":", "subjects", "}", ",", "nil", "\n", "}" ]

[ "Helper", "function", "to", "parse", "old", "style", "authorization", "configs", "." ]

[ "func", "parseSubjectPermission", "(", "v", "interface", "{", "}", ",", "errors", ",", "warnings", "*", "[", "]", "error", ")", "(", "*", "SubjectPermission", ",", "error", ")", "{", "m", ":=", "v", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "len", "(", "m", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "p", ":=", "&", "SubjectPermission", "{", "}", "\n", "for", "k", ",", "v", ":=", "range", "m", "{", "tk", ",", "_", ":=", "unwrapValue", "(", "v", ")", "\n", "switch", "strings", ".", "ToLower", "(", "k", ")", "{", "case", "\"", "\"", ":", "subjects", ",", "err", ":=", "parseSubjects", "(", "tk", ",", "errors", ",", "warnings", ")", "\n", "if", "err", "!=", "nil", "{", "*", "errors", "=", "append", "(", "*", "errors", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "p", ".", "Allow", "=", "subjects", "\n", "case", "\"", "\"", ":", "subjects", ",", "err", ":=", "parseSubjects", "(", "tk", ",", "errors", ",", "warnings", ")", "\n", "if", "err", "!=", "nil", "{", "*", "errors", "=", "append", "(", "*", "errors", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "p", ".", "Deny", "=", "subjects", "\n", "default", ":", "if", "!", "tk", ".", "IsUsedVariable", "(", ")", "{", "err", ":=", "&", "configErr", "{", "tk", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ")", "}", "\n", "*", "errors", "=", "append", "(", "*", "errors", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "p", ",", "nil", "\n", "}" ]

[ "Helper", "function", "to", "parse", "new", "style", "authorization", "into", "a", "SubjectPermission", "with", "Allow", "and", "Deny", "." ]

[ "func", "checkSubjectArray", "(", "sa", "[", "]", "string", ")", "error", "{", "for", "_", ",", "s", ":=", "range", "sa", "{", "if", "!", "IsValidSubject", "(", "s", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Helper", "function", "to", "validate", "subjects", "etc", "for", "account", "permissioning", "." ]

[ "func", "PrintTLSHelpAndDie", "(", ")", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "tlsUsage", ")", "\n", "for", "k", ":=", "range", "cipherMap", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "k", ")", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\\n", "\"", ")", "\n", "for", "k", ":=", "range", "curvePreferenceMap", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "k", ")", "\n", "}", "\n", "os", ".", "Exit", "(", "0", ")", "\n", "}" ]

[ "PrintTLSHelpAndDie", "prints", "TLS", "usage", "and", "exits", "." ]

[ "func", "GenTLSConfig", "(", "tc", "*", "TLSConfigOpts", ")", "(", "*", "tls", ".", "Config", ",", "error", ")", "{", "// Now load in cert and private key", "cert", ",", "err", ":=", "tls", ".", "LoadX509KeyPair", "(", "tc", ".", "CertFile", ",", "tc", ".", "KeyFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "cert", ".", "Leaf", ",", "err", "=", "x509", ".", "ParseCertificate", "(", "cert", ".", "Certificate", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Create the tls.Config from our options.", "// We will determine the cipher suites that we prefer.", "// FIXME(dlc) change if ARM based.", "config", ":=", "tls", ".", "Config", "{", "MinVersion", ":", "tls", ".", "VersionTLS12", ",", "CipherSuites", ":", "tc", ".", "Ciphers", ",", "PreferServerCipherSuites", ":", "true", ",", "CurvePreferences", ":", "tc", ".", "CurvePreferences", ",", "Certificates", ":", "[", "]", "tls", ".", "Certificate", "{", "cert", "}", ",", "InsecureSkipVerify", ":", "tc", ".", "Insecure", ",", "}", "\n\n", "// Require client certificates as needed", "if", "tc", ".", "Verify", "{", "config", ".", "ClientAuth", "=", "tls", ".", "RequireAndVerifyClientCert", "\n", "}", "\n", "// Add in CAs if applicable.", "if", "tc", ".", "CaFile", "!=", "\"", "\"", "{", "rootPEM", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "tc", ".", "CaFile", ")", "\n", "if", "err", "!=", "nil", "||", "rootPEM", "==", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "pool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n", "ok", ":=", "pool", ".", "AppendCertsFromPEM", "(", "rootPEM", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "config", ".", "ClientCAs", "=", "pool", "\n", "}", "\n\n", "return", "&", "config", ",", "nil", "\n", "}" ]

[ "GenTLSConfig", "loads", "TLS", "related", "configuration", "parameters", "." ]

[ "func", "MergeOptions", "(", "fileOpts", ",", "flagOpts", "*", "Options", ")", "*", "Options", "{", "if", "fileOpts", "==", "nil", "{", "return", "flagOpts", "\n", "}", "\n", "if", "flagOpts", "==", "nil", "{", "return", "fileOpts", "\n", "}", "\n", "// Merge the two, flagOpts override", "opts", ":=", "*", "fileOpts", "\n\n", "if", "flagOpts", ".", "Port", "!=", "0", "{", "opts", ".", "Port", "=", "flagOpts", ".", "Port", "\n", "}", "\n", "if", "flagOpts", ".", "Host", "!=", "\"", "\"", "{", "opts", ".", "Host", "=", "flagOpts", ".", "Host", "\n", "}", "\n", "if", "flagOpts", ".", "ClientAdvertise", "!=", "\"", "\"", "{", "opts", ".", "ClientAdvertise", "=", "flagOpts", ".", "ClientAdvertise", "\n", "}", "\n", "if", "flagOpts", ".", "Username", "!=", "\"", "\"", "{", "opts", ".", "Username", "=", "flagOpts", ".", "Username", "\n", "}", "\n", "if", "flagOpts", ".", "Password", "!=", "\"", "\"", "{", "opts", ".", "Password", "=", "flagOpts", ".", "Password", "\n", "}", "\n", "if", "flagOpts", ".", "Authorization", "!=", "\"", "\"", "{", "opts", ".", "Authorization", "=", "flagOpts", ".", "Authorization", "\n", "}", "\n", "if", "flagOpts", ".", "HTTPPort", "!=", "0", "{", "opts", ".", "HTTPPort", "=", "flagOpts", ".", "HTTPPort", "\n", "}", "\n", "if", "flagOpts", ".", "Debug", "{", "opts", ".", "Debug", "=", "true", "\n", "}", "\n", "if", "flagOpts", ".", "Trace", "{", "opts", ".", "Trace", "=", "true", "\n", "}", "\n", "if", "flagOpts", ".", "Logtime", "{", "opts", ".", "Logtime", "=", "true", "\n", "}", "\n", "if", "flagOpts", ".", "LogFile", "!=", "\"", "\"", "{", "opts", ".", "LogFile", "=", "flagOpts", ".", "LogFile", "\n", "}", "\n", "if", "flagOpts", ".", "PidFile", "!=", "\"", "\"", "{", "opts", ".", "PidFile", "=", "flagOpts", ".", "PidFile", "\n", "}", "\n", "if", "flagOpts", ".", "PortsFileDir", "!=", "\"", "\"", "{", "opts", ".", "PortsFileDir", "=", "flagOpts", ".", "PortsFileDir", "\n", "}", "\n", "if", "flagOpts", ".", "ProfPort", "!=", "0", "{", "opts", ".", "ProfPort", "=", "flagOpts", ".", "ProfPort", "\n", "}", "\n", "if", "flagOpts", ".", "Cluster", ".", "ListenStr", "!=", "\"", "\"", "{", "opts", ".", "Cluster", ".", "ListenStr", "=", "flagOpts", ".", "Cluster", ".", "ListenStr", "\n", "}", "\n", "if", "flagOpts", ".", "Cluster", ".", "NoAdvertise", "{", "opts", ".", "Cluster", ".", "NoAdvertise", "=", "true", "\n", "}", "\n", "if", "flagOpts", ".", "Cluster", ".", "ConnectRetries", "!=", "0", "{", "opts", ".", "Cluster", ".", "ConnectRetries", "=", "flagOpts", ".", "Cluster", ".", "ConnectRetries", "\n", "}", "\n", "if", "flagOpts", ".", "Cluster", ".", "Advertise", "!=", "\"", "\"", "{", "opts", ".", "Cluster", ".", "Advertise", "=", "flagOpts", ".", "Cluster", ".", "Advertise", "\n", "}", "\n", "if", "flagOpts", ".", "RoutesStr", "!=", "\"", "\"", "{", "mergeRoutes", "(", "&", "opts", ",", "flagOpts", ")", "\n", "}", "\n", "return", "&", "opts", "\n", "}" ]

[ "MergeOptions", "will", "merge", "two", "options", "giving", "preference", "to", "the", "flagOpts", "if", "the", "item", "is", "present", "." ]

[ "func", "RoutesFromStr", "(", "routesStr", "string", ")", "[", "]", "*", "url", ".", "URL", "{", "routes", ":=", "strings", ".", "Split", "(", "routesStr", ",", "\"", "\"", ")", "\n", "if", "len", "(", "routes", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "routeUrls", ":=", "[", "]", "*", "url", ".", "URL", "{", "}", "\n", "for", "_", ",", "r", ":=", "range", "routes", "{", "r", "=", "strings", ".", "TrimSpace", "(", "r", ")", "\n", "u", ",", "_", ":=", "url", ".", "Parse", "(", "r", ")", "\n", "routeUrls", "=", "append", "(", "routeUrls", ",", "u", ")", "\n", "}", "\n", "return", "routeUrls", "\n", "}" ]

[ "RoutesFromStr", "parses", "route", "URLs", "from", "a", "string" ]

[ "func", "mergeRoutes", "(", "opts", ",", "flagOpts", "*", "Options", ")", "{", "routeUrls", ":=", "RoutesFromStr", "(", "flagOpts", ".", "RoutesStr", ")", "\n", "if", "routeUrls", "==", "nil", "{", "return", "\n", "}", "\n", "opts", ".", "Routes", "=", "routeUrls", "\n", "opts", ".", "RoutesStr", "=", "flagOpts", ".", "RoutesStr", "\n", "}" ]

[ "This", "will", "merge", "the", "flag", "routes", "and", "override", "anything", "that", "was", "present", "." ]

[ "func", "RemoveSelfReference", "(", "clusterPort", "int", ",", "routes", "[", "]", "*", "url", ".", "URL", ")", "(", "[", "]", "*", "url", ".", "URL", ",", "error", ")", "{", "var", "cleanRoutes", "[", "]", "*", "url", ".", "URL", "\n", "cport", ":=", "strconv", ".", "Itoa", "(", "clusterPort", ")", "\n\n", "selfIPs", ",", "err", ":=", "getInterfaceIPs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "r", ":=", "range", "routes", "{", "host", ",", "port", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "r", ".", "Host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ipList", ",", "err", ":=", "getURLIP", "(", "host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "cport", "==", "port", "&&", "isIPInList", "(", "selfIPs", ",", "ipList", ")", "{", "continue", "\n", "}", "\n", "cleanRoutes", "=", "append", "(", "cleanRoutes", ",", "r", ")", "\n", "}", "\n\n", "return", "cleanRoutes", ",", "nil", "\n", "}" ]

[ "RemoveSelfReference", "removes", "this", "server", "from", "an", "array", "of", "routes" ]

[ "func", "overrideTLS", "(", "opts", "*", "Options", ")", "error", "{", "if", "opts", ".", "TLSCert", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "opts", ".", "TLSKey", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "tc", ":=", "TLSConfigOpts", "{", "}", "\n", "tc", ".", "CertFile", "=", "opts", ".", "TLSCert", "\n", "tc", ".", "KeyFile", "=", "opts", ".", "TLSKey", "\n", "tc", ".", "CaFile", "=", "opts", ".", "TLSCaCert", "\n", "tc", ".", "Verify", "=", "opts", ".", "TLSVerify", "\n\n", "var", "err", "error", "\n", "opts", ".", "TLSConfig", ",", "err", "=", "GenTLSConfig", "(", "&", "tc", ")", "\n", "return", "err", "\n", "}" ]

[ "overrideTLS", "is", "called", "when", "at", "least", "-", "tls", "=", "true", "has", "been", "set", "." ]

[ "func", "(", "s", "SortOpt", ")", "IsValid", "(", ")", "bool", "{", "switch", "s", "{", "case", "\"", "\"", ",", "ByCid", ",", "ByStart", ",", "BySubs", ",", "ByPending", ",", "ByOutMsgs", ",", "ByInMsgs", ",", "ByOutBytes", ",", "ByInBytes", ",", "ByLast", ",", "ByIdle", ",", "ByUptime", ",", "ByStop", ",", "ByReason", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsValid", "determines", "if", "a", "sort", "option", "is", "valid" ]

[ "func", "(", "c", "*", "client", ")", "clonePubArg", "(", ")", "{", "// Just copy and re-process original arg buffer.", "c", ".", "argBuf", "=", "c", ".", "scratch", "[", ":", "0", "]", "\n", "c", ".", "argBuf", "=", "append", "(", "c", ".", "argBuf", ",", "c", ".", "pa", ".", "arg", "...", ")", "\n\n", "// This is a routed msg", "if", "c", ".", "pa", ".", "account", "!=", "nil", "{", "c", ".", "processRoutedMsgArgs", "(", "false", ",", "c", ".", "argBuf", ")", "\n", "}", "else", "{", "c", ".", "processPub", "(", "false", ",", "c", ".", "argBuf", ")", "\n", "}", "\n", "}" ]

[ "clonePubArg", "is", "used", "when", "the", "split", "buffer", "scenario", "has", "the", "pubArg", "in", "the", "existing", "read", "buffer", "but", "we", "need", "to", "hold", "onto", "it", "into", "the", "next", "read", "." ]

[ "func", "NewServer", "(", "opts", "*", "Options", ")", "(", "*", "Server", ",", "error", ")", "{", "setBaselineOptions", "(", "opts", ")", "\n\n", "// Process TLS options, including whether we require client certificates.", "tlsReq", ":=", "opts", ".", "TLSConfig", "!=", "nil", "\n", "verify", ":=", "(", "tlsReq", "&&", "opts", ".", "TLSConfig", ".", "ClientAuth", "==", "tls", ".", "RequireAndVerifyClientCert", ")", "\n\n", "// Created server's nkey identity.", "kp", ",", "_", ":=", "nkeys", ".", "CreateServer", "(", ")", "\n", "pub", ",", "_", ":=", "kp", ".", "PublicKey", "(", ")", "\n\n", "// Validate some options. This is here because we cannot assume that", "// server will always be started with configuration parsing (that could", "// report issues). Its options can be (incorrectly) set by hand when", "// server is embedded. If there is an error, return nil.", "if", "err", ":=", "validateOptions", "(", "opts", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "info", ":=", "Info", "{", "ID", ":", "pub", ",", "Version", ":", "VERSION", ",", "Proto", ":", "PROTO", ",", "GitCommit", ":", "gitCommit", ",", "GoVersion", ":", "runtime", ".", "Version", "(", ")", ",", "Host", ":", "opts", ".", "Host", ",", "Port", ":", "opts", ".", "Port", ",", "AuthRequired", ":", "false", ",", "TLSRequired", ":", "tlsReq", ",", "TLSVerify", ":", "verify", ",", "MaxPayload", ":", "opts", ".", "MaxPayload", ",", "}", "\n\n", "now", ":=", "time", ".", "Now", "(", ")", "\n", "s", ":=", "&", "Server", "{", "kp", ":", "kp", ",", "configFile", ":", "opts", ".", "ConfigFile", ",", "info", ":", "info", ",", "prand", ":", "rand", ".", "New", "(", "rand", ".", "NewSource", "(", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", ")", ",", "opts", ":", "opts", ",", "done", ":", "make", "(", "chan", "bool", ",", "1", ")", ",", "start", ":", "now", ",", "configTime", ":", "now", ",", "}", "\n\n", "// Trusted root operator keys.", "if", "!", "s", ".", "processTrustedKeys", "(", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Ensure that non-exported options (used in tests) are properly set.", "s", ".", "setLeafNodeNonExportedOptions", "(", ")", "\n\n", "// Used internally for quick look-ups.", "s", ".", "clientConnectURLsMap", "=", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", "\n\n", "// Call this even if there is no gateway defined. It will", "// initialize the structure so we don't have to check for", "// it to be nil or not in various places in the code.", "gws", ",", "err", ":=", "newGateway", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "s", ".", "gateway", "=", "gws", "\n\n", "if", "s", ".", "gateway", ".", "enabled", "{", "s", ".", "info", ".", "Cluster", "=", "s", ".", "getGatewayName", "(", ")", "\n", "}", "\n\n", "// This is normally done in the AcceptLoop, once the", "// listener has been created (possibly with random port),", "// but since some tests may expect the INFO to be properly", "// set after New(), let's do it now.", "s", ".", "setInfoHostPortAndGenerateJSON", "(", ")", "\n\n", "// For tracking clients", "s", ".", "clients", "=", "make", "(", "map", "[", "uint64", "]", "*", "client", ")", "\n\n", "// For tracking closed clients.", "s", ".", "closed", "=", "newClosedRingBuffer", "(", "opts", ".", "MaxClosedClients", ")", "\n\n", "// For tracking connections that are not yet registered", "// in s.routes, but for which readLoop has started.", "s", ".", "grTmpClients", "=", "make", "(", "map", "[", "uint64", "]", "*", "client", ")", "\n\n", "// For tracking routes and their remote ids", "s", ".", "routes", "=", "make", "(", "map", "[", "uint64", "]", "*", "client", ")", "\n", "s", ".", "remotes", "=", "make", "(", "map", "[", "string", "]", "*", "client", ")", "\n\n", "// For tracking leaf nodes.", "s", ".", "leafs", "=", "make", "(", "map", "[", "uint64", "]", "*", "client", ")", "\n\n", "// Used to kick out all go routines possibly waiting on server", "// to shutdown.", "s", ".", "quitCh", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n\n", "// For tracking accounts", "if", "err", ":=", "s", ".", "configureAccounts", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Used to setup Authorization.", "s", ".", "configureAuthorization", "(", ")", "\n\n", "// Start signal handler", "s", ".", "handleSignals", "(", ")", "\n\n", "return", "s", ",", "nil", "\n", "}" ]

[ "NewServer", "will", "setup", "a", "new", "server", "struct", "after", "parsing", "the", "options", ".", "Could", "return", "an", "error", "if", "options", "can", "not", "be", "validated", "." ]

[ "func", "(", "s", "*", "Server", ")", "configureAccounts", "(", ")", "error", "{", "// Create global account.", "if", "s", ".", "gacc", "==", "nil", "{", "s", ".", "gacc", "=", "NewAccount", "(", "globalAccountName", ")", "\n", "s", ".", "registerAccount", "(", "s", ".", "gacc", ")", "\n", "}", "\n\n", "opts", ":=", "s", ".", "opts", "\n\n", "// Check opts and walk through them. We need to copy them here", "// so that we do not keep a real one sitting in the options.", "for", "_", ",", "acc", ":=", "range", "s", ".", "opts", ".", "Accounts", "{", "a", ":=", "acc", ".", "shallowCopy", "(", ")", "\n", "acc", ".", "sl", "=", "nil", "\n", "acc", ".", "clients", "=", "nil", "\n", "s", ".", "registerAccount", "(", "a", ")", "\n", "}", "\n\n", "// Now that we have this we need to remap any referenced accounts in", "// import or export maps to the new ones.", "swapApproved", ":=", "func", "(", "ea", "*", "exportAuth", ")", "{", "if", "ea", "==", "nil", "{", "return", "\n", "}", "\n", "for", "sub", ",", "a", ":=", "range", "ea", ".", "approved", "{", "var", "acc", "*", "Account", "\n", "if", "v", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "a", ".", "Name", ")", ";", "ok", "{", "acc", "=", "v", ".", "(", "*", "Account", ")", "\n", "}", "\n", "ea", ".", "approved", "[", "sub", "]", "=", "acc", "\n", "}", "\n", "}", "\n", "s", ".", "accounts", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "acc", ":=", "v", ".", "(", "*", "Account", ")", "\n", "// Exports", "for", "_", ",", "ea", ":=", "range", "acc", ".", "exports", ".", "streams", "{", "swapApproved", "(", "ea", ")", "\n", "}", "\n", "for", "_", ",", "ea", ":=", "range", "acc", ".", "exports", ".", "services", "{", "swapApproved", "(", "ea", ")", "\n", "}", "\n", "// Imports", "for", "_", ",", "si", ":=", "range", "acc", ".", "imports", ".", "streams", "{", "if", "v", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "si", ".", "acc", ".", "Name", ")", ";", "ok", "{", "si", ".", "acc", "=", "v", ".", "(", "*", "Account", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "si", ":=", "range", "acc", ".", "imports", ".", "services", "{", "if", "v", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "si", ".", "acc", ".", "Name", ")", ";", "ok", "{", "si", ".", "acc", "=", "v", ".", "(", "*", "Account", ")", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "// Check for configured account resolvers.", "if", "opts", ".", "AccountResolver", "!=", "nil", "{", "s", ".", "accResolver", "=", "opts", ".", "AccountResolver", "\n", "if", "len", "(", "opts", ".", "resolverPreloads", ")", ">", "0", "{", "if", "_", ",", "ok", ":=", "s", ".", "accResolver", ".", "(", "*", "MemAccResolver", ")", ";", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "opts", ".", "resolverPreloads", "{", "if", "_", ",", "_", ",", "err", ":=", "s", ".", "verifyAccountClaims", "(", "v", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "s", ".", "accResolver", ".", "Store", "(", "k", ",", "v", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "// Set the system account if it was configured.", "if", "opts", ".", "SystemAccount", "!=", "_EMPTY_", "{", "// Lock is held entering this function, so release to call lookupAccount.", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "_", ",", "err", ":=", "s", ".", "lookupAccount", "(", "opts", ".", "SystemAccount", ")", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Used", "to", "setup", "Accounts", "." ]

[ "func", "(", "s", "*", "Server", ")", "isTrustedIssuer", "(", "issuer", "string", ")", "bool", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "// If we are not running in trusted mode and there is no issuer, that is ok.", "if", "len", "(", "s", ".", "trustedKeys", ")", "==", "0", "&&", "issuer", "==", "\"", "\"", "{", "return", "true", "\n", "}", "\n", "for", "_", ",", "tk", ":=", "range", "s", ".", "trustedKeys", "{", "if", "tk", "==", "issuer", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isTrustedIssuer", "will", "check", "that", "the", "issuer", "is", "a", "trusted", "public", "key", ".", "This", "is", "used", "to", "make", "sure", "an", "account", "was", "signed", "by", "a", "trusted", "operator", "." ]

[ "func", "(", "s", "*", "Server", ")", "processTrustedKeys", "(", ")", "bool", "{", "if", "trustedKeys", "!=", "\"", "\"", "&&", "!", "s", ".", "initStampedTrustedKeys", "(", ")", "{", "return", "false", "\n", "}", "else", "if", "s", ".", "opts", ".", "TrustedKeys", "!=", "nil", "{", "for", "_", ",", "key", ":=", "range", "s", ".", "opts", ".", "TrustedKeys", "{", "if", "!", "nkeys", ".", "IsValidPublicOperatorKey", "(", "key", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "s", ".", "trustedKeys", "=", "s", ".", "opts", ".", "TrustedKeys", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "processTrustedKeys", "will", "process", "binary", "stamped", "and", "options", "-", "based", "trusted", "nkeys", ".", "Returns", "success", "." ]

[ "func", "checkTrustedKeyString", "(", "keys", "string", ")", "[", "]", "string", "{", "tks", ":=", "strings", ".", "Fields", "(", "keys", ")", "\n", "if", "len", "(", "tks", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "// Walk all the keys and make sure they are valid.", "for", "_", ",", "key", ":=", "range", "tks", "{", "if", "!", "nkeys", ".", "IsValidPublicOperatorKey", "(", "key", ")", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "tks", "\n", "}" ]

[ "checkTrustedKeyString", "will", "check", "that", "the", "string", "is", "a", "valid", "array", "of", "public", "operator", "nkeys", "." ]

[ "func", "(", "s", "*", "Server", ")", "initStampedTrustedKeys", "(", ")", "bool", "{", "// Check to see if we have an override in options, which will cause us to fail.", "if", "len", "(", "s", ".", "opts", ".", "TrustedKeys", ")", ">", "0", "{", "return", "false", "\n", "}", "\n", "tks", ":=", "checkTrustedKeyString", "(", "trustedKeys", ")", "\n", "if", "len", "(", "tks", ")", "==", "0", "{", "return", "false", "\n", "}", "\n", "s", ".", "trustedKeys", "=", "tks", "\n", "return", "true", "\n", "}" ]

[ "initStampedTrustedKeys", "will", "check", "the", "stamped", "trusted", "keys", "and", "will", "set", "the", "server", "field", "trustedKeys", ".", "Returns", "whether", "it", "succeeded", "or", "not", "." ]

[ "func", "PrintAndDie", "(", "msg", "string", ")", "{", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "msg", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}" ]

[ "PrintAndDie", "is", "exported", "for", "access", "in", "other", "packages", "." ]

[ "func", "ProcessCommandLineArgs", "(", "cmd", "*", "flag", ".", "FlagSet", ")", "(", "showVersion", "bool", ",", "showHelp", "bool", ",", "err", "error", ")", "{", "if", "len", "(", "cmd", ".", "Args", "(", ")", ")", ">", "0", "{", "arg", ":=", "cmd", ".", "Args", "(", ")", "[", "0", "]", "\n", "switch", "strings", ".", "ToLower", "(", "arg", ")", "{", "case", "\"", "\"", ":", "return", "true", ",", "false", ",", "nil", "\n", "case", "\"", "\"", ":", "return", "false", ",", "true", ",", "nil", "\n", "default", ":", "return", "false", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "arg", ")", "\n", "}", "\n", "}", "\n\n", "return", "false", ",", "false", ",", "nil", "\n", "}" ]

[ "ProcessCommandLineArgs", "takes", "the", "command", "line", "arguments", "validating", "and", "setting", "flags", "for", "handling", "in", "case", "any", "sub", "command", "was", "present", "." ]

[ "func", "(", "s", "*", "Server", ")", "isRunning", "(", ")", "bool", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "running", ":=", "s", ".", "running", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "running", "\n", "}" ]

[ "Protected", "check", "on", "running", "state" ]

[ "func", "(", "s", "*", "Server", ")", "NewAccountsAllowed", "(", ")", "bool", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "s", ".", "opts", ".", "AllowNewAccounts", "\n", "}" ]

[ "NewAccountsAllowed", "returns", "whether", "or", "not", "new", "accounts", "can", "be", "created", "on", "the", "fly", "." ]

[ "func", "(", "s", "*", "Server", ")", "numAccounts", "(", ")", "int", "{", "count", ":=", "0", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "accounts", ".", "Range", "(", "func", "(", "k", ",", "v", "interface", "{", "}", ")", "bool", "{", "count", "++", "\n", "return", "true", "\n", "}", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "count", "\n", "}" ]

[ "This", "should", "be", "used", "for", "testing", "only", ".", "Will", "be", "slow", "since", "we", "have", "to", "range", "over", "all", "accounts", "in", "the", "sync", ".", "Map", "to", "count", "." ]

[ "func", "(", "s", "*", "Server", ")", "LookupOrRegisterAccount", "(", "name", "string", ")", "(", "account", "*", "Account", ",", "isNew", "bool", ")", "{", "if", "v", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "name", ")", ";", "ok", "{", "return", "v", ".", "(", "*", "Account", ")", ",", "false", "\n", "}", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "acc", ":=", "NewAccount", "(", "name", ")", "\n", "s", ".", "registerAccount", "(", "acc", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "acc", ",", "true", "\n", "}" ]

[ "LookupOrRegisterAccount", "will", "return", "the", "given", "account", "if", "known", "or", "create", "a", "new", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "RegisterAccount", "(", "name", "string", ")", "(", "*", "Account", ",", "error", ")", "{", "if", "_", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "name", ")", ";", "ok", "{", "return", "nil", ",", "ErrAccountExists", "\n", "}", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "acc", ":=", "NewAccount", "(", "name", ")", "\n", "s", ".", "registerAccount", "(", "acc", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "acc", ",", "nil", "\n", "}" ]

[ "RegisterAccount", "will", "register", "an", "account", ".", "The", "account", "must", "be", "new", "or", "this", "call", "will", "fail", "." ]

[ "func", "(", "s", "*", "Server", ")", "SetSystemAccount", "(", "accName", "string", ")", "error", "{", "if", "v", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "accName", ")", ";", "ok", "{", "return", "s", ".", "setSystemAccount", "(", "v", ".", "(", "*", "Account", ")", ")", "\n", "}", "\n\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "// If we are here we do not have local knowledge of this account.", "// Do this one by hand to return more useful error.", "ac", ",", "jwt", ",", "err", ":=", "s", ".", "fetchAccountClaims", "(", "accName", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "err", "\n", "}", "\n", "acc", ":=", "s", ".", "buildInternalAccount", "(", "ac", ")", "\n", "acc", ".", "claimJWT", "=", "jwt", "\n", "s", ".", "registerAccount", "(", "acc", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "return", "s", ".", "setSystemAccount", "(", "acc", ")", "\n", "}" ]

[ "SetSystemAccount", "will", "set", "the", "internal", "system", "account", ".", "If", "root", "operators", "are", "present", "it", "will", "also", "check", "validity", "." ]

[ "func", "(", "s", "*", "Server", ")", "SystemAccount", "(", ")", "*", "Account", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "s", ".", "sys", "!=", "nil", "{", "return", "s", ".", "sys", ".", "account", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SystemAccount", "returns", "the", "system", "account", "if", "set", "." ]

[ "func", "(", "s", "*", "Server", ")", "setSystemAccount", "(", "acc", "*", "Account", ")", "error", "{", "if", "acc", "==", "nil", "{", "return", "ErrMissingAccount", "\n", "}", "\n", "// Don't try to fix this here.", "if", "acc", ".", "IsExpired", "(", ")", "{", "return", "ErrAccountExpired", "\n", "}", "\n", "// If we are running with trusted keys for an operator", "// make sure we check the account is legit.", "if", "!", "s", ".", "isTrustedIssuer", "(", "acc", ".", "Issuer", ")", "{", "return", "ErrAccountValidation", "\n", "}", "\n\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n\n", "if", "s", ".", "sys", "!=", "nil", "{", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "ErrAccountExists", "\n", "}", "\n\n", "s", ".", "sys", "=", "&", "internal", "{", "account", ":", "acc", ",", "client", ":", "&", "client", "{", "srv", ":", "s", ",", "kind", ":", "SYSTEM", ",", "opts", ":", "internalOpts", ",", "msubs", ":", "-", "1", ",", "mpay", ":", "-", "1", ",", "start", ":", "time", ".", "Now", "(", ")", ",", "last", ":", "time", ".", "Now", "(", ")", "}", ",", "seq", ":", "1", ",", "sid", ":", "1", ",", "servers", ":", "make", "(", "map", "[", "string", "]", "*", "serverUpdate", ")", ",", "subs", ":", "make", "(", "map", "[", "string", "]", "msgHandler", ")", ",", "sendq", ":", "make", "(", "chan", "*", "pubMsg", ",", "128", ")", ",", "statsz", ":", "eventsHBInterval", ",", "orphMax", ":", "5", "*", "eventsHBInterval", ",", "chkOrph", ":", "3", "*", "eventsHBInterval", ",", "}", "\n", "s", ".", "sys", ".", "client", ".", "initClient", "(", ")", "\n", "s", ".", "sys", ".", "client", ".", "echo", "=", "false", "\n", "s", ".", "sys", ".", "wg", ".", "Add", "(", "1", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Register with the account.", "s", ".", "sys", ".", "client", ".", "registerWithAccount", "(", "acc", ")", "\n\n", "// Start our internal loop to serialize outbound messages.", "// We do our own wg here since we will stop first during shutdown.", "go", "s", ".", "internalSendLoop", "(", "&", "s", ".", "sys", ".", "wg", ")", "\n\n", "// Start up our general subscriptions", "s", ".", "initEventTracking", "(", ")", "\n\n", "// Track for dead remote servers.", "s", ".", "wrapChk", "(", "s", ".", "startRemoteServerSweepTimer", ")", "(", ")", "\n\n", "// Send out statsz updates periodically.", "s", ".", "wrapChk", "(", "s", ".", "startStatszTimer", ")", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Assign", "a", "system", "account", ".", "Should", "only", "be", "called", "once", ".", "This", "sets", "up", "a", "server", "to", "send", "and", "receive", "messages", "from", "inside", "the", "server", "itself", "." ]

[ "func", "(", "s", "*", "Server", ")", "shouldTrackSubscriptions", "(", ")", "bool", "{", "return", "(", "s", ".", "opts", ".", "Cluster", ".", "Port", "!=", "0", "||", "s", ".", "opts", ".", "Gateway", ".", "Port", "!=", "0", ")", "\n", "}" ]

[ "Determine", "if", "accounts", "should", "track", "subscriptions", "for", "efficient", "propagation", ".", "Lock", "should", "be", "held", "on", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "registerAccount", "(", "acc", "*", "Account", ")", "{", "if", "acc", ".", "sl", "==", "nil", "{", "acc", ".", "sl", "=", "NewSublist", "(", ")", "\n", "}", "\n", "if", "acc", ".", "maxnae", "==", "0", "{", "acc", ".", "maxnae", "=", "DEFAULT_MAX_ACCOUNT_AE_RESPONSE_MAPS", "\n", "}", "\n", "if", "acc", ".", "maxaettl", "==", "0", "{", "acc", ".", "maxaettl", "=", "DEFAULT_TTL_AE_RESPONSE_MAP", "\n", "}", "\n", "if", "acc", ".", "clients", "==", "nil", "{", "acc", ".", "clients", "=", "make", "(", "map", "[", "*", "client", "]", "*", "client", ")", "\n", "}", "\n", "// If we are capable of routing we will track subscription", "// information for efficient interest propagation.", "// During config reload, it is possible that account was", "// already created (global account), so use locking and", "// make sure we create only if needed.", "acc", ".", "mu", ".", "Lock", "(", ")", "\n", "// TODO(dlc)- Double check that we need this for GWs.", "if", "acc", ".", "rm", "==", "nil", "&&", "s", ".", "opts", "!=", "nil", "&&", "s", ".", "shouldTrackSubscriptions", "(", ")", "{", "acc", ".", "rm", "=", "make", "(", "map", "[", "string", "]", "int32", ")", "\n", "}", "\n", "acc", ".", "srv", "=", "s", "\n", "acc", ".", "mu", ".", "Unlock", "(", ")", "\n", "s", ".", "accounts", ".", "Store", "(", "acc", ".", "Name", ",", "acc", ")", "\n", "s", ".", "enableAccountTracking", "(", "acc", ")", "\n", "}" ]

[ "Place", "common", "account", "setup", "here", ".", "Lock", "should", "be", "held", "on", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "lookupAccount", "(", "name", "string", ")", "(", "*", "Account", ",", "error", ")", "{", "if", "v", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "name", ")", ";", "ok", "{", "acc", ":=", "v", ".", "(", "*", "Account", ")", "\n", "// If we are expired and we have a resolver, then", "// return the latest information from the resolver.", "if", "acc", ".", "IsExpired", "(", ")", "{", "var", "err", "error", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "s", ".", "accResolver", "!=", "nil", "{", "err", "=", "s", ".", "updateAccount", "(", "acc", ")", "\n", "}", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "acc", ",", "nil", "\n", "}", "\n", "// If we have a resolver see if it can fetch the account.", "if", "s", ".", "accResolver", "==", "nil", "{", "return", "nil", ",", "ErrMissingAccount", "\n", "}", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "acc", ",", "err", ":=", "s", ".", "fetchAccount", "(", "name", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "acc", ",", "err", "\n", "}" ]

[ "lookupAccount", "is", "a", "function", "to", "return", "the", "account", "structure", "associated", "with", "an", "account", "name", "." ]

[ "func", "(", "s", "*", "Server", ")", "LookupAccount", "(", "name", "string", ")", "(", "*", "Account", ",", "error", ")", "{", "return", "s", ".", "lookupAccount", "(", "name", ")", "\n", "}" ]

[ "LookupAccount", "is", "a", "public", "function", "to", "return", "the", "account", "structure", "associated", "with", "name", "." ]

[ "func", "(", "s", "*", "Server", ")", "updateAccount", "(", "acc", "*", "Account", ")", "error", "{", "// TODO(dlc) - Make configurable", "if", "time", ".", "Since", "(", "acc", ".", "updated", ")", "<", "time", ".", "Second", "{", "s", ".", "Debugf", "(", "\"", "\"", ",", "acc", ".", "Name", ")", "\n", "return", "ErrAccountResolverUpdateTooSoon", "\n", "}", "\n", "claimJWT", ",", "err", ":=", "s", ".", "fetchRawAccountClaims", "(", "acc", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "s", ".", "updateAccountWithClaimJWT", "(", "acc", ",", "claimJWT", ")", "\n", "}" ]

[ "This", "will", "fetch", "new", "claims", "and", "if", "found", "update", "the", "account", "with", "new", "claims", ".", "Lock", "should", "be", "held", "upon", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "updateAccountWithClaimJWT", "(", "acc", "*", "Account", ",", "claimJWT", "string", ")", "error", "{", "if", "acc", "==", "nil", "{", "return", "ErrMissingAccount", "\n", "}", "\n", "acc", ".", "updated", "=", "time", ".", "Now", "(", ")", "\n", "if", "acc", ".", "claimJWT", "!=", "\"", "\"", "&&", "acc", ".", "claimJWT", "==", "claimJWT", "{", "s", ".", "Debugf", "(", "\"", "\"", ",", "acc", ".", "Name", ")", "\n", "return", "ErrAccountResolverSameClaims", "\n", "}", "\n", "accClaims", ",", "_", ",", "err", ":=", "s", ".", "verifyAccountClaims", "(", "claimJWT", ")", "\n", "if", "err", "==", "nil", "&&", "accClaims", "!=", "nil", "{", "acc", ".", "claimJWT", "=", "claimJWT", "\n", "s", ".", "updateAccountClaims", "(", "acc", ",", "accClaims", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "updateAccountWithClaimJWT", "will", "check", "and", "apply", "the", "claim", "update", "." ]

[ "func", "(", "s", "*", "Server", ")", "fetchRawAccountClaims", "(", "name", "string", ")", "(", "string", ",", "error", ")", "{", "accResolver", ":=", "s", ".", "accResolver", "\n", "if", "accResolver", "==", "nil", "{", "return", "\"", "\"", ",", "ErrNoAccountResolver", "\n", "}", "\n", "// Need to do actual Fetch without the lock.", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "claimJWT", ",", "err", ":=", "accResolver", ".", "Fetch", "(", "name", ")", "\n", "fetchTime", ":=", "time", ".", "Since", "(", "start", ")", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "fetchTime", ">", "time", ".", "Second", "{", "s", ".", "Warnf", "(", "\"", "\\n", "\"", ",", "name", ",", "fetchTime", ")", "\n", "}", "else", "{", "s", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "name", ",", "fetchTime", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "s", ".", "Warnf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "claimJWT", ",", "nil", "\n", "}" ]

[ "fetchRawAccountClaims", "will", "grab", "raw", "account", "claims", "iff", "we", "have", "a", "resolver", ".", "Lock", "is", "held", "upon", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "fetchAccountClaims", "(", "name", "string", ")", "(", "*", "jwt", ".", "AccountClaims", ",", "string", ",", "error", ")", "{", "claimJWT", ",", "err", ":=", "s", ".", "fetchRawAccountClaims", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "_EMPTY_", ",", "err", "\n", "}", "\n", "return", "s", ".", "verifyAccountClaims", "(", "claimJWT", ")", "\n", "}" ]

[ "fetchAccountClaims", "will", "attempt", "to", "fetch", "new", "claims", "if", "a", "resolver", "is", "present", ".", "Lock", "is", "held", "upon", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "verifyAccountClaims", "(", "claimJWT", "string", ")", "(", "*", "jwt", ".", "AccountClaims", ",", "string", ",", "error", ")", "{", "if", "accClaims", ",", "err", ":=", "jwt", ".", "DecodeAccountClaims", "(", "claimJWT", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "_EMPTY_", ",", "err", "\n", "}", "else", "{", "vr", ":=", "jwt", ".", "CreateValidationResults", "(", ")", "\n", "accClaims", ".", "Validate", "(", "vr", ")", "\n", "if", "vr", ".", "IsBlocking", "(", "true", ")", "{", "return", "nil", ",", "_EMPTY_", ",", "ErrAccountValidation", "\n", "}", "\n", "return", "accClaims", ",", "claimJWT", ",", "nil", "\n", "}", "\n", "}" ]

[ "verifyAccountClaims", "will", "decode", "and", "validate", "any", "account", "claims", "." ]

[ "func", "(", "s", "*", "Server", ")", "fetchAccount", "(", "name", "string", ")", "(", "*", "Account", ",", "error", ")", "{", "if", "accClaims", ",", "claimJWT", ",", "err", ":=", "s", ".", "fetchAccountClaims", "(", "name", ")", ";", "accClaims", "!=", "nil", "{", "// We have released the lock during the low level fetch.", "// Now that we are back under lock, check again if account", "// is in the map or not. If it is, simply return it.", "if", "v", ",", "ok", ":=", "s", ".", "accounts", ".", "Load", "(", "name", ")", ";", "ok", "{", "acc", ":=", "v", ".", "(", "*", "Account", ")", "\n", "// Update with the new claims in case they are new.", "// Following call will return ErrAccountResolverSameClaims", "// if claims are the same.", "err", "=", "s", ".", "updateAccountWithClaimJWT", "(", "acc", ",", "claimJWT", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "ErrAccountResolverSameClaims", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "acc", ",", "nil", "\n", "}", "\n", "acc", ":=", "s", ".", "buildInternalAccount", "(", "accClaims", ")", "\n", "acc", ".", "claimJWT", "=", "claimJWT", "\n", "s", ".", "registerAccount", "(", "acc", ")", "\n", "return", "acc", ",", "nil", "\n", "}", "else", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}" ]

[ "This", "will", "fetch", "an", "account", "from", "a", "resolver", "if", "defined", ".", "Lock", "should", "be", "held", "upon", "entry", "." ]

[ "func", "(", "s", "*", "Server", ")", "Start", "(", ")", "{", "s", ".", "Noticef", "(", "\"", "\"", ",", "VERSION", ")", "\n", "s", ".", "Debugf", "(", "\"", "\"", ",", "s", ".", "info", ".", "GoVersion", ")", "\n", "gc", ":=", "gitCommit", "\n", "if", "gc", "==", "\"", "\"", "{", "gc", "=", "\"", "\"", "\n", "}", "\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "gc", ")", "\n\n", "// Check for insecure configurations.op", "s", ".", "checkAuthforWarnings", "(", ")", "\n\n", "// Avoid RACE between Start() and Shutdown()", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "running", "=", "true", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "s", ".", "grMu", ".", "Lock", "(", ")", "\n", "s", ".", "grRunning", "=", "true", "\n", "s", ".", "grMu", ".", "Unlock", "(", ")", "\n\n", "// Snapshot server options.", "opts", ":=", "s", ".", "getOpts", "(", ")", "\n\n", "hasOperators", ":=", "len", "(", "opts", ".", "TrustedOperators", ")", ">", "0", "\n", "if", "hasOperators", "{", "s", ".", "Noticef", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "opc", ":=", "range", "opts", ".", "TrustedOperators", "{", "s", ".", "Noticef", "(", "\"", "\"", ",", "opc", ".", "Audience", ")", "\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "opc", ".", "Name", ")", "\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "time", ".", "Unix", "(", "opc", ".", "IssuedAt", ",", "0", ")", ")", "\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "time", ".", "Unix", "(", "opc", ".", "Expires", ",", "0", ")", ")", "\n", "}", "\n", "if", "hasOperators", "&&", "opts", ".", "SystemAccount", "==", "_EMPTY_", "{", "s", ".", "Warnf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Log the pid to a file", "if", "opts", ".", "PidFile", "!=", "_EMPTY_", "{", "if", "err", ":=", "s", ".", "logPid", "(", ")", ";", "err", "!=", "nil", "{", "PrintAndDie", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "err", ")", ")", "\n", "}", "\n", "}", "\n\n", "// Start monitoring if needed", "if", "err", ":=", "s", ".", "StartMonitoring", "(", ")", ";", "err", "!=", "nil", "{", "s", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// Setup system account which will start eventing stack.", "if", "sa", ":=", "opts", ".", "SystemAccount", ";", "sa", "!=", "_EMPTY_", "{", "if", "err", ":=", "s", ".", "SetSystemAccount", "(", "sa", ")", ";", "err", "!=", "nil", "{", "s", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "}", "\n\n", "// Start up gateway if needed. Do this before starting the routes, because", "// we want to resolve the gateway host:port so that this information can", "// be sent to other routes.", "if", "opts", ".", "Gateway", ".", "Port", "!=", "0", "{", "s", ".", "startGateways", "(", ")", "\n", "}", "\n\n", "// Start up listen if we want to accept leaf node connections.", "if", "opts", ".", "LeafNode", ".", "Port", "!=", "0", "{", "// Spin up the accept loop if needed", "ch", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "go", "s", ".", "leafNodeAcceptLoop", "(", "ch", ")", "\n", "// This ensure that we have resolved or assigned the advertise", "// address for the leafnode listener. We need that in StartRouting().", "<-", "ch", "\n", "}", "\n\n", "// Solicit remote servers for leaf node connections.", "if", "len", "(", "opts", ".", "LeafNode", ".", "Remotes", ")", ">", "0", "{", "s", ".", "solicitLeafNodeRemotes", "(", "opts", ".", "LeafNode", ".", "Remotes", ")", "\n", "}", "\n\n", "// The Routing routine needs to wait for the client listen", "// port to be opened and potential ephemeral port selected.", "clientListenReady", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n\n", "// Start up routing as well if needed.", "if", "opts", ".", "Cluster", ".", "Port", "!=", "0", "{", "s", ".", "startGoRoutine", "(", "func", "(", ")", "{", "s", ".", "StartRouting", "(", "clientListenReady", ")", "\n", "}", ")", "\n", "}", "\n\n", "// Pprof http endpoint for the profiler.", "if", "opts", ".", "ProfPort", "!=", "0", "{", "s", ".", "StartProfiler", "(", ")", "\n", "}", "\n\n", "if", "opts", ".", "PortsFileDir", "!=", "_EMPTY_", "{", "s", ".", "logPorts", "(", ")", "\n", "}", "\n\n", "// Wait for clients.", "s", ".", "AcceptLoop", "(", "clientListenReady", ")", "\n", "}" ]

[ "Start", "up", "the", "server", "this", "will", "block", ".", "Start", "via", "a", "Go", "routine", "if", "needed", "." ]

[ "func", "(", "s", "*", "Server", ")", "Shutdown", "(", ")", "{", "// Shutdown the eventing system as needed.", "// This is done first to send out any messages for", "// account status. We will also clean up any", "// eventing items associated with accounts.", "s", ".", "shutdownEventing", "(", ")", "\n\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "// Prevent issues with multiple calls.", "if", "s", ".", "shutdown", "{", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n", "s", ".", "Noticef", "(", "\"", "\"", ")", "\n\n", "opts", ":=", "s", ".", "getOpts", "(", ")", "\n\n", "s", ".", "shutdown", "=", "true", "\n", "s", ".", "running", "=", "false", "\n", "s", ".", "grMu", ".", "Lock", "(", ")", "\n", "s", ".", "grRunning", "=", "false", "\n", "s", ".", "grMu", ".", "Unlock", "(", ")", "\n\n", "conns", ":=", "make", "(", "map", "[", "uint64", "]", "*", "client", ")", "\n\n", "// Copy off the clients", "for", "i", ",", "c", ":=", "range", "s", ".", "clients", "{", "conns", "[", "i", "]", "=", "c", "\n", "}", "\n", "// Copy off the connections that are not yet registered", "// in s.routes, but for which the readLoop has started", "s", ".", "grMu", ".", "Lock", "(", ")", "\n", "for", "i", ",", "c", ":=", "range", "s", ".", "grTmpClients", "{", "conns", "[", "i", "]", "=", "c", "\n", "}", "\n", "s", ".", "grMu", ".", "Unlock", "(", ")", "\n", "// Copy off the routes", "for", "i", ",", "r", ":=", "range", "s", ".", "routes", "{", "conns", "[", "i", "]", "=", "r", "\n", "}", "\n", "// Copy off the gateways", "s", ".", "getAllGatewayConnections", "(", "conns", ")", "\n\n", "// Copy off the leaf nodes", "for", "i", ",", "c", ":=", "range", "s", ".", "leafs", "{", "conns", "[", "i", "]", "=", "c", "\n", "}", "\n\n", "// Number of done channel responses we expect.", "doneExpected", ":=", "0", "\n\n", "// Kick client AcceptLoop()", "if", "s", ".", "listener", "!=", "nil", "{", "doneExpected", "++", "\n", "s", ".", "listener", ".", "Close", "(", ")", "\n", "s", ".", "listener", "=", "nil", "\n", "}", "\n\n", "// Kick leafnodes AcceptLoop()", "if", "s", ".", "leafNodeListener", "!=", "nil", "{", "doneExpected", "++", "\n", "s", ".", "leafNodeListener", ".", "Close", "(", ")", "\n", "s", ".", "leafNodeListener", "=", "nil", "\n", "}", "\n\n", "// Kick route AcceptLoop()", "if", "s", ".", "routeListener", "!=", "nil", "{", "doneExpected", "++", "\n", "s", ".", "routeListener", ".", "Close", "(", ")", "\n", "s", ".", "routeListener", "=", "nil", "\n", "}", "\n\n", "// Kick Gateway AcceptLoop()", "if", "s", ".", "gatewayListener", "!=", "nil", "{", "doneExpected", "++", "\n", "s", ".", "gatewayListener", ".", "Close", "(", ")", "\n", "s", ".", "gatewayListener", "=", "nil", "\n", "}", "\n\n", "// Kick HTTP monitoring if its running", "if", "s", ".", "http", "!=", "nil", "{", "doneExpected", "++", "\n", "s", ".", "http", ".", "Close", "(", ")", "\n", "s", ".", "http", "=", "nil", "\n", "}", "\n\n", "// Kick Profiling if its running", "if", "s", ".", "profiler", "!=", "nil", "{", "doneExpected", "++", "\n", "s", ".", "profiler", ".", "Close", "(", ")", "\n", "}", "\n\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Release go routines that wait on that channel", "close", "(", "s", ".", "quitCh", ")", "\n\n", "// Close client and route connections", "for", "_", ",", "c", ":=", "range", "conns", "{", "c", ".", "setNoReconnect", "(", ")", "\n", "c", ".", "closeConnection", "(", "ServerShutdown", ")", "\n", "}", "\n\n", "// Block until the accept loops exit", "for", "doneExpected", ">", "0", "{", "<-", "s", ".", "done", "\n", "doneExpected", "--", "\n", "}", "\n\n", "// Wait for go routines to be done.", "s", ".", "grWG", ".", "Wait", "(", ")", "\n\n", "if", "opts", ".", "PortsFileDir", "!=", "_EMPTY_", "{", "s", ".", "deletePortsFile", "(", "opts", ".", "PortsFileDir", ")", "\n", "}", "\n\n", "// Close logger if applicable. It allows tests on Windows", "// to be able to do proper cleanup (delete log file).", "s", ".", "logging", ".", "RLock", "(", ")", "\n", "log", ":=", "s", ".", "logging", ".", "logger", "\n", "s", ".", "logging", ".", "RUnlock", "(", ")", "\n", "if", "log", "!=", "nil", "{", "if", "l", ",", "ok", ":=", "log", ".", "(", "*", "logger", ".", "Logger", ")", ";", "ok", "{", "l", ".", "Close", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Shutdown", "will", "shutdown", "the", "server", "instance", "by", "kicking", "out", "the", "AcceptLoop", "and", "closing", "all", "associated", "clients", "." ]

[ "func", "(", "s", "*", "Server", ")", "AcceptLoop", "(", "clr", "chan", "struct", "{", "}", ")", "{", "// If we were to exit before the listener is setup properly,", "// make sure we close the channel.", "defer", "func", "(", ")", "{", "if", "clr", "!=", "nil", "{", "close", "(", "clr", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Snapshot server options.", "opts", ":=", "s", ".", "getOpts", "(", ")", "\n\n", "hp", ":=", "net", ".", "JoinHostPort", "(", "opts", ".", "Host", ",", "strconv", ".", "Itoa", "(", "opts", ".", "Port", ")", ")", "\n", "l", ",", "e", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "hp", ")", "\n", "if", "e", "!=", "nil", "{", "s", ".", "Fatalf", "(", "\"", "\"", ",", "hp", ",", "e", ")", "\n", "return", "\n", "}", "\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "net", ".", "JoinHostPort", "(", "opts", ".", "Host", ",", "strconv", ".", "Itoa", "(", "l", ".", "Addr", "(", ")", ".", "(", "*", "net", ".", "TCPAddr", ")", ".", "Port", ")", ")", ")", "\n\n", "// Alert of TLS enabled.", "if", "opts", ".", "TLSConfig", "!=", "nil", "{", "s", ".", "Noticef", "(", "\"", "\"", ")", "\n", "}", "\n\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "s", ".", "info", ".", "ID", ")", "\n", "s", ".", "Noticef", "(", "\"", "\"", ")", "\n\n", "// Setup state that can enable shutdown", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "listener", "=", "l", "\n\n", "// If server was started with RANDOM_PORT (-1), opts.Port would be equal", "// to 0 at the beginning this function. So we need to get the actual port", "if", "opts", ".", "Port", "==", "0", "{", "// Write resolved port back to options.", "opts", ".", "Port", "=", "l", ".", "Addr", "(", ")", ".", "(", "*", "net", ".", "TCPAddr", ")", ".", "Port", "\n", "}", "\n\n", "// Now that port has been set (if it was set to RANDOM), set the", "// server's info Host/Port with either values from Options or", "// ClientAdvertise. Also generate the JSON byte array.", "if", "err", ":=", "s", ".", "setInfoHostPortAndGenerateJSON", "(", ")", ";", "err", "!=", "nil", "{", "s", ".", "Fatalf", "(", "\"", "\"", ",", "s", ".", "opts", ".", "ClientAdvertise", ",", "err", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}", "\n", "// Keep track of client connect URLs. We may need them later.", "s", ".", "clientConnectURLs", "=", "s", ".", "getClientConnectURLs", "(", ")", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Let the caller know that we are ready", "close", "(", "clr", ")", "\n", "clr", "=", "nil", "\n\n", "tmpDelay", ":=", "ACCEPT_MIN_SLEEP", "\n\n", "for", "s", ".", "isRunning", "(", ")", "{", "conn", ",", "err", ":=", "l", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "s", ".", "isLameDuckMode", "(", ")", "{", "// Signal that we are not accepting new clients", "s", ".", "ldmCh", "<-", "true", "\n", "// Now wait for the Shutdown...", "<-", "s", ".", "quitCh", "\n", "return", "\n", "}", "\n", "tmpDelay", "=", "s", ".", "acceptError", "(", "\"", "\"", ",", "err", ",", "tmpDelay", ")", "\n", "continue", "\n", "}", "\n", "tmpDelay", "=", "ACCEPT_MIN_SLEEP", "\n", "s", ".", "startGoRoutine", "(", "func", "(", ")", "{", "s", ".", "createClient", "(", "conn", ")", "\n", "s", ".", "grWG", ".", "Done", "(", ")", "\n", "}", ")", "\n", "}", "\n", "s", ".", "done", "<-", "true", "\n", "}" ]

[ "AcceptLoop", "is", "exported", "for", "easier", "testing", "." ]

[ "func", "(", "s", "*", "Server", ")", "StartProfiler", "(", ")", "{", "// Snapshot server options.", "opts", ":=", "s", ".", "getOpts", "(", ")", "\n\n", "port", ":=", "opts", ".", "ProfPort", "\n\n", "// Check for Random Port", "if", "port", "==", "-", "1", "{", "port", "=", "0", "\n", "}", "\n\n", "hp", ":=", "net", ".", "JoinHostPort", "(", "opts", ".", "Host", ",", "strconv", ".", "Itoa", "(", "port", ")", ")", "\n\n", "l", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "hp", ")", "\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "l", ".", "Addr", "(", ")", ".", "(", "*", "net", ".", "TCPAddr", ")", ".", "Port", ")", "\n\n", "if", "err", "!=", "nil", "{", "s", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "srv", ":=", "&", "http", ".", "Server", "{", "Addr", ":", "hp", ",", "Handler", ":", "http", ".", "DefaultServeMux", ",", "MaxHeaderBytes", ":", "1", "<<", "20", ",", "}", "\n\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "profiler", "=", "l", "\n", "s", ".", "profilingServer", "=", "srv", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "go", "func", "(", ")", "{", "// if this errors out, it's probably because the server is being shutdown", "err", ":=", "srv", ".", "Serve", "(", "l", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "shutdown", ":=", "s", ".", "shutdown", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "!", "shutdown", "{", "s", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "s", ".", "done", "<-", "true", "\n", "}", "(", ")", "\n", "}" ]

[ "StartProfiler", "is", "called", "to", "enable", "dynamic", "profiling", "." ]

[ "func", "(", "s", "*", "Server", ")", "StartMonitoring", "(", ")", "error", "{", "// Snapshot server options.", "opts", ":=", "s", ".", "getOpts", "(", ")", "\n\n", "// Specifying both HTTP and HTTPS ports is a misconfiguration", "if", "opts", ".", "HTTPPort", "!=", "0", "&&", "opts", ".", "HTTPSPort", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "opts", ".", "HTTPPort", ",", "opts", ".", "HTTPSPort", ")", "\n", "}", "\n", "var", "err", "error", "\n", "if", "opts", ".", "HTTPPort", "!=", "0", "{", "err", "=", "s", ".", "startMonitoring", "(", "false", ")", "\n", "}", "else", "if", "opts", ".", "HTTPSPort", "!=", "0", "{", "if", "opts", ".", "TLSConfig", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "err", "=", "s", ".", "startMonitoring", "(", "true", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "StartMonitoring", "starts", "the", "HTTP", "or", "HTTPs", "server", "if", "needed", "." ]

[ "func", "(", "s", "*", "Server", ")", "startMonitoring", "(", "secure", "bool", ")", "error", "{", "// Snapshot server options.", "opts", ":=", "s", ".", "getOpts", "(", ")", "\n\n", "// Used to track HTTP requests", "s", ".", "httpReqStats", "=", "map", "[", "string", "]", "uint64", "{", "RootPath", ":", "0", ",", "VarzPath", ":", "0", ",", "ConnzPath", ":", "0", ",", "RoutezPath", ":", "0", ",", "SubszPath", ":", "0", ",", "}", "\n\n", "var", "(", "hp", "string", "\n", "err", "error", "\n", "httpListener", "net", ".", "Listener", "\n", "port", "int", "\n", ")", "\n\n", "monitorProtocol", ":=", "\"", "\"", "\n\n", "if", "secure", "{", "monitorProtocol", "+=", "\"", "\"", "\n", "port", "=", "opts", ".", "HTTPSPort", "\n", "if", "port", "==", "-", "1", "{", "port", "=", "0", "\n", "}", "\n", "hp", "=", "net", ".", "JoinHostPort", "(", "opts", ".", "HTTPHost", ",", "strconv", ".", "Itoa", "(", "port", ")", ")", "\n", "config", ":=", "opts", ".", "TLSConfig", ".", "Clone", "(", ")", "\n", "config", ".", "ClientAuth", "=", "tls", ".", "NoClientCert", "\n", "httpListener", ",", "err", "=", "tls", ".", "Listen", "(", "\"", "\"", ",", "hp", ",", "config", ")", "\n\n", "}", "else", "{", "port", "=", "opts", ".", "HTTPPort", "\n", "if", "port", "==", "-", "1", "{", "port", "=", "0", "\n", "}", "\n", "hp", "=", "net", ".", "JoinHostPort", "(", "opts", ".", "HTTPHost", ",", "strconv", ".", "Itoa", "(", "port", ")", ")", "\n", "httpListener", ",", "err", "=", "net", ".", "Listen", "(", "\"", "\"", ",", "hp", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "s", ".", "Noticef", "(", "\"", "\"", ",", "monitorProtocol", ",", "net", ".", "JoinHostPort", "(", "opts", ".", "HTTPHost", ",", "strconv", ".", "Itoa", "(", "httpListener", ".", "Addr", "(", ")", ".", "(", "*", "net", ".", "TCPAddr", ")", ".", "Port", ")", ")", ")", "\n\n", "mux", ":=", "http", ".", "NewServeMux", "(", ")", "\n\n", "// Root", "mux", ".", "HandleFunc", "(", "RootPath", ",", "s", ".", "HandleRoot", ")", "\n", "// Varz", "mux", ".", "HandleFunc", "(", "VarzPath", ",", "s", ".", "HandleVarz", ")", "\n", "// Connz", "mux", ".", "HandleFunc", "(", "ConnzPath", ",", "s", ".", "HandleConnz", ")", "\n", "// Routez", "mux", ".", "HandleFunc", "(", "RoutezPath", ",", "s", ".", "HandleRoutez", ")", "\n", "// Subz", "mux", ".", "HandleFunc", "(", "SubszPath", ",", "s", ".", "HandleSubsz", ")", "\n", "// Subz alias for backwards compatibility", "mux", ".", "HandleFunc", "(", "\"", "\"", ",", "s", ".", "HandleSubsz", ")", "\n", "// Stacksz", "mux", ".", "HandleFunc", "(", "StackszPath", ",", "s", ".", "HandleStacksz", ")", "\n\n", "// Do not set a WriteTimeout because it could cause cURL/browser", "// to return empty response or unable to display page if the", "// server needs more time to build the response.", "srv", ":=", "&", "http", ".", "Server", "{", "Addr", ":", "hp", ",", "Handler", ":", "mux", ",", "MaxHeaderBytes", ":", "1", "<<", "20", ",", "}", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "http", "=", "httpListener", "\n", "s", ".", "httpHandler", "=", "mux", "\n", "s", ".", "monitoringServer", "=", "srv", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "go", "func", "(", ")", "{", "srv", ".", "Serve", "(", "httpListener", ")", "\n", "srv", ".", "Handler", "=", "nil", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "httpHandler", "=", "nil", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "s", ".", "done", "<-", "true", "\n", "}", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Start", "the", "monitoring", "server" ]

[ "func", "(", "s", "*", "Server", ")", "copyInfo", "(", ")", "Info", "{", "info", ":=", "s", ".", "info", "\n", "if", "info", ".", "ClientConnectURLs", "!=", "nil", "{", "info", ".", "ClientConnectURLs", "=", "make", "(", "[", "]", "string", ",", "len", "(", "s", ".", "info", ".", "ClientConnectURLs", ")", ")", "\n", "copy", "(", "info", ".", "ClientConnectURLs", ",", "s", ".", "info", ".", "ClientConnectURLs", ")", "\n", "}", "\n", "if", "s", ".", "nonceRequired", "(", ")", "{", "// Nonce handling", "var", "raw", "[", "nonceLen", "]", "byte", "\n", "nonce", ":=", "raw", "[", ":", "]", "\n", "s", ".", "generateNonce", "(", "nonce", ")", "\n", "info", ".", "Nonce", "=", "string", "(", "nonce", ")", "\n", "}", "\n", "return", "info", "\n", "}" ]

[ "Perform", "a", "conditional", "deep", "copy", "due", "to", "reference", "nature", "of", "ClientConnectURLs", ".", "If", "updates", "are", "made", "to", "Info", "this", "function", "should", "be", "consulted", "and", "updated", ".", "Assume", "lock", "is", "held", "." ]

[ "func", "tlsTimeout", "(", "c", "*", "client", ",", "conn", "*", "tls", ".", "Conn", ")", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "nc", ":=", "c", ".", "nc", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "// Check if already closed", "if", "nc", "==", "nil", "{", "return", "\n", "}", "\n", "cs", ":=", "conn", ".", "ConnectionState", "(", ")", "\n", "if", "!", "cs", ".", "HandshakeComplete", "{", "c", ".", "Errorf", "(", "\"", "\"", ")", "\n", "c", ".", "sendErr", "(", "\"", "\"", ")", "\n", "c", ".", "closeConnection", "(", "TLSHandshakeError", ")", "\n", "}", "\n", "}" ]

[ "Handle", "closing", "down", "a", "connection", "when", "the", "handshake", "has", "timedout", "." ]

[ "func", "tlsVersion", "(", "ver", "uint16", ")", "string", "{", "switch", "ver", "{", "case", "tls", ".", "VersionTLS10", ":", "return", "\"", "\"", "\n", "case", "tls", ".", "VersionTLS11", ":", "return", "\"", "\"", "\n", "case", "tls", ".", "VersionTLS12", ":", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ver", ")", "\n", "}" ]

[ "Seems", "silly", "we", "have", "to", "write", "these" ]

[ "func", "tlsCipher", "(", "cs", "uint16", ")", "string", "{", "name", ",", "present", ":=", "cipherMapByID", "[", "cs", "]", "\n", "if", "present", "{", "return", "name", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cs", ")", "\n", "}" ]

[ "We", "use", "hex", "here", "so", "we", "don", "t", "need", "multiple", "versions" ]

[ "func", "(", "s", "*", "Server", ")", "removeClient", "(", "c", "*", "client", ")", "{", "// type is immutable, so can check without lock", "switch", "c", ".", "kind", "{", "case", "CLIENT", ":", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "cid", ":=", "c", ".", "cid", "\n", "updateProtoInfoCount", ":=", "false", "\n", "if", "c", ".", "kind", "==", "CLIENT", "&&", "c", ".", "opts", ".", "Protocol", ">=", "ClientProtoInfo", "{", "updateProtoInfoCount", "=", "true", "\n", "}", "\n", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "delete", "(", "s", ".", "clients", ",", "cid", ")", "\n", "if", "updateProtoInfoCount", "{", "s", ".", "cproto", "--", "\n", "}", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "case", "ROUTER", ":", "s", ".", "removeRoute", "(", "c", ")", "\n", "case", "GATEWAY", ":", "s", ".", "removeRemoteGatewayConnection", "(", "c", ")", "\n", "case", "LEAF", ":", "s", ".", "removeLeafNodeConnection", "(", "c", ")", "\n", "}", "\n", "}" ]

[ "Remove", "a", "client", "or", "route", "from", "our", "internal", "accounting", "." ]

[ "func", "(", "s", "*", "Server", ")", "NumRemotes", "(", ")", "int", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "len", "(", "s", ".", "remotes", ")", "\n", "}" ]

[ "NumRemotes", "will", "report", "number", "of", "registered", "remotes", "." ]

[ "func", "(", "s", "*", "Server", ")", "NumLeafNodes", "(", ")", "int", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "len", "(", "s", ".", "leafs", ")", "\n", "}" ]

[ "NumLeafNodes", "will", "report", "number", "of", "leaf", "node", "connections", "." ]