Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "r", "FutureGetMiningInfoResult", ")", "Receive", "(", ")", "(", "*", "btcjson", ".", "GetMiningInfoResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as a getmininginfo result object.", "var", "infoResult", "btcjson", ".", "GetMiningInfoResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "infoResult", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "infoResult", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "mining", "information", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetMiningInfoAsync", "(", ")", "FutureGetMiningInfoResult", "{", "cmd", ":=", "btcjson", ".", "NewGetMiningInfoCmd", "(", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetMiningInfoAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetMiningInfo", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "r", "FutureGetNetworkHashPS", ")", "Receive", "(", ")", "(", "int64", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as an int64.", "var", "result", "int64", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "estimated", "network", "hashes", "per", "second", "for", "the", "block", "heights", "provided", "by", "the", "parameters", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetNetworkHashPSAsync", "(", ")", "FutureGetNetworkHashPS", "{", "cmd", ":=", "btcjson", ".", "NewGetNetworkHashPSCmd", "(", "nil", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetNetworkHashPSAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetNetworkHashPS", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetNetworkHashPS2Async", "(", "blocks", "int", ")", "FutureGetNetworkHashPS", "{", "cmd", ":=", "btcjson", ".", "NewGetNetworkHashPSCmd", "(", "&", "blocks", ",", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetNetworkHashPS2Async", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetNetworkHashPS2", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetNetworkHashPS2", "(", "blocks", "int", ")", "(", "int64", ",", "error", ")", "{", "return", "c", ".", "GetNetworkHashPS2Async", "(", "blocks", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetNetworkHashPS2", "returns", "the", "estimated", "network", "hashes", "per", "second", "for", "the", "specified", "previous", "number", "of", "blocks", "working", "backwards", "from", "the", "most", "recent", "block", "height", ".", "The", "blocks", "parameter", "can", "also", "be", "-", "1", "in", "which", "case", "the", "number", "of", "blocks", "since", "the", "last", "difficulty", "change", "will", "be", "used", ".", "See", "GetNetworkHashPS", "to", "use", "defaults", "and", "GetNetworkHashPS3", "to", "override", "the", "height", "at", "which", "to", "calculate", "the", "estimate", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetNetworkHashPS3Async", "(", "blocks", ",", "height", "int", ")", "FutureGetNetworkHashPS", "{", "cmd", ":=", "btcjson", ".", "NewGetNetworkHashPSCmd", "(", "&", "blocks", ",", "&", "height", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetNetworkHashPS3Async", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetNetworkHashPS3", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetNetworkHashPS3", "(", "blocks", ",", "height", "int", ")", "(", "int64", ",", "error", ")", "{", "return", "c", ".", "GetNetworkHashPS3Async", "(", "blocks", ",", "height", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetNetworkHashPS3", "returns", "the", "estimated", "network", "hashes", "per", "second", "for", "the", "specified", "previous", "number", "of", "blocks", "working", "backwards", "from", "the", "specified", "block", "height", ".", "The", "blocks", "parameter", "can", "also", "be", "-", "1", "in", "which", "case", "the", "number", "of", "blocks", "since", "the", "last", "difficulty", "change", "will", "be", "used", ".", "See", "GetNetworkHashPS", "and", "GetNetworkHashPS2", "to", "use", "defaults", "." ]

[ "func", "(", "r", "FutureGetWork", ")", "Receive", "(", ")", "(", "*", "btcjson", ".", "GetWorkResult", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as a getwork result object.", "var", "result", "btcjson", ".", "GetWorkResult", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "result", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "the", "hash", "data", "to", "work", "on", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetWorkAsync", "(", ")", "FutureGetWork", "{", "cmd", ":=", "btcjson", ".", "NewGetWorkCmd", "(", "nil", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetWorkAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetWork", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "r", "FutureGetWorkSubmit", ")", "Receive", "(", ")", "(", "bool", ",", "error", ")", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "// Unmarshal result as a boolean.", "var", "accepted", "bool", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "accepted", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "accepted", ",", "nil", "\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "whether", "or", "not", "the", "submitted", "block", "header", "was", "accepted", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetWorkSubmitAsync", "(", "data", "string", ")", "FutureGetWorkSubmit", "{", "cmd", ":=", "btcjson", ".", "NewGetWorkCmd", "(", "&", "data", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "GetWorkSubmitAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "GetWorkSubmit", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetWorkSubmit", "(", "data", "string", ")", "(", "bool", ",", "error", ")", "{", "return", "c", ".", "GetWorkSubmitAsync", "(", "data", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "GetWorkSubmit", "submits", "a", "block", "header", "which", "is", "a", "solution", "to", "previously", "requested", "data", "and", "returns", "whether", "or", "not", "the", "solution", "was", "accepted", ".", "See", "GetWork", "to", "request", "data", "to", "work", "on", "." ]

[ "func", "(", "r", "FutureSubmitBlockResult", ")", "Receive", "(", ")", "error", "{", "res", ",", "err", ":=", "receiveFuture", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "string", "(", "res", ")", "!=", "\"", "\"", "{", "var", "result", "string", "\n", "err", "=", "json", ".", "Unmarshal", "(", "res", ",", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "errors", ".", "New", "(", "result", ")", "\n", "}", "\n\n", "return", "nil", "\n\n", "}" ]

[ "Receive", "waits", "for", "the", "response", "promised", "by", "the", "future", "and", "returns", "an", "error", "if", "any", "occurred", "when", "submitting", "the", "block", "." ]

[ "func", "(", "c", "*", "Client", ")", "SubmitBlockAsync", "(", "block", "*", "btcutil", ".", "Block", ",", "options", "*", "btcjson", ".", "SubmitBlockOptions", ")", "FutureSubmitBlockResult", "{", "blockHex", ":=", "\"", "\"", "\n", "if", "block", "!=", "nil", "{", "blockBytes", ",", "err", ":=", "block", ".", "Bytes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newFutureError", "(", "err", ")", "\n", "}", "\n\n", "blockHex", "=", "hex", ".", "EncodeToString", "(", "blockBytes", ")", "\n", "}", "\n\n", "cmd", ":=", "btcjson", ".", "NewSubmitBlockCmd", "(", "blockHex", ",", "options", ")", "\n", "return", "c", ".", "sendCmd", "(", "cmd", ")", "\n", "}" ]

[ "SubmitBlockAsync", "returns", "an", "instance", "of", "a", "type", "that", "can", "be", "used", "to", "get", "the", "result", "of", "the", "RPC", "at", "some", "future", "time", "by", "invoking", "the", "Receive", "function", "on", "the", "returned", "instance", ".", "See", "SubmitBlock", "for", "the", "blocking", "version", "and", "more", "details", "." ]

[ "func", "(", "c", "*", "Client", ")", "SubmitBlock", "(", "block", "*", "btcutil", ".", "Block", ",", "options", "*", "btcjson", ".", "SubmitBlockOptions", ")", "error", "{", "return", "c", ".", "SubmitBlockAsync", "(", "block", ",", "options", ")", ".", "Receive", "(", ")", "\n", "}" ]

[ "SubmitBlock", "attempts", "to", "submit", "a", "new", "block", "into", "the", "bitcoin", "network", "." ]

[ "func", "pkcs7Unpad", "(", "data", "[", "]", "byte", ",", "blockSize", "int", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "blockSize", "<=", "0", "{", "return", "nil", ",", "ErrInvalidBlockSize", "\n", "}", "\n", "if", "len", "(", "data", ")", "%", "blockSize", "!=", "0", "||", "len", "(", "data", ")", "==", "0", "{", "return", "nil", ",", "ErrInvalidPKCS7Data", "\n", "}", "\n", "c", ":=", "data", "[", "len", "(", "data", ")", "-", "1", "]", "\n", "n", ":=", "int", "(", "c", ")", "\n", "if", "n", "==", "0", "||", "n", ">", "len", "(", "data", ")", "{", "return", "nil", ",", "ErrInvalidPKCS7Padding", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "n", ";", "i", "++", "{", "if", "data", "[", "len", "(", "data", ")", "-", "n", "+", "i", "]", "!=", "c", "{", "return", "nil", ",", "ErrInvalidPKCS7Padding", "\n", "}", "\n", "}", "\n", "return", "data", "[", ":", "len", "(", "data", ")", "-", "n", "]", ",", "nil", "\n", "}" ]

[ "pkcs7Unpad", "returns", "slice", "of", "the", "original", "data", "without", "padding" ]

[ "func", "NewMemcache", "(", "server", "...", "string", ")", "*", "Memcache", "{", "mc", ":=", "memcache", ".", "New", "(", "server", "...", ")", "\n", "return", "&", "Memcache", "{", "mc", "}", "\n", "}" ]

[ "NewMemcache", "create", "new", "memcache" ]

[ "func", "(", "mem", "*", "Memcache", ")", "Delete", "(", "key", "string", ")", "error", "{", "return", "mem", ".", "conn", ".", "Delete", "(", "key", ")", "\n", "}" ]

[ "Delete", "delete", "value", "in", "memcache", "." ]

[ "func", "(", "ctx", "*", "Context", ")", "Query", "(", "key", "string", ")", "string", "{", "value", ",", "_", ":=", "ctx", ".", "GetQuery", "(", "key", ")", "\n", "return", "value", "\n", "}" ]

[ "Query", "returns", "the", "keyed", "url", "query", "value", "if", "it", "exists" ]

[ "func", "NewPay", "(", "ctx", "*", "context", ".", "Context", ")", "*", "Pay", "{", "pay", ":=", "Pay", "{", "Context", ":", "ctx", "}", "\n", "return", "&", "pay", "\n", "}" ]

[ "NewPay", "return", "an", "instance", "of", "Pay", "package" ]

[ "func", "(", "pcf", "*", "Pay", ")", "PrePayOrder", "(", "p", "*", "Params", ")", "(", "payOrder", "PreOrder", ",", "err", "error", ")", "{", "nonceStr", ":=", "util", ".", "RandomStr", "(", "32", ")", "\n", "param", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "param", "[", "\"", "\"", "]", "=", "pcf", ".", "AppID", "\n", "param", "[", "\"", "\"", "]", "=", "p", ".", "Body", "\n", "param", "[", "\"", "\"", "]", "=", "pcf", ".", "PayMchID", "\n", "param", "[", "\"", "\"", "]", "=", "nonceStr", "\n", "param", "[", "\"", "\"", "]", "=", "pcf", ".", "PayNotifyURL", "\n", "param", "[", "\"", "\"", "]", "=", "p", ".", "OutTradeNo", "\n", "param", "[", "\"", "\"", "]", "=", "p", ".", "CreateIP", "\n", "param", "[", "\"", "\"", "]", "=", "p", ".", "TotalFee", "\n", "param", "[", "\"", "\"", "]", "=", "p", ".", "TradeType", "\n", "param", "[", "\"", "\"", "]", "=", "p", ".", "OpenID", "\n\n", "bizKey", ":=", "\"", "\"", "+", "pcf", ".", "PayKey", "\n", "str", ":=", "orderParam", "(", "param", ",", "bizKey", ")", "\n", "sign", ":=", "util", ".", "MD5Sum", "(", "str", ")", "\n", "request", ":=", "payRequest", "{", "AppID", ":", "pcf", ".", "AppID", ",", "MchID", ":", "pcf", ".", "PayMchID", ",", "NonceStr", ":", "nonceStr", ",", "Sign", ":", "sign", ",", "Body", ":", "p", ".", "Body", ",", "OutTradeNo", ":", "p", ".", "OutTradeNo", ",", "TotalFee", ":", "p", ".", "TotalFee", ",", "SpbillCreateIP", ":", "p", ".", "CreateIP", ",", "NotifyURL", ":", "pcf", ".", "PayNotifyURL", ",", "TradeType", ":", "p", ".", "TradeType", ",", "OpenID", ":", "p", ".", "OpenID", ",", "}", "\n", "rawRet", ",", "err", ":=", "util", ".", "PostXML", "(", "payGateway", ",", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "err", "=", "xml", ".", "Unmarshal", "(", "rawRet", ",", "&", "payOrder", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "payOrder", ".", "ReturnCode", "==", "\"", "\"", "{", "//pay success", "if", "payOrder", ".", "ResultCode", "==", "\"", "\"", "{", "err", "=", "nil", "\n", "return", "\n", "}", "\n", "err", "=", "errors", ".", "New", "(", "payOrder", ".", "ErrCode", "+", "payOrder", ".", "ErrCodeDes", ")", "\n", "return", "\n", "}", "\n", "err", "=", "errors", ".", "New", "(", "\"", "\"", "+", "string", "(", "rawRet", ")", "+", "\"", "\"", "+", "str", "+", "\"", "\"", "+", "sign", "+", "\"", "\"", ")", "\n", "return", "\n", "}" ]

[ "PrePayOrder", "return", "data", "for", "invoke", "wechat", "payment" ]

[ "func", "(", "pcf", "*", "Pay", ")", "PrePayID", "(", "p", "*", "Params", ")", "(", "prePayID", "string", ",", "err", "error", ")", "{", "order", ",", "err", ":=", "pcf", ".", "PrePayOrder", "(", "p", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "order", ".", "PrePayID", "==", "\"", "\"", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "prePayID", "=", "order", ".", "PrePayID", "\n", "return", "\n", "}" ]

[ "PrePayID", "will", "request", "wechat", "merchant", "api", "and", "request", "for", "a", "pre", "payment", "order", "id" ]

[ "func", "(", "ctx", "*", "Context", ")", "Render", "(", "bytes", "[", "]", "byte", ")", "{", "//debug", "//fmt.Println(\"response msg = \", string(bytes))", "ctx", ".", "Writer", ".", "WriteHeader", "(", "200", ")", "\n", "_", ",", "err", ":=", "ctx", ".", "Writer", ".", "Write", "(", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "Render", "render", "from", "bytes" ]

[ "func", "(", "ctx", "*", "Context", ")", "String", "(", "str", "string", ")", "{", "writeContextType", "(", "ctx", ".", "Writer", ",", "plainContentType", ")", "\n", "ctx", ".", "Render", "(", "[", "]", "byte", "(", "str", ")", ")", "\n", "}" ]

[ "String", "render", "from", "string" ]

[ "func", "(", "ctx", "*", "Context", ")", "XML", "(", "obj", "interface", "{", "}", ")", "{", "writeContextType", "(", "ctx", ".", "Writer", ",", "xmlContentType", ")", "\n", "bytes", ",", "err", ":=", "xml", ".", "Marshal", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "ctx", ".", "Render", "(", "bytes", ")", "\n", "}" ]

[ "XML", "render", "to", "xml" ]

[ "func", "(", "t", "*", "TeeReadCloser", ")", "Close", "(", ")", "error", "{", "err1", ":=", "t", ".", "c", ".", "Close", "(", ")", "\n", "err2", ":=", "t", ".", "w", ".", "Close", "(", ")", "\n", "if", "err1", "!=", "nil", "{", "return", "err1", "\n", "}", "\n", "return", "err2", "\n", "}" ]

[ "Close", "attempts", "to", "close", "the", "reader", "and", "write", ".", "It", "returns", "an", "error", "if", "both", "failed", "to", "Close", "." ]

[ "func", "HandleStringReader", "(", "f", "func", "(", "r", "io", ".", "Reader", ",", "ctx", "*", "goproxy", ".", "ProxyCtx", ")", "io", ".", "Reader", ")", "goproxy", ".", "RespHandler", "{", "return", "goproxy", ".", "FuncRespHandler", "(", "func", "(", "resp", "*", "http", ".", "Response", ",", "ctx", "*", "goproxy", ".", "ProxyCtx", ")", "*", "http", ".", "Response", "{", "if", "ctx", ".", "Error", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "charsetName", ":=", "ctx", ".", "Charset", "(", ")", "\n", "if", "charsetName", "==", "\"", "\"", "{", "charsetName", "=", "\"", "\"", "\n", "}", "\n\n", "if", "strings", ".", "ToLower", "(", "charsetName", ")", "!=", "\"", "\"", "{", "r", ",", "err", ":=", "charset", ".", "NewReader", "(", "charsetName", ",", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "ctx", ".", "Warnf", "(", "\"", "\"", ",", "charsetName", ",", "err", ")", "\n", "return", "resp", "\n", "}", "\n", "tr", ",", "err", ":=", "charset", ".", "TranslatorTo", "(", "charsetName", ")", "\n", "if", "err", "!=", "nil", "{", "ctx", ".", "Warnf", "(", "\"", "\"", ",", "charsetName", ",", "err", ")", "\n", "return", "resp", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "ctx", ".", "Warnf", "(", "\"", "\"", ",", "charsetName", ",", "err", ")", "\n", "return", "resp", "\n", "}", "\n", "newr", ":=", "charset", ".", "NewTranslatingReader", "(", "f", "(", "r", ",", "ctx", ")", ",", "tr", ")", "\n", "resp", ".", "Body", "=", "&", "readFirstCloseBoth", "{", "ioutil", ".", "NopCloser", "(", "newr", ")", ",", "resp", ".", "Body", "}", "\n", "}", "else", "{", "//no translation is needed, already at utf-8", "resp", ".", "Body", "=", "&", "readFirstCloseBoth", "{", "ioutil", ".", "NopCloser", "(", "f", "(", "resp", ".", "Body", ",", "ctx", ")", ")", ",", "resp", ".", "Body", "}", "\n", "}", "\n", "return", "resp", "\n", "}", ")", "\n", "}" ]

[ "Will", "receive", "an", "input", "stream", "which", "would", "convert", "the", "response", "to", "utf", "-", "8", "The", "given", "function", "must", "close", "the", "reader", "r", "in", "order", "to", "close", "the", "response", "body", "." ]

[ "func", "(", "t", "*", "Transport", ")", "RegisterProtocol", "(", "scheme", "string", ",", "rt", "RoundTripper", ")", "{", "if", "scheme", "==", "\"", "\"", "||", "scheme", "==", "\"", "\"", "{", "panic", "(", "\"", "\"", "+", "scheme", "+", "\"", "\"", ")", "\n", "}", "\n", "t", ".", "lk", ".", "Lock", "(", ")", "\n", "defer", "t", ".", "lk", ".", "Unlock", "(", ")", "\n", "if", "t", ".", "altProto", "==", "nil", "{", "t", ".", "altProto", "=", "make", "(", "map", "[", "string", "]", "RoundTripper", ")", "\n", "}", "\n", "if", "_", ",", "exists", ":=", "t", ".", "altProto", "[", "scheme", "]", ";", "exists", "{", "panic", "(", "\"", "\"", "+", "scheme", "+", "\"", "\"", ")", "\n", "}", "\n", "t", ".", "altProto", "[", "scheme", "]", "=", "rt", "\n", "}" ]

[ "RegisterProtocol", "registers", "a", "new", "protocol", "with", "scheme", ".", "The", "Transport", "will", "pass", "requests", "using", "the", "given", "scheme", "to", "rt", ".", "It", "is", "rt", "s", "responsibility", "to", "simulate", "HTTP", "request", "semantics", ".", "RegisterProtocol", "can", "be", "used", "by", "other", "packages", "to", "provide", "implementations", "of", "protocol", "schemes", "like", "ftp", "or", "file", "." ]

[ "func", "(", "t", "*", "Transport", ")", "CloseIdleConnections", "(", ")", "{", "t", ".", "lk", ".", "Lock", "(", ")", "\n", "defer", "t", ".", "lk", ".", "Unlock", "(", ")", "\n", "if", "t", ".", "idleConn", "==", "nil", "{", "return", "\n", "}", "\n", "for", "_", ",", "conns", ":=", "range", "t", ".", "idleConn", "{", "for", "_", ",", "pconn", ":=", "range", "conns", "{", "pconn", ".", "close", "(", ")", "\n", "}", "\n", "}", "\n", "t", ".", "idleConn", "=", "make", "(", "map", "[", "string", "]", "[", "]", "*", "persistConn", ")", "\n", "}" ]

[ "CloseIdleConnections", "closes", "any", "connections", "which", "were", "previously", "connected", "from", "previous", "requests", "but", "are", "now", "sitting", "idle", "in", "a", "keep", "-", "alive", "state", ".", "It", "does", "not", "interrupt", "any", "connections", "currently", "in", "use", "." ]

[ "func", "getenvEitherCase", "(", "k", "string", ")", "string", "{", "if", "v", ":=", "os", ".", "Getenv", "(", "strings", ".", "ToUpper", "(", "k", ")", ")", ";", "v", "!=", "\"", "\"", "{", "return", "v", "\n", "}", "\n", "return", "os", ".", "Getenv", "(", "strings", ".", "ToLower", "(", "k", ")", ")", "\n", "}" ]

[ "Private", "implementation", "past", "this", "point", "." ]

[ "func", "(", "cm", "*", "connectMethod", ")", "proxyAuth", "(", ")", "string", "{", "if", "cm", ".", "proxyURL", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "u", ":=", "cm", ".", "proxyURL", ".", "User", ";", "u", "!=", "nil", "{", "return", "\"", "\"", "+", "base64", ".", "URLEncoding", ".", "EncodeToString", "(", "[", "]", "byte", "(", "u", ".", "String", "(", ")", ")", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "proxyAuth", "returns", "the", "Proxy", "-", "Authorization", "header", "to", "set", "on", "requests", "if", "applicable", "." ]

[ "func", "(", "t", "*", "Transport", ")", "putIdleConn", "(", "pconn", "*", "persistConn", ")", "bool", "{", "t", ".", "lk", ".", "Lock", "(", ")", "\n", "defer", "t", ".", "lk", ".", "Unlock", "(", ")", "\n", "if", "t", ".", "DisableKeepAlives", "||", "t", ".", "MaxIdleConnsPerHost", "<", "0", "{", "pconn", ".", "close", "(", ")", "\n", "return", "false", "\n", "}", "\n", "if", "pconn", ".", "isBroken", "(", ")", "{", "return", "false", "\n", "}", "\n", "key", ":=", "pconn", ".", "cacheKey", "\n", "max", ":=", "t", ".", "MaxIdleConnsPerHost", "\n", "if", "max", "==", "0", "{", "max", "=", "DefaultMaxIdleConnsPerHost", "\n", "}", "\n", "if", "len", "(", "t", ".", "idleConn", "[", "key", "]", ")", ">=", "max", "{", "pconn", ".", "close", "(", ")", "\n", "return", "false", "\n", "}", "\n", "t", ".", "idleConn", "[", "key", "]", "=", "append", "(", "t", ".", "idleConn", "[", "key", "]", ",", "pconn", ")", "\n", "return", "true", "\n", "}" ]

[ "putIdleConn", "adds", "pconn", "to", "the", "list", "of", "idle", "persistent", "connections", "awaiting", "a", "new", "request", ".", "If", "pconn", "is", "no", "longer", "needed", "or", "not", "in", "a", "good", "state", "putIdleConn", "returns", "false", "." ]

[ "func", "useProxy", "(", "addr", "string", ")", "bool", "{", "if", "len", "(", "addr", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "host", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "if", "host", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "if", "ip", ":=", "net", ".", "ParseIP", "(", "host", ")", ";", "ip", "!=", "nil", "{", "if", "ip", ".", "IsLoopback", "(", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "no_proxy", ":=", "getenvEitherCase", "(", "\"", "\"", ")", "\n", "if", "no_proxy", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n\n", "addr", "=", "strings", ".", "ToLower", "(", "strings", ".", "TrimSpace", "(", "addr", ")", ")", "\n", "if", "hasPort", "(", "addr", ")", "{", "addr", "=", "addr", "[", ":", "strings", ".", "LastIndex", "(", "addr", ",", "\"", "\"", ")", "]", "\n", "}", "\n\n", "for", "_", ",", "p", ":=", "range", "strings", ".", "Split", "(", "no_proxy", ",", "\"", "\"", ")", "{", "p", "=", "strings", ".", "ToLower", "(", "strings", ".", "TrimSpace", "(", "p", ")", ")", "\n", "if", "len", "(", "p", ")", "==", "0", "{", "continue", "\n", "}", "\n", "if", "hasPort", "(", "p", ")", "{", "p", "=", "p", "[", ":", "strings", ".", "LastIndex", "(", "p", ",", "\"", "\"", ")", "]", "\n", "}", "\n", "if", "addr", "==", "p", "||", "(", "p", "[", "0", "]", "==", "'.'", "&&", "(", "strings", ".", "HasSuffix", "(", "addr", ",", "p", ")", "||", "addr", "==", "p", "[", "1", ":", "]", ")", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "useProxy", "returns", "true", "if", "requests", "to", "addr", "should", "use", "a", "proxy", "according", "to", "the", "NO_PROXY", "or", "no_proxy", "environment", "variable", ".", "addr", "is", "always", "a", "canonicalAddr", "with", "a", "host", "and", "port", "." ]

[ "func", "(", "cm", "*", "connectMethod", ")", "tlsHost", "(", ")", "string", "{", "h", ":=", "cm", ".", "targetAddr", "\n", "if", "hasPort", "(", "h", ")", "{", "h", "=", "h", "[", ":", "strings", ".", "LastIndex", "(", "h", ",", "\"", "\"", ")", "]", "\n", "}", "\n", "return", "h", "\n", "}" ]

[ "tlsHost", "returns", "the", "host", "name", "to", "match", "against", "the", "peer", "s", "TLS", "certificate", "." ]

[ "func", "NewRegretableReaderCloserSize", "(", "rc", "io", ".", "ReadCloser", ",", "size", "int", ")", "*", "RegretableReaderCloser", "{", "return", "&", "RegretableReaderCloser", "{", "*", "NewRegretableReaderSize", "(", "rc", ",", "size", ")", ",", "rc", "}", "\n", "}" ]

[ "initialize", "a", "RegretableReaderCloser", "with", "underlying", "readCloser", "rc" ]

[ "func", "NewRegretableReaderSize", "(", "r", "io", ".", "Reader", ",", "size", "int", ")", "*", "RegretableReader", "{", "return", "&", "RegretableReader", "{", "reader", ":", "r", ",", "buf", ":", "make", "(", "[", "]", "byte", ",", "size", ")", "}", "\n", "}" ]

[ "initialize", "a", "RegretableReader", "with", "underlying", "reader", "r", "whose", "buffer", "is", "size", "bytes", "long" ]

[ "func", "(", "rb", "*", "RegretableReader", ")", "Read", "(", "p", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "if", "rb", ".", "overflow", "{", "return", "rb", ".", "reader", ".", "Read", "(", "p", ")", "\n", "}", "\n", "if", "rb", ".", "r", "<", "rb", ".", "w", "{", "n", "=", "copy", "(", "p", ",", "rb", ".", "buf", "[", "rb", ".", "r", ":", "rb", ".", "w", "]", ")", "\n", "rb", ".", "r", "+=", "n", "\n", "return", "\n", "}", "\n", "n", ",", "err", "=", "rb", ".", "reader", ".", "Read", "(", "p", ")", "\n", "bn", ":=", "copy", "(", "rb", ".", "buf", "[", "rb", ".", "w", ":", "]", ",", "p", "[", ":", "n", "]", ")", "\n", "rb", ".", "w", ",", "rb", ".", "r", "=", "rb", ".", "w", "+", "bn", ",", "rb", ".", "w", "+", "n", "\n", "if", "bn", "<", "n", "{", "rb", ".", "overflow", "=", "true", "\n", "}", "\n", "return", "\n", "}" ]

[ "reads", "from", "the", "underlying", "reader", ".", "Will", "buffer", "all", "input", "until", "Regret", "is", "called", "." ]

[ "func", "findScriptSrc", "(", "html", "string", ")", "[", "]", "string", "{", "srcs", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "matches", ":=", "scriptMatcher", ".", "FindAllStringIndex", "(", "html", ",", "-", "1", ")", "\n", "for", "_", ",", "match", ":=", "range", "matches", "{", "// -1 to capture the whitespace at the end of the script tag", "srcMatch", ":=", "srcAttrMatcher", ".", "FindStringSubmatch", "(", "html", "[", "match", "[", "1", "]", "-", "1", ":", "]", ")", "\n", "if", "srcMatch", "!=", "nil", "{", "srcs", "=", "append", "(", "srcs", ",", "srcMatch", "[", "1", "]", ")", "\n", "}", "\n", "}", "\n", "return", "srcs", "\n", "}" ]

[ "findScripts", "returns", "all", "sources", "of", "HTML", "script", "tags", "found", "in", "input", "text", "." ]

[ "func", "NewJqueryVersionProxy", "(", ")", "*", "goproxy", ".", "ProxyHttpServer", "{", "proxy", ":=", "goproxy", ".", "NewProxyHttpServer", "(", ")", "\n", "m", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "jqueryMatcher", ":=", "regexp", ".", "MustCompile", "(", "`(?i:jquery\\.)`", ")", "\n", "proxy", ".", "OnResponse", "(", "goproxy_html", ".", "IsHtml", ")", ".", "Do", "(", "goproxy_html", ".", "HandleString", "(", "func", "(", "s", "string", ",", "ctx", "*", "goproxy", ".", "ProxyCtx", ")", "string", "{", "for", "_", ",", "src", ":=", "range", "findScriptSrc", "(", "s", ")", "{", "if", "!", "jqueryMatcher", ".", "MatchString", "(", "src", ")", "{", "continue", "\n", "}", "\n", "prev", ",", "ok", ":=", "m", "[", "ctx", ".", "Req", ".", "Host", "]", "\n", "if", "ok", "{", "if", "prev", "!=", "src", "{", "ctx", ".", "Warnf", "(", "\"", "\"", ",", "ctx", ".", "Req", ".", "URL", ",", "prev", ",", "src", ")", "\n", "break", "\n", "}", "\n", "}", "else", "{", "ctx", ".", "Warnf", "(", "\"", "\"", ",", "ctx", ".", "Req", ".", "Host", ",", "src", ")", "\n", "m", "[", "ctx", ".", "Req", ".", "Host", "]", "=", "src", "\n", "}", "\n", "}", "\n", "return", "s", "\n", "}", ")", ")", "\n", "return", "proxy", "\n", "}" ]

[ "NewJQueryVersionProxy", "creates", "a", "proxy", "checking", "responses", "HTML", "content", "looks", "for", "scripts", "referencing", "jQuery", "library", "and", "emits", "warnings", "if", "different", "versions", "of", "the", "library", "are", "being", "used", "for", "a", "given", "host", "." ]

[ "func", "NewProxyHttpServer", "(", ")", "*", "ProxyHttpServer", "{", "proxy", ":=", "ProxyHttpServer", "{", "Logger", ":", "log", ".", "New", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "log", ".", "LstdFlags", ")", ",", "reqHandlers", ":", "[", "]", "ReqHandler", "{", "}", ",", "respHandlers", ":", "[", "]", "RespHandler", "{", "}", ",", "httpsHandlers", ":", "[", "]", "HttpsHandler", "{", "}", ",", "NonproxyHandler", ":", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "http", ".", "Error", "(", "w", ",", "\"", "\"", ",", "500", ")", "\n", "}", ")", ",", "Tr", ":", "&", "http", ".", "Transport", "{", "TLSClientConfig", ":", "tlsClientSkipVerify", ",", "Proxy", ":", "http", ".", "ProxyFromEnvironment", "}", ",", "}", "\n", "proxy", ".", "ConnectDial", "=", "dialerFromEnv", "(", "&", "proxy", ")", "\n\n", "return", "&", "proxy", "\n", "}" ]

[ "NewProxyHttpServer", "creates", "and", "returns", "a", "proxy", "server", "logging", "to", "stderr", "by", "default" ]

[ "func", "(", "f", "FuncHttpsHandler", ")", "HandleConnect", "(", "host", "string", ",", "ctx", "*", "ProxyCtx", ")", "(", "*", "ConnectAction", ",", "string", ")", "{", "return", "f", "(", "host", ",", "ctx", ")", "\n", "}" ]

[ "FuncHttpsHandler", "should", "implement", "the", "RespHandler", "interface" ]

[ "func", "ProxyBasic", "(", "proxy", "*", "goproxy", ".", "ProxyHttpServer", ",", "realm", "string", ",", "f", "func", "(", "user", ",", "passwd", "string", ")", "bool", ")", "{", "proxy", ".", "OnRequest", "(", ")", ".", "Do", "(", "Basic", "(", "realm", ",", "f", ")", ")", "\n", "proxy", ".", "OnRequest", "(", ")", ".", "HandleConnect", "(", "BasicConnect", "(", "realm", ",", "f", ")", ")", "\n", "}" ]

[ "ProxyBasic", "will", "force", "HTTP", "authentication", "before", "any", "request", "to", "the", "proxy", "is", "processed" ]

[ "func", "(", "c", "ReqConditionFunc", ")", "HandleResp", "(", "resp", "*", "http", ".", "Response", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "return", "c", "(", "ctx", ".", "Req", ",", "ctx", ")", "\n", "}" ]

[ "ReqConditionFunc", "cannot", "test", "responses", ".", "It", "only", "satisfies", "RespCondition", "interface", "so", "that", "to", "be", "usable", "as", "RespCondition", "." ]

[ "func", "ReqHostMatches", "(", "regexps", "...", "*", "regexp", ".", "Regexp", ")", "ReqConditionFunc", "{", "return", "func", "(", "req", "*", "http", ".", "Request", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "for", "_", ",", "re", ":=", "range", "regexps", "{", "if", "re", ".", "MatchString", "(", "req", ".", "Host", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "}" ]

[ "ReqHostMatches", "returns", "a", "ReqCondition", "testing", "whether", "the", "host", "to", "which", "the", "request", "was", "directed", "to", "matches", "any", "of", "the", "given", "regular", "expressions", "." ]

[ "func", "ReqHostIs", "(", "hosts", "...", "string", ")", "ReqConditionFunc", "{", "hostSet", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "for", "_", ",", "h", ":=", "range", "hosts", "{", "hostSet", "[", "h", "]", "=", "true", "\n", "}", "\n", "return", "func", "(", "req", "*", "http", ".", "Request", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "_", ",", "ok", ":=", "hostSet", "[", "req", ".", "URL", ".", "Host", "]", "\n", "return", "ok", "\n", "}", "\n", "}" ]

[ "ReqHostIs", "returns", "a", "ReqCondition", "testing", "whether", "the", "host", "to", "which", "the", "request", "is", "directed", "to", "equal", "to", "one", "of", "the", "given", "strings" ]

[ "func", "UrlMatches", "(", "re", "*", "regexp", ".", "Regexp", ")", "ReqConditionFunc", "{", "return", "func", "(", "req", "*", "http", ".", "Request", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "return", "re", ".", "MatchString", "(", "req", ".", "URL", ".", "Path", ")", "||", "re", ".", "MatchString", "(", "req", ".", "URL", ".", "Host", "+", "req", ".", "URL", ".", "Path", ")", "\n", "}", "\n", "}" ]

[ "UrlMatches", "returns", "a", "ReqCondition", "testing", "whether", "the", "destination", "URL", "of", "the", "request", "matches", "the", "given", "regexp", "with", "or", "without", "prefix" ]

[ "func", "DstHostIs", "(", "host", "string", ")", "ReqConditionFunc", "{", "return", "func", "(", "req", "*", "http", ".", "Request", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "return", "req", ".", "URL", ".", "Host", "==", "host", "\n", "}", "\n", "}" ]

[ "DstHostIs", "returns", "a", "ReqCondition", "testing", "wether", "the", "host", "in", "the", "request", "url", "is", "the", "given", "string" ]

[ "func", "SrcIpIs", "(", "ips", "...", "string", ")", "ReqCondition", "{", "return", "ReqConditionFunc", "(", "func", "(", "req", "*", "http", ".", "Request", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "for", "_", ",", "ip", ":=", "range", "ips", "{", "if", "strings", ".", "HasPrefix", "(", "req", ".", "RemoteAddr", ",", "ip", "+", "\"", "\"", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n", "}" ]

[ "SrcIpIs", "returns", "a", "ReqCondition", "testing", "whether", "the", "source", "IP", "of", "the", "request", "is", "one", "of", "the", "given", "strings" ]

[ "func", "Not", "(", "r", "ReqCondition", ")", "ReqConditionFunc", "{", "return", "func", "(", "req", "*", "http", ".", "Request", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "return", "!", "r", ".", "HandleReq", "(", "req", ",", "ctx", ")", "\n", "}", "\n", "}" ]

[ "Not", "returns", "a", "ReqCondition", "negating", "the", "given", "ReqCondition" ]

[ "func", "ContentTypeIs", "(", "typ", "string", ",", "types", "...", "string", ")", "RespCondition", "{", "types", "=", "append", "(", "types", ",", "typ", ")", "\n", "return", "RespConditionFunc", "(", "func", "(", "resp", "*", "http", ".", "Response", ",", "ctx", "*", "ProxyCtx", ")", "bool", "{", "if", "resp", "==", "nil", "{", "return", "false", "\n", "}", "\n", "contentType", ":=", "resp", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "for", "_", ",", "typ", ":=", "range", "types", "{", "if", "contentType", "==", "typ", "||", "strings", ".", "HasPrefix", "(", "contentType", ",", "typ", "+", "\"", "\"", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n", "}" ]

[ "ContentTypeIs", "returns", "a", "RespCondition", "testing", "whether", "the", "HTTP", "response", "has", "Content", "-", "Type", "header", "equal", "to", "one", "of", "the", "given", "strings", "." ]

[ "func", "HandleBytes", "(", "f", "func", "(", "b", "[", "]", "byte", ",", "ctx", "*", "ProxyCtx", ")", "[", "]", "byte", ")", "RespHandler", "{", "return", "FuncRespHandler", "(", "func", "(", "resp", "*", "http", ".", "Response", ",", "ctx", "*", "ProxyCtx", ")", "*", "http", ".", "Response", "{", "b", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "ctx", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "resp", "\n", "}", "\n", "resp", ".", "Body", ".", "Close", "(", ")", "\n\n", "resp", ".", "Body", "=", "ioutil", ".", "NopCloser", "(", "bytes", ".", "NewBuffer", "(", "f", "(", "b", ",", "ctx", ")", ")", ")", "\n", "return", "resp", "\n", "}", ")", "\n", "}" ]

[ "HandleBytes", "will", "return", "a", "RespHandler", "that", "read", "the", "entire", "body", "of", "the", "request", "to", "a", "byte", "array", "in", "memory", "would", "run", "the", "user", "supplied", "f", "function", "on", "the", "byte", "arra", "and", "will", "replace", "the", "body", "of", "the", "original", "response", "with", "the", "resulting", "byte", "array", "." ]

[ "func", "NewHandler", "(", "n", "*", "centrifuge", ".", "Node", ",", "c", "Config", ")", "*", "Handler", "{", "return", "&", "Handler", "{", "node", ":", "n", ",", "config", ":", "c", ",", "api", ":", "newAPIExecutor", "(", "n", ",", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "NewHandler", "creates", "new", "APIHandler", "." ]

[ "func", "RegisterGRPCServerAPI", "(", "n", "*", "centrifuge", ".", "Node", ",", "server", "*", "grpc", ".", "Server", ",", "config", "GRPCAPIServiceConfig", ")", "error", "{", "RegisterCentrifugoServer", "(", "server", ",", "newGRPCAPIService", "(", "n", ",", "config", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "RegisterGRPCServerAPI", "registers", "GRPC", "API", "service", "in", "provided", "GRPC", "server", "." ]

[ "func", "newGRPCAPIService", "(", "n", "*", "centrifuge", ".", "Node", ",", "c", "GRPCAPIServiceConfig", ")", "*", "grpcAPIService", "{", "return", "&", "grpcAPIService", "{", "config", ":", "c", ",", "api", ":", "newAPIExecutor", "(", "n", ",", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "newGRPCAPIService", "creates", "new", "Service", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "Publish", "(", "ctx", "context", ".", "Context", ",", "req", "*", "PublishRequest", ")", "(", "*", "PublishResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "Publish", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "Publish", "into", "channel", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "Broadcast", "(", "ctx", "context", ".", "Context", ",", "req", "*", "BroadcastRequest", ")", "(", "*", "BroadcastResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "Broadcast", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "Broadcast", "into", "channels", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "Channels", "(", "ctx", "context", ".", "Context", ",", "req", "*", "ChannelsRequest", ")", "(", "*", "ChannelsResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "Channels", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "Channels", "allows", "to", "retrieve", "list", "of", "channels", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "Unsubscribe", "(", "ctx", "context", ".", "Context", ",", "req", "*", "UnsubscribeRequest", ")", "(", "*", "UnsubscribeResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "Unsubscribe", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "Unsubscribe", "user", "from", "channel", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "Disconnect", "(", "ctx", "context", ".", "Context", ",", "req", "*", "DisconnectRequest", ")", "(", "*", "DisconnectResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "Disconnect", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "Disconnect", "user", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "History", "(", "ctx", "context", ".", "Context", ",", "req", "*", "HistoryRequest", ")", "(", "*", "HistoryResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "History", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "History", "in", "channel", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "Presence", "(", "ctx", "context", ".", "Context", ",", "req", "*", "PresenceRequest", ")", "(", "*", "PresenceResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "Presence", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "Presence", "in", "channel", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "PresenceStats", "(", "ctx", "context", ".", "Context", ",", "req", "*", "PresenceStatsRequest", ")", "(", "*", "PresenceStatsResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "PresenceStats", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "PresenceStats", "information", "for", "channel", "." ]

[ "func", "(", "s", "*", "grpcAPIService", ")", "Info", "(", "ctx", "context", ".", "Context", ",", "req", "*", "InfoRequest", ")", "(", "*", "InfoResponse", ",", "error", ")", "{", "return", "s", ".", "api", ".", "Info", "(", "ctx", ",", "req", ")", ",", "nil", "\n", "}" ]

[ "Info", "returns", "information", "about", "Centrifugo", "state", "." ]

[ "func", "APIKeyAuth", "(", "key", "string", ",", "h", "http", ".", "Handler", ")", "http", ".", "Handler", "{", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "if", "key", "==", "\"", "\"", "{", "log", ".", "Error", "(", ")", ".", "Msg", "(", "\"", "\"", ")", "\n", "w", ".", "WriteHeader", "(", "http", ".", "StatusUnauthorized", ")", "\n", "return", "\n", "}", "\n", "authorization", ":=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "parts", ":=", "strings", ".", "Fields", "(", "authorization", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusUnauthorized", ")", "\n", "return", "\n", "}", "\n", "authMethod", ":=", "strings", ".", "ToLower", "(", "parts", "[", "0", "]", ")", "\n", "if", "authMethod", "!=", "\"", "\"", "||", "parts", "[", "1", "]", "!=", "key", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusUnauthorized", ")", "\n", "return", "\n", "}", "\n", "h", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "}", ")", "\n", "}" ]

[ "APIKeyAuth", "middleware", "authorizes", "request", "using", "API", "key", "authorization", "." ]

[ "func", "(", "r", "Raw", ")", "Marshal", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "len", "(", "r", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "[", "]", "byte", "(", "r", ")", ",", "nil", "\n", "}" ]

[ "Marshal", "encodes", "Raw", "to", "slice", "of", "bytes", ".", "Exists", "to", "fit", "gogoprotobuf", "custom", "type", "interface", "." ]

[ "func", "(", "r", "Raw", ")", "MarshalTo", "(", "data", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "if", "len", "(", "r", ")", "==", "0", "{", "return", "0", ",", "nil", "\n", "}", "\n", "copy", "(", "data", ",", "r", ")", "\n", "return", "len", "(", "r", ")", ",", "nil", "\n", "}" ]

[ "MarshalTo", "exists", "to", "fit", "gogoprotobuf", "custom", "type", "interface", "." ]

[ "func", "(", "r", "*", "Raw", ")", "Unmarshal", "(", "data", "[", "]", "byte", ")", "error", "{", "if", "len", "(", "data", ")", "==", "0", "{", "r", "=", "nil", "\n", "return", "nil", "\n", "}", "\n", "id", ":=", "Raw", "(", "make", "(", "[", "]", "byte", ",", "len", "(", "data", ")", ")", ")", "\n", "copy", "(", "id", ",", "data", ")", "\n", "*", "r", "=", "id", "\n", "return", "nil", "\n", "}" ]

[ "Unmarshal", "exists", "to", "fit", "gogoprotobuf", "custom", "type", "interface", "." ]

[ "func", "(", "r", "Raw", ")", "Equal", "(", "other", "Raw", ")", "bool", "{", "return", "bytes", ".", "Equal", "(", "r", "[", "0", ":", "]", ",", "other", "[", "0", ":", "]", ")", "\n", "}" ]

[ "Equal", "exists", "to", "fit", "gogoprotobuf", "custom", "type", "interface", "." ]

[ "func", "(", "r", "Raw", ")", "Compare", "(", "other", "Raw", ")", "int", "{", "return", "bytes", ".", "Compare", "(", "r", "[", "0", ":", "]", ",", "other", "[", "0", ":", "]", ")", "\n", "}" ]

[ "Compare", "exists", "to", "fit", "gogoprotobuf", "custom", "type", "interface", "." ]

[ "func", "NewPopulatedRaw", "(", "r", "intn", ")", "*", "Raw", "{", "v1", ":=", "r", ".", "Intn", "(", "100", ")", "\n", "data", ":=", "make", "(", "[", "]", "byte", ",", "v1", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "v1", ";", "i", "++", "{", "data", "[", "i", "]", "=", "byte", "(", "'a'", ")", "\n", "}", "\n", "d", ":=", "`{\"key\":\"`", "+", "string", "(", "data", ")", "+", "`\"}`", "\n", "raw", ":=", "Raw", "(", "[", "]", "byte", "(", "d", ")", ")", "\n", "return", "&", "raw", "\n", "}" ]

[ "NewPopulatedRaw", "required", "for", "gogoprotobuf", "custom", "type", "." ]

[ "func", "(", "m", "*", "MethodType", ")", "UnmarshalJSON", "(", "data", "[", "]", "byte", ")", "error", "{", "val", ",", "err", ":=", "strconv", ".", "Atoi", "(", "string", "(", "data", ")", ")", "\n", "if", "err", "!=", "nil", "{", "method", ":=", "strings", ".", "Trim", "(", "strings", ".", "ToUpper", "(", "string", "(", "data", ")", ")", ",", "`\"`", ")", "\n", "if", "v", ",", "ok", ":=", "MethodType_value", "[", "method", "]", ";", "ok", "{", "*", "m", "=", "MethodType", "(", "v", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "*", "m", "=", "MethodType", "(", "val", ")", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalJSON", "helps", "to", "unmarshal", "command", "method", "when", "set", "as", "string", "." ]

[ "func", "LogRequest", "(", "h", "http", ".", "Handler", ")", "http", ".", "Handler", "{", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "var", "start", "time", ".", "Time", "\n", "if", "zerolog", ".", "GlobalLevel", "(", ")", "<=", "zerolog", ".", "DebugLevel", "{", "start", "=", "time", ".", "Now", "(", ")", "\n", "}", "\n", "h", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "if", "zerolog", ".", "GlobalLevel", "(", ")", "<=", "zerolog", ".", "DebugLevel", "{", "addr", ":=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "addr", "==", "\"", "\"", "{", "addr", "=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "addr", "==", "\"", "\"", "{", "addr", "=", "r", ".", "RemoteAddr", "\n", "}", "\n", "}", "\n", "log", ".", "Debug", "(", ")", ".", "Str", "(", "\"", "\"", ",", "r", ".", "Method", ")", ".", "Str", "(", "\"", "\"", ",", "r", ".", "URL", ".", "Path", ")", ".", "Str", "(", "\"", "\"", ",", "addr", ")", ".", "Dur", "(", "\"", "\"", ",", "time", ".", "Since", "(", "start", ")", ")", ".", "Msgf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "\n", "}", ")", "\n", "}" ]

[ "LogRequest", "middleware", "logs", "details", "of", "request", "." ]

[ "func", "(", "s", "*", "Handler", ")", "authHandler", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "formPassword", ":=", "r", ".", "FormValue", "(", "\"", "\"", ")", "\n\n", "insecure", ":=", "s", ".", "config", ".", "Insecure", "\n", "password", ":=", "s", ".", "config", ".", "Password", "\n", "secret", ":=", "s", ".", "config", ".", "Secret", "\n\n", "if", "insecure", "{", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "resp", ":=", "struct", "{", "Token", "string", "`json:\"token\"`", "\n", "}", "{", "Token", ":", "\"", "\"", ",", "}", "\n", "json", ".", "NewEncoder", "(", "w", ")", ".", "Encode", "(", "resp", ")", "\n", "return", "\n", "}", "\n\n", "if", "password", "==", "\"", "\"", "||", "secret", "==", "\"", "\"", "{", "log", ".", "Error", "(", ")", ".", "Msg", "(", "\"", "\"", ")", "\n", "http", ".", "Error", "(", "w", ",", "\"", "\"", ",", "http", ".", "StatusBadRequest", ")", "\n", "return", "\n", "}", "\n\n", "if", "formPassword", "==", "password", "{", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "token", ",", "err", ":=", "generateSecureAdminToken", "(", "secret", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Error", "(", ")", ".", "Msgf", "(", "\"", "\"", ",", "err", ")", "\n", "http", ".", "Error", "(", "w", ",", "\"", "\"", ",", "http", ".", "StatusInternalServerError", ")", "\n", "return", "\n", "}", "\n", "resp", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "token", ",", "}", "\n", "json", ".", "NewEncoder", "(", "w", ")", ".", "Encode", "(", "resp", ")", "\n", "return", "\n", "}", "\n", "http", ".", "Error", "(", "w", ",", "\"", "\"", ",", "http", ".", "StatusBadRequest", ")", "\n", "}" ]

[ "authHandler", "allows", "to", "get", "admin", "web", "interface", "token", "." ]

[ "func", "generateSecureAdminToken", "(", "secret", "string", ")", "(", "string", ",", "error", ")", "{", "s", ":=", "securecookie", ".", "New", "(", "[", "]", "byte", "(", "secret", ")", ",", "nil", ")", "\n", "return", "s", ".", "Encode", "(", "secureAdminTokenKey", ",", "secureAdminTokenValue", ")", "\n", "}" ]

[ "generateSecureAdminToken", "generates", "admin", "authentication", "token", "." ]

[ "func", "checkSecureAdminToken", "(", "secret", "string", ",", "token", "string", ")", "bool", "{", "s", ":=", "securecookie", ".", "New", "(", "[", "]", "byte", "(", "secret", ")", ",", "nil", ")", "\n", "var", "val", "string", "\n", "err", ":=", "s", ".", "Decode", "(", "secureAdminTokenKey", ",", "token", ",", "&", "val", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "if", "val", "!=", "secureAdminTokenValue", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "checkSecureAdminToken", "checks", "admin", "connection", "token", "which", "Centrifugo", "returns", "after", "admin", "login", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "Publish", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "PublishRequest", ")", "*", "PublishResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "ch", ":=", "cmd", ".", "Channel", "\n", "data", ":=", "cmd", ".", "Data", "\n\n", "resp", ":=", "&", "PublishResponse", "{", "}", "\n\n", "if", "ch", "==", "\"", "\"", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "nil", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "if", "len", "(", "data", ")", "==", "0", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "nil", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "_", ",", "ok", ":=", "h", ".", "node", ".", "ChannelOpts", "(", "ch", ")", "\n", "if", "!", "ok", "{", "resp", ".", "Error", "=", "ErrorNamespaceNotFound", "\n", "return", "resp", "\n", "}", "\n\n", "err", ":=", "h", ".", "node", ".", "Publish", "(", "cmd", ".", "Channel", ",", "cmd", ".", "Data", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n", "return", "resp", "\n", "}" ]

[ "Publish", "publishes", "data", "into", "channel", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "Broadcast", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "BroadcastRequest", ")", "*", "BroadcastResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "BroadcastResponse", "{", "}", "\n\n", "channels", ":=", "cmd", ".", "Channels", "\n", "data", ":=", "cmd", ".", "Data", "\n\n", "if", "len", "(", "channels", ")", "==", "0", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "nil", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "if", "len", "(", "data", ")", "==", "0", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "nil", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "errs", ":=", "make", "(", "[", "]", "error", ",", "len", "(", "channels", ")", ")", "\n\n", "var", "wg", "sync", ".", "WaitGroup", "\n\n", "for", "i", ",", "ch", ":=", "range", "channels", "{", "if", "ch", "==", "\"", "\"", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "nil", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "_", ",", "ok", ":=", "h", ".", "node", ".", "ChannelOpts", "(", "ch", ")", "\n", "if", "!", "ok", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "ch", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorNamespaceNotFound", "\n", "return", "resp", "\n", "}", "\n\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "i", "int", ",", "ch", "string", ")", "{", "errs", "[", "i", "]", "=", "h", ".", "node", ".", "Publish", "(", "ch", ",", "data", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", "i", ",", "ch", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n\n", "var", "firstErr", "error", "\n", "for", "i", ":=", "range", "errs", "{", "err", ":=", "errs", "[", "i", "]", "\n", "if", "err", "!=", "nil", "{", "if", "firstErr", "==", "nil", "{", "firstErr", "=", "err", "\n", "}", "\n", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "channels", "[", "i", "]", ",", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "}", "\n", "}", "\n", "if", "firstErr", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "firstErr", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n", "return", "resp", "\n", "}" ]

[ "Broadcast", "publishes", "the", "same", "data", "into", "many", "channels", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "Unsubscribe", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "UnsubscribeRequest", ")", "*", "UnsubscribeResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "UnsubscribeResponse", "{", "}", "\n\n", "user", ":=", "cmd", ".", "User", "\n", "channel", ":=", "cmd", ".", "Channel", "\n\n", "if", "user", "==", "\"", "\"", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "channel", ",", "\"", "\"", ":", "user", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "if", "channel", "!=", "\"", "\"", "{", "_", ",", "ok", ":=", "h", ".", "node", ".", "ChannelOpts", "(", "channel", ")", "\n", "if", "!", "ok", "{", "resp", ".", "Error", "=", "ErrorNamespaceNotFound", "\n", "return", "resp", "\n", "}", "\n", "}", "\n\n", "err", ":=", "h", ".", "node", ".", "Unsubscribe", "(", "user", ",", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "channel", ",", "\"", "\"", ":", "user", ",", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n", "return", "resp", "\n", "}" ]

[ "Unsubscribe", "unsubscribes", "user", "from", "channel", "and", "sends", "unsubscribe", "control", "message", "to", "other", "nodes", "so", "they", "could", "also", "unsubscribe", "user", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "Disconnect", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "DisconnectRequest", ")", "*", "DisconnectResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "DisconnectResponse", "{", "}", "\n\n", "user", ":=", "cmd", ".", "User", "\n", "if", "user", "==", "\"", "\"", "{", "// h.node.Log(centrifuge.NewLogEntry(centrifuge.LogLevelError, \"user required for disconnect\", map[string]interface{}{}))", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "err", ":=", "h", ".", "node", ".", "Disconnect", "(", "user", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "// h.node.Log(centrifuge.NewLogEntry(centrifuge.LogLevelError, \"error disconnecting user\", map[string]interface{}{\"user\": cmd.User, \"error\": errError()}))", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n", "return", "resp", "\n", "}" ]

[ "Disconnect", "disconnects", "user", "by", "its", "ID", "and", "sends", "disconnect", "control", "message", "to", "other", "nodes", "so", "they", "could", "also", "disconnect", "user", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "Presence", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "PresenceRequest", ")", "*", "PresenceResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "PresenceResponse", "{", "}", "\n\n", "ch", ":=", "cmd", ".", "Channel", "\n\n", "if", "ch", "==", "\"", "\"", "{", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "chOpts", ",", "ok", ":=", "h", ".", "node", ".", "ChannelOpts", "(", "ch", ")", "\n", "if", "!", "ok", "{", "resp", ".", "Error", "=", "ErrorNamespaceNotFound", "\n", "return", "resp", "\n", "}", "\n\n", "if", "!", "chOpts", ".", "Presence", "{", "resp", ".", "Error", "=", "ErrorNotAvailable", "\n", "return", "resp", "\n", "}", "\n\n", "presence", ",", "err", ":=", "h", ".", "node", ".", "Presence", "(", "ch", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n\n", "apiPresence", ":=", "make", "(", "map", "[", "string", "]", "*", "ClientInfo", ",", "len", "(", "presence", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "presence", "{", "apiPresence", "[", "k", "]", "=", "&", "ClientInfo", "{", "User", ":", "v", ".", "User", ",", "Client", ":", "v", ".", "Client", ",", "ConnInfo", ":", "Raw", "(", "v", ".", "ConnInfo", ")", ",", "ChanInfo", ":", "Raw", "(", "v", ".", "ChanInfo", ")", ",", "}", "\n", "}", "\n\n", "resp", ".", "Result", "=", "&", "PresenceResult", "{", "Presence", ":", "apiPresence", ",", "}", "\n", "return", "resp", "\n", "}" ]

[ "Presence", "returns", "response", "with", "presence", "information", "for", "channel", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "PresenceStats", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "PresenceStatsRequest", ")", "*", "PresenceStatsResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "PresenceStatsResponse", "{", "}", "\n\n", "ch", ":=", "cmd", ".", "Channel", "\n\n", "if", "ch", "==", "\"", "\"", "{", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "chOpts", ",", "ok", ":=", "h", ".", "node", ".", "ChannelOpts", "(", "ch", ")", "\n", "if", "!", "ok", "{", "resp", ".", "Error", "=", "ErrorNamespaceNotFound", "\n", "return", "resp", "\n", "}", "\n\n", "if", "!", "chOpts", ".", "Presence", "{", "resp", ".", "Error", "=", "ErrorNotAvailable", "\n", "return", "resp", "\n", "}", "\n\n", "stats", ",", "err", ":=", "h", ".", "node", ".", "PresenceStats", "(", "cmd", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n\n", "resp", ".", "Result", "=", "&", "PresenceStatsResult", "{", "NumClients", ":", "uint32", "(", "stats", ".", "NumClients", ")", ",", "NumUsers", ":", "uint32", "(", "stats", ".", "NumUsers", ")", ",", "}", "\n\n", "return", "resp", "\n", "}" ]

[ "PresenceStats", "returns", "response", "with", "presence", "stats", "information", "for", "channel", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "History", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "HistoryRequest", ")", "*", "HistoryResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "HistoryResponse", "{", "}", "\n\n", "ch", ":=", "cmd", ".", "Channel", "\n\n", "if", "ch", "==", "\"", "\"", "{", "resp", ".", "Error", "=", "ErrorBadRequest", "\n", "return", "resp", "\n", "}", "\n\n", "chOpts", ",", "ok", ":=", "h", ".", "node", ".", "ChannelOpts", "(", "ch", ")", "\n", "if", "!", "ok", "{", "resp", ".", "Error", "=", "ErrorNamespaceNotFound", "\n", "return", "resp", "\n", "}", "\n\n", "if", "chOpts", ".", "HistorySize", "<=", "0", "||", "chOpts", ".", "HistoryLifetime", "<=", "0", "{", "resp", ".", "Error", "=", "ErrorNotAvailable", "\n", "return", "resp", "\n", "}", "\n\n", "history", ",", "err", ":=", "h", ".", "node", ".", "History", "(", "ch", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n\n", "apiPubs", ":=", "make", "(", "[", "]", "*", "Publication", ",", "len", "(", "history", ")", ")", "\n\n", "for", "i", ",", "pub", ":=", "range", "history", "{", "apiPub", ":=", "&", "Publication", "{", "UID", ":", "pub", ".", "UID", ",", "Data", ":", "Raw", "(", "pub", ".", "Data", ")", ",", "}", "\n", "if", "pub", ".", "Info", "!=", "nil", "{", "apiPub", ".", "Info", "=", "&", "ClientInfo", "{", "User", ":", "pub", ".", "Info", ".", "User", ",", "Client", ":", "pub", ".", "Info", ".", "Client", ",", "ConnInfo", ":", "Raw", "(", "pub", ".", "Info", ".", "ConnInfo", ")", ",", "ChanInfo", ":", "Raw", "(", "pub", ".", "Info", ".", "ChanInfo", ")", ",", "}", "\n", "}", "\n", "apiPubs", "[", "i", "]", "=", "apiPub", "\n", "}", "\n\n", "resp", ".", "Result", "=", "&", "HistoryResult", "{", "Publications", ":", "apiPubs", ",", "}", "\n", "return", "resp", "\n", "}" ]

[ "History", "returns", "response", "with", "history", "information", "for", "channel", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "Channels", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "ChannelsRequest", ")", "*", "ChannelsResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "ChannelsResponse", "{", "}", "\n\n", "channels", ",", "err", ":=", "h", ".", "node", ".", "Channels", "(", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n\n", "resp", ".", "Result", "=", "&", "ChannelsResult", "{", "Channels", ":", "channels", ",", "}", "\n", "return", "resp", "\n", "}" ]

[ "Channels", "returns", "active", "channels", "." ]

[ "func", "(", "h", "*", "apiExecutor", ")", "Info", "(", "ctx", "context", ".", "Context", ",", "cmd", "*", "InfoRequest", ")", "*", "InfoResponse", "{", "defer", "func", "(", "started", "time", ".", "Time", ")", "{", "apiCommandDurationSummary", ".", "WithLabelValues", "(", "h", ".", "protocol", ",", "\"", "\"", ")", ".", "Observe", "(", "time", ".", "Since", "(", "started", ")", ".", "Seconds", "(", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "resp", ":=", "&", "InfoResponse", "{", "}", "\n\n", "info", ",", "err", ":=", "h", ".", "node", ".", "Info", "(", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "node", ".", "Log", "(", "centrifuge", ".", "NewLogEntry", "(", "centrifuge", ".", "LogLevelError", ",", "\"", "\"", ",", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", "}", ")", ")", "\n", "resp", ".", "Error", "=", "ErrorInternal", "\n", "return", "resp", "\n", "}", "\n\n", "nodes", ":=", "make", "(", "[", "]", "*", "NodeResult", ",", "len", "(", "info", ".", "Nodes", ")", ")", "\n", "for", "i", ",", "nd", ":=", "range", "info", ".", "Nodes", "{", "res", ":=", "&", "NodeResult", "{", "UID", ":", "nd", ".", "UID", ",", "Version", ":", "nd", ".", "Version", ",", "Name", ":", "nd", ".", "Name", ",", "NumClients", ":", "nd", ".", "NumClients", ",", "NumUsers", ":", "nd", ".", "NumUsers", ",", "NumChannels", ":", "nd", ".", "NumChannels", ",", "Uptime", ":", "nd", ".", "Uptime", ",", "}", "\n", "if", "nd", ".", "Metrics", "!=", "nil", "{", "res", ".", "Metrics", "=", "&", "Metrics", "{", "Interval", ":", "nd", ".", "Metrics", ".", "Interval", ",", "Items", ":", "nd", ".", "Metrics", ".", "Items", ",", "}", "\n", "}", "\n", "nodes", "[", "i", "]", "=", "res", "\n", "}", "\n", "resp", ".", "Result", "=", "&", "InfoResult", "{", "Nodes", ":", "nodes", ",", "}", "\n", "return", "resp", "\n", "}" ]

[ "Info", "returns", "information", "about", "running", "nodes", "." ]

[ "func", "generateConfig", "(", "f", "string", ")", "error", "{", "exists", ",", "err", ":=", "pathExists", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "exists", "{", "return", "errors", ".", "New", "(", "\"", "\"", "+", "f", ")", "\n", "}", "\n", "ext", ":=", "filepath", ".", "Ext", "(", "f", ")", "\n\n", "if", "len", "(", "ext", ")", ">", "1", "{", "ext", "=", "ext", "[", "1", ":", "]", "\n", "}", "\n\n", "supportedExts", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n\n", "if", "!", "stringInSlice", "(", "ext", ",", "supportedExts", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", "+", "strings", ".", "Join", "(", "supportedExts", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "var", "t", "*", "template", ".", "Template", "\n\n", "switch", "ext", "{", "case", "\"", "\"", ":", "t", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Parse", "(", "jsonConfigTemplate", ")", "\n", "case", "\"", "\"", ":", "t", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Parse", "(", "tomlConfigTemplate", ")", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "t", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Parse", "(", "yamlConfigTemplate", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "output", "bytes", ".", "Buffer", "\n", "t", ".", "Execute", "(", "&", "output", ",", "struct", "{", "Secret", "string", "\n", "AdminPassword", "string", "\n", "AdminSecret", "string", "\n", "APIKey", "string", "\n", "}", "{", "uuid", ".", "NewV4", "(", ")", ".", "String", "(", ")", ",", "uuid", ".", "NewV4", "(", ")", ".", "String", "(", ")", ",", "uuid", ".", "NewV4", "(", ")", ".", "String", "(", ")", ",", "uuid", ".", "NewV4", "(", ")", ".", "String", "(", ")", ",", "}", ")", "\n\n", "err", "=", "ioutil", ".", "WriteFile", "(", "f", ",", "output", ".", "Bytes", "(", ")", ",", "0644", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "validateConfig", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "_", "=", "os", ".", "Remove", "(", "f", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "generateConfig", "generates", "configuration", "file", "at", "provided", "path", "." ]

[ "func", "validateConfig", "(", "f", "string", ")", "error", "{", "viper", ".", "SetConfigFile", "(", "f", ")", "\n", "err", ":=", "viper", ".", "ReadInConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "switch", "err", ".", "(", "type", ")", "{", "case", "viper", ".", "ConfigParseError", ":", "return", "err", "\n", "default", ":", "return", "errors", ".", "New", "(", "\"", "\\\"", "\"", "+", "f", "+", "\"", "\\\"", "\"", ")", "\n", "}", "\n", "}", "\n", "c", ":=", "nodeConfig", "(", ")", "\n", "return", "c", ".", "Validate", "(", ")", "\n", "}" ]

[ "validateConfig", "validates", "config", "file", "located", "at", "provided", "path", "." ]

[ "func", "applicationName", "(", ")", "string", "{", "v", ":=", "viper", ".", "GetViper", "(", ")", "\n\n", "name", ":=", "v", ".", "GetString", "(", "\"", "\"", ")", "\n", "if", "name", "!=", "\"", "\"", "{", "return", "name", "\n", "}", "\n", "port", ":=", "v", ".", "GetString", "(", "\"", "\"", ")", "\n", "var", "hostname", "string", "\n", "hostname", ",", "err", ":=", "os", ".", "Hostname", "(", ")", "\n", "if", "err", "!=", "nil", "{", "hostname", "=", "\"", "\"", "\n", "}", "\n", "return", "hostname", "+", "\"", "\"", "+", "port", "\n", "}" ]

[ "applicationName", "returns", "a", "name", "for", "this", "centrifuge", ".", "If", "no", "name", "provided", "in", "configuration", "then", "it", "constructs", "node", "name", "based", "on", "hostname", "and", "port" ]

[ "func", "namespacesFromConfig", "(", "v", "*", "viper", ".", "Viper", ")", "[", "]", "centrifuge", ".", "ChannelNamespace", "{", "ns", ":=", "[", "]", "centrifuge", ".", "ChannelNamespace", "{", "}", "\n", "if", "!", "v", ".", "IsSet", "(", "\"", "\"", ")", "{", "return", "ns", "\n", "}", "\n", "v", ".", "UnmarshalKey", "(", "\"", "\"", ",", "&", "ns", ")", "\n", "return", "ns", "\n", "}" ]

[ "namespacesFromConfig", "allows", "to", "unmarshal", "channel", "namespaces", "." ]

[ "func", "Mux", "(", "n", "*", "centrifuge", ".", "Node", ",", "flags", "HandlerFlag", ")", "*", "http", ".", "ServeMux", "{", "mux", ":=", "http", ".", "NewServeMux", "(", ")", "\n\n", "if", "flags", "&", "HandlerDebug", "!=", "0", "{", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "http", ".", "HandlerFunc", "(", "pprof", ".", "Index", ")", ")", ")", "\n", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "http", ".", "HandlerFunc", "(", "pprof", ".", "Cmdline", ")", ")", ")", "\n", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "http", ".", "HandlerFunc", "(", "pprof", ".", "Profile", ")", ")", ")", "\n", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "http", ".", "HandlerFunc", "(", "pprof", ".", "Symbol", ")", ")", ")", "\n", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "http", ".", "HandlerFunc", "(", "pprof", ".", "Trace", ")", ")", ")", "\n", "}", "\n\n", "if", "flags", "&", "HandlerWebsocket", "!=", "0", "{", "// register Websocket connection endpoint.", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "centrifuge", ".", "NewWebsocketHandler", "(", "n", ",", "websocketHandlerConfig", "(", ")", ")", ")", ")", "\n", "}", "\n\n", "if", "flags", "&", "HandlerSockJS", "!=", "0", "{", "// register SockJS connection endpoints.", "sockjsConfig", ":=", "sockjsHandlerConfig", "(", ")", "\n", "sockjsConfig", ".", "HandlerPrefix", "=", "\"", "\"", "\n", "mux", ".", "Handle", "(", "sockjsConfig", ".", "HandlerPrefix", "+", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "centrifuge", ".", "NewSockjsHandler", "(", "n", ",", "sockjsConfig", ")", ")", ")", "\n", "}", "\n\n", "if", "flags", "&", "HandlerAPI", "!=", "0", "{", "// register HTTP API endpoint.", "apiHandler", ":=", "api", ".", "NewHandler", "(", "n", ",", "api", ".", "Config", "{", "}", ")", "\n", "if", "viper", ".", "GetBool", "(", "\"", "\"", ")", "{", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "apiHandler", ")", ")", "\n", "}", "else", "{", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "middleware", ".", "APIKeyAuth", "(", "viper", ".", "GetString", "(", "\"", "\"", ")", ",", "apiHandler", ")", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "flags", "&", "HandlerPrometheus", "!=", "0", "{", "// register Prometheus metrics export endpoint.", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "promhttp", ".", "Handler", "(", ")", ")", ")", "\n", "}", "\n\n", "if", "flags", "&", "HandlerAdmin", "!=", "0", "{", "// register admin web interface API endpoints.", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "admin", ".", "NewHandler", "(", "n", ",", "adminHandlerConfig", "(", ")", ")", ")", ")", "\n", "}", "else", "{", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "http", ".", "HandlerFunc", "(", "notFoundHandler", ")", ")", ")", "\n", "}", "\n\n", "if", "flags", "&", "HandlerHealth", "!=", "0", "{", "mux", ".", "Handle", "(", "\"", "\"", ",", "middleware", ".", "LogRequest", "(", "health", ".", "NewHandler", "(", "n", ",", "health", ".", "Config", "{", "}", ")", ")", ")", "\n", "}", "\n\n", "return", "mux", "\n", "}" ]

[ "Mux", "returns", "a", "mux", "including", "set", "of", "default", "handlers", "for", "Centrifugo", "server", "." ]

[ "func", "PreparePathComponent", "(", "s", "string", ")", "string", "{", "s", "=", "re", ".", "ReplaceAllLiteralString", "(", "s", ",", "\"", "\"", ")", "\n", "return", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "}" ]

[ "PreparePathComponent", "cleans", "string", "to", "be", "used", "as", "Graphite", "metric", "path", "." ]

[ "func", "New", "(", "c", "Config", ")", "*", "Exporter", "{", "exporter", ":=", "&", "Exporter", "{", "prefix", ":", "c", ".", "Prefix", ",", "address", ":", "c", ".", "Address", ",", "timeout", ":", "time", ".", "Second", ",", "tags", ":", "c", ".", "Tags", ",", "closeCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "sink", ":", "make", "(", "chan", "eagle", ".", "Metrics", ")", ",", "}", "\n", "exporter", ".", "eagle", "=", "eagle", ".", "New", "(", "eagle", ".", "Config", "{", "Gatherer", ":", "c", ".", "Gatherer", ",", "Interval", ":", "c", ".", "Interval", ",", "Sink", ":", "exporter", ".", "sink", ",", "}", ")", "\n", "go", "exporter", ".", "run", "(", ")", "\n", "return", "exporter", "\n", "}" ]

[ "New", "creates", "new", "Graphite", "Exporter", "." ]

[ "func", "(", "e", "*", "Exporter", ")", "Close", "(", ")", "error", "{", "e", ".", "closeOnce", ".", "Do", "(", "func", "(", ")", "{", "close", "(", "e", ".", "closeCh", ")", "\n", "e", ".", "eagle", ".", "Close", "(", ")", "\n", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "Close", "stops", "exporter", "." ]

[ "func", "NewRadioButtons", "(", "options", "[", "]", "string", ")", "*", "RadioButtons", "{", "return", "&", "RadioButtons", "{", "Box", ":", "tview", ".", "NewBox", "(", ")", ",", "options", ":", "options", ",", "}", "\n", "}" ]

[ "NewRadioButtons", "returns", "a", "new", "radio", "button", "primitive", "." ]

[ "func", "NewBox", "(", ")", "*", "Box", "{", "b", ":=", "&", "Box", "{", "width", ":", "15", ",", "height", ":", "10", ",", "innerX", ":", "-", "1", ",", "// Mark as uninitialized.", "backgroundColor", ":", "Styles", ".", "PrimitiveBackgroundColor", ",", "borderColor", ":", "Styles", ".", "BorderColor", ",", "titleColor", ":", "Styles", ".", "TitleColor", ",", "titleAlign", ":", "AlignCenter", ",", "}", "\n", "b", ".", "focus", "=", "b", "\n", "return", "b", "\n", "}" ]

[ "NewBox", "returns", "a", "Box", "without", "a", "border", "." ]

[ "func", "(", "b", "*", "Box", ")", "SetBorderPadding", "(", "top", ",", "bottom", ",", "left", ",", "right", "int", ")", "*", "Box", "{", "b", ".", "paddingTop", ",", "b", ".", "paddingBottom", ",", "b", ".", "paddingLeft", ",", "b", ".", "paddingRight", "=", "top", ",", "bottom", ",", "left", ",", "right", "\n", "return", "b", "\n", "}" ]

[ "SetBorderPadding", "sets", "the", "size", "of", "the", "borders", "around", "the", "box", "content", "." ]

[ "func", "(", "b", "*", "Box", ")", "GetRect", "(", ")", "(", "int", ",", "int", ",", "int", ",", "int", ")", "{", "return", "b", ".", "x", ",", "b", ".", "y", ",", "b", ".", "width", ",", "b", ".", "height", "\n", "}" ]

[ "GetRect", "returns", "the", "current", "position", "of", "the", "rectangle", "x", "y", "width", "and", "height", "." ]

[ "func", "(", "b", "*", "Box", ")", "InputHandler", "(", ")", "func", "(", "event", "*", "tcell", ".", "EventKey", ",", "setFocus", "func", "(", "p", "Primitive", ")", ")", "{", "return", "b", ".", "WrapInputHandler", "(", "nil", ")", "\n", "}" ]

[ "InputHandler", "returns", "nil", "." ]

[ "func", "(", "b", "*", "Box", ")", "SetBackgroundColor", "(", "color", "tcell", ".", "Color", ")", "*", "Box", "{", "b", ".", "backgroundColor", "=", "color", "\n", "return", "b", "\n", "}" ]

[ "SetBackgroundColor", "sets", "the", "box", "s", "background", "color", "." ]

[ "func", "(", "b", "*", "Box", ")", "SetBorder", "(", "show", "bool", ")", "*", "Box", "{", "b", ".", "border", "=", "show", "\n", "return", "b", "\n", "}" ]

[ "SetBorder", "sets", "the", "flag", "indicating", "whether", "or", "not", "the", "box", "should", "have", "a", "border", "." ]