Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "h", "*", "Handler", ")", "passUpstream", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "cacheRequest", ")", "{", "rw", ":=", "newResponseStreamer", "(", "w", ")", "\n", "rdr", ",", "err", ":=", "rw", ".", "Stream", ".", "NextReader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "debugf", "(", "\"", "\"", ",", "err", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "CacheHeader", ",", "\"", "\"", ")", "\n", "h", ".", "upstream", ".", "ServeHTTP", "(", "w", ",", "r", ".", "Request", ")", "\n", "return", "\n", "}", "\n\n", "t", ":=", "Clock", "(", ")", "\n", "debugf", "(", "\"", "\"", ")", "\n", "rw", ".", "Header", "(", ")", ".", "Set", "(", "CacheHeader", ",", "\"", "\"", ")", "\n\n", "go", "func", "(", ")", "{", "h", ".", "upstream", ".", "ServeHTTP", "(", "rw", ",", "r", ".", "Request", ")", "\n", "rw", ".", "Stream", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "rw", ".", "WaitHeaders", "(", ")", "\n", "debugf", "(", "\"", "\"", ",", "Clock", "(", ")", ".", "Sub", "(", "t", ")", ".", "String", "(", ")", ")", "\n\n", "// just the headers!", "res", ":=", "NewResourceBytes", "(", "rw", ".", "StatusCode", ",", "nil", ",", "rw", ".", "Header", "(", ")", ")", "\n", "if", "!", "h", ".", "isCacheable", "(", "res", ",", "r", ")", "{", "rdr", ".", "Close", "(", ")", "\n", "debugf", "(", "\"", "\"", ")", "\n", "rw", ".", "Header", "(", ")", ".", "Set", "(", "CacheHeader", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "b", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "rdr", ")", "\n", "rdr", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "debugf", "(", "\"", "\"", ",", "err", ")", "\n", "rw", ".", "Header", "(", ")", ".", "Set", "(", "CacheHeader", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "debugf", "(", "\"", "\"", ",", "Clock", "(", ")", ".", "Sub", "(", "t", ")", ".", "String", "(", ")", ")", "\n", "res", ".", "ReadSeekCloser", "=", "&", "byteReadSeekCloser", "{", "bytes", ".", "NewReader", "(", "b", ")", "}", "\n\n", "if", "age", ",", "err", ":=", "correctedAge", "(", "res", ".", "Header", "(", ")", ",", "t", ",", "Clock", "(", ")", ")", ";", "err", "==", "nil", "{", "res", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "int", "(", "math", ".", "Ceil", "(", "age", ".", "Seconds", "(", ")", ")", ")", ")", ")", "\n", "}", "else", "{", "debugf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "rw", ".", "Header", "(", ")", ".", "Set", "(", "ProxyDateHeader", ",", "Clock", "(", ")", ".", "Format", "(", "http", ".", "TimeFormat", ")", ")", "\n", "h", ".", "storeResource", "(", "res", ",", "r", ")", "\n", "}" ]

[ "passUpstream", "makes", "the", "request", "via", "the", "upstream", "handler", "and", "stores", "the", "result" ]

[ "func", "(", "h", "*", "Handler", ")", "lookup", "(", "req", "*", "cacheRequest", ")", "(", "*", "Resource", ",", "error", ")", "{", "res", ",", "err", ":=", "h", ".", "cache", ".", "Retrieve", "(", "req", ".", "Key", ".", "String", "(", ")", ")", "\n\n", "// HEAD requests can possibly be served from GET", "if", "err", "==", "ErrNotFoundInCache", "&&", "req", ".", "Method", "==", "\"", "\"", "{", "res", ",", "err", "=", "h", ".", "cache", ".", "Retrieve", "(", "req", ".", "Key", ".", "ForMethod", "(", "\"", "\"", ")", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "res", ".", "HasExplicitExpiration", "(", ")", "&&", "req", ".", "isCacheable", "(", ")", "{", "debugf", "(", "\"", "\"", ")", "\n", "return", "res", ",", "nil", "\n", "}", "else", "{", "return", "nil", ",", "ErrNotFoundInCache", "\n", "}", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// Secondary lookup for Vary", "if", "vary", ":=", "res", ".", "Header", "(", ")", ".", "Get", "(", "\"", "\"", ")", ";", "vary", "!=", "\"", "\"", "{", "res", ",", "err", "=", "h", ".", "cache", ".", "Retrieve", "(", "req", ".", "Key", ".", "Vary", "(", "vary", ",", "req", ".", "Request", ")", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "lookupResource", "finds", "the", "best", "matching", "Resource", "for", "the", "request", "or", "nil", "and", "ErrNotFoundInCache", "if", "none", "is", "found" ]

[ "func", "(", "rw", "*", "responseStreamer", ")", "Resource", "(", ")", "*", "Resource", "{", "r", ",", "err", ":=", "rw", ".", "Stream", ".", "NextReader", "(", ")", "\n", "if", "err", "==", "nil", "{", "b", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ")", "\n", "r", ".", "Close", "(", ")", "\n", "if", "err", "==", "nil", "{", "return", "NewResourceBytes", "(", "rw", ".", "StatusCode", ",", "b", ",", "rw", ".", "Header", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "&", "Resource", "{", "header", ":", "rw", ".", "Header", "(", ")", ",", "statusCode", ":", "rw", ".", "StatusCode", ",", "ReadSeekCloser", ":", "errReadSeekCloser", "{", "err", "}", ",", "}", "\n", "}" ]

[ "Resource", "returns", "a", "copy", "of", "the", "responseStreamer", "as", "a", "Resource", "object" ]

[ "func", "(", "r", "*", "Resource", ")", "Age", "(", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "var", "age", "time", ".", "Duration", "\n\n", "if", "ageInt", ",", "err", ":=", "intHeader", "(", "\"", "\"", ",", "r", ".", "header", ")", ";", "err", "==", "nil", "{", "age", "=", "time", ".", "Second", "*", "time", ".", "Duration", "(", "ageInt", ")", "\n", "}", "\n\n", "if", "proxyDate", ",", "err", ":=", "timeHeader", "(", "ProxyDateHeader", ",", "r", ".", "header", ")", ";", "err", "==", "nil", "{", "return", "Clock", "(", ")", ".", "Sub", "(", "proxyDate", ")", "+", "age", ",", "nil", "\n", "}", "\n\n", "if", "date", ",", "err", ":=", "timeHeader", "(", "\"", "\"", ",", "r", ".", "header", ")", ";", "err", "==", "nil", "{", "return", "Clock", "(", ")", ".", "Sub", "(", "date", ")", "+", "age", ",", "nil", "\n", "}", "\n\n", "return", "time", ".", "Duration", "(", "0", ")", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Calculate", "the", "age", "of", "the", "resource" ]

[ "func", "NewKey", "(", "method", "string", ",", "u", "*", "url", ".", "URL", ",", "h", "http", ".", "Header", ")", "Key", "{", "return", "Key", "{", "method", ":", "method", ",", "header", ":", "h", ",", "u", ":", "*", "u", ",", "vary", ":", "[", "]", "string", "{", "}", "}", "\n", "}" ]

[ "NewKey", "returns", "a", "new", "Key", "instance" ]

[ "func", "NewRequestKey", "(", "r", "*", "http", ".", "Request", ")", "Key", "{", "URL", ":=", "r", ".", "URL", "\n\n", "if", "location", ":=", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ";", "location", "!=", "\"", "\"", "{", "u", ",", "err", ":=", "url", ".", "Parse", "(", "location", ")", "\n", "if", "err", "==", "nil", "{", "if", "!", "u", ".", "IsAbs", "(", ")", "{", "u", "=", "r", ".", "URL", ".", "ResolveReference", "(", "u", ")", "\n", "}", "\n", "if", "u", ".", "Host", "!=", "r", ".", "Host", "{", "debugf", "(", "\"", "\"", ",", "u", ".", "Host", ")", "\n", "}", "else", "{", "debugf", "(", "\"", "\"", ",", "u", ".", "String", "(", ")", ")", "\n", "URL", "=", "u", "\n", "}", "\n", "}", "else", "{", "debugf", "(", "\"", "\"", ",", "location", ")", "\n", "}", "\n", "}", "\n\n", "return", "NewKey", "(", "r", ".", "Method", ",", "URL", ",", "r", ".", "Header", ")", "\n", "}" ]

[ "NewRequestKey", "generates", "a", "Key", "for", "a", "request" ]

[ "func", "(", "k", "Key", ")", "ForMethod", "(", "method", "string", ")", "Key", "{", "k2", ":=", "k", "\n", "k2", ".", "method", "=", "method", "\n", "return", "k2", "\n", "}" ]

[ "ForMethod", "returns", "a", "new", "Key", "with", "a", "given", "method" ]

[ "func", "(", "k", "Key", ")", "Vary", "(", "varyHeader", "string", ",", "r", "*", "http", ".", "Request", ")", "Key", "{", "k2", ":=", "k", "\n\n", "for", "_", ",", "header", ":=", "range", "strings", ".", "Split", "(", "varyHeader", ",", "\"", "\"", ")", "{", "k2", ".", "vary", "=", "append", "(", "k2", ".", "vary", ",", "header", "+", "\"", "\"", "+", "r", ".", "Header", ".", "Get", "(", "header", ")", ")", "\n", "}", "\n\n", "return", "k2", "\n", "}" ]

[ "Vary", "returns", "a", "Key", "that", "is", "varied", "on", "particular", "headers", "in", "a", "http", ".", "Request" ]

[ "func", "WithForwardedHeaders", "(", "fn", "func", "(", "header", "string", ")", "bool", ")", "Option", "{", "return", "func", "(", "p", "*", "Proxy", ")", "{", "p", ".", "headerForwarder", "=", "fn", "\n", "}", "\n", "}" ]

[ "WithForwardedHeaders", "allows", "controlling", "which", "headers", "are", "forwarded", "." ]

[ "func", "transformSubProtocolHeader", "(", "header", "string", ")", "string", "{", "tokens", ":=", "strings", ".", "SplitN", "(", "header", ",", "\"", "\"", ",", "2", ")", "\n\n", "if", "len", "(", "tokens", ")", "<", "2", "{", "return", "\"", "\"", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "Trim", "(", "tokens", "[", "1", "]", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "IE", "and", "Edge", "do", "not", "delimit", "Sec", "-", "WebSocket", "-", "Protocol", "strings", "with", "spaces" ]

[ "func", "(", "w", "*", "worker", ")", "start", "(", ")", "{", "go", "func", "(", ")", "{", "for", "job", ":=", "range", "w", ".", "jobs", "{", "w", ".", "doJob", "(", "job", ")", "\n", "}", "\n", "w", ".", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n", "}" ]

[ "start", "starts", "a", "goroutine", "in", "which", "the", "worker", "will", "continuously", "execute", "jobs", "until", "the", "jobs", "channel", "is", "closed", "." ]

[ "func", "(", "w", "*", "worker", ")", "doJob", "(", "job", "*", "Job", ")", "{", "if", "w", ".", "afterFunc", "!=", "nil", "{", "defer", "w", ".", "afterFunc", "(", "job", ")", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "// Get a reasonable error message from the panic", "msg", ":=", "\"", "\"", "\n", "if", "err", ",", "ok", ":=", "r", ".", "(", "error", ")", ";", "ok", "{", "msg", "=", "err", ".", "Error", "(", ")", "\n", "}", "else", "{", "msg", "=", "fmt", ".", "Sprint", "(", "r", ")", "\n", "}", "\n", "if", "err", ":=", "setJobError", "(", "job", ",", "msg", ")", ";", "err", "!=", "nil", "{", "// Nothing left to do but panic", "panic", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "// Set the started field and save the job", "job", ".", "started", "=", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "UnixNano", "(", ")", "\n", "t0", ":=", "newTransaction", "(", ")", "\n", "t0", ".", "setJobField", "(", "job", ",", "\"", "\"", ",", "job", ".", "started", ")", "\n", "if", "err", ":=", "t0", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "if", "err", ":=", "setJobError", "(", "job", ",", "err", ".", "Error", "(", ")", ")", ";", "err", "!=", "nil", "{", "// NOTE: panics will be caught by the recover statment above", "panic", "(", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "// Use reflection to instantiate arguments for the handler", "handlerArgs", ":=", "[", "]", "reflect", ".", "Value", "{", "}", "\n", "if", "job", ".", "typ", ".", "dataType", "!=", "nil", "{", "// Instantiate a new variable to hold this argument", "dataVal", ":=", "reflect", ".", "New", "(", "job", ".", "typ", ".", "dataType", ")", "\n", "if", "err", ":=", "decode", "(", "job", ".", "data", ",", "dataVal", ".", "Interface", "(", ")", ")", ";", "err", "!=", "nil", "{", "if", "err", ":=", "setJobError", "(", "job", ",", "err", ".", "Error", "(", ")", ")", ";", "err", "!=", "nil", "{", "// NOTE: panics will be caught by the recover statment above", "panic", "(", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "handlerArgs", "=", "append", "(", "handlerArgs", ",", "dataVal", ".", "Elem", "(", ")", ")", "\n", "}", "\n", "// Call the handler using the arguments we just instantiated", "handlerVal", ":=", "reflect", ".", "ValueOf", "(", "job", ".", "typ", ".", "handler", ")", "\n", "returnVals", ":=", "handlerVal", ".", "Call", "(", "handlerArgs", ")", "\n", "// Set the finished timestamp", "job", ".", "finished", "=", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "UnixNano", "(", ")", "\n\n", "// Check if the error return value was nil", "if", "!", "returnVals", "[", "0", "]", ".", "IsNil", "(", ")", "{", "err", ":=", "returnVals", "[", "0", "]", ".", "Interface", "(", ")", ".", "(", "error", ")", "\n", "if", "err", ":=", "setJobError", "(", "job", ",", "err", ".", "Error", "(", ")", ")", ";", "err", "!=", "nil", "{", "// NOTE: panics will be caught by the recover statment above", "panic", "(", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "t1", ":=", "newTransaction", "(", ")", "\n", "t1", ".", "setJobField", "(", "job", ",", "\"", "\"", ",", "job", ".", "finished", ")", "\n", "if", "job", ".", "IsRecurring", "(", ")", "{", "// If the job is recurring, reschedule and set status to queued", "job", ".", "time", "=", "job", ".", "NextTime", "(", ")", "\n", "t1", ".", "setJobField", "(", "job", ",", "\"", "\"", ",", "job", ".", "time", ")", "\n", "t1", ".", "addJobToTimeIndex", "(", "job", ")", "\n", "t1", ".", "setStatus", "(", "job", ",", "StatusQueued", ")", "\n", "}", "else", "{", "// Otherwise, set status to finished", "t1", ".", "setStatus", "(", "job", ",", "StatusFinished", ")", "\n", "}", "\n", "if", "err", ":=", "t1", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "if", "err", ":=", "setJobError", "(", "job", ",", "err", ".", "Error", "(", ")", ")", ";", "err", "!=", "nil", "{", "// NOTE: panics will be caught by the recover statment above", "panic", "(", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "}" ]

[ "doJob", "executes", "the", "given", "job", ".", "It", "also", "sets", "the", "status", "and", "timestamps", "for", "the", "job", "appropriately", "depending", "on", "the", "outcome", "of", "the", "execution", "." ]

[ "func", "generateRandomId", "(", ")", "string", "{", "timeInt", ":=", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", "\n", "timeString", ":=", "strconv", ".", "FormatInt", "(", "timeInt", ",", "36", ")", "\n", "randomString", ":=", "uniuri", ".", "NewLen", "(", "16", ")", "\n", "return", "randomString", "+", "timeString", "\n", "}" ]

[ "generateRandomId", "generates", "a", "random", "string", "that", "is", "more", "or", "less", "garunteed", "to", "be", "unique", "." ]

[ "func", "(", "j", "*", "Job", ")", "save", "(", ")", "error", "{", "t", ":=", "newTransaction", "(", ")", "\n", "t", ".", "saveJob", "(", "j", ")", "\n", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "save", "writes", "the", "job", "to", "the", "database", "and", "adds", "it", "to", "the", "appropriate", "indexes", "and", "status", "sets", "but", "does", "not", "enqueue", "it", ".", "If", "you", "want", "to", "add", "it", "to", "the", "queue", "use", "the", "enqueue", "method", "after", "save", "." ]

[ "func", "(", "t", "*", "transaction", ")", "saveJob", "(", "job", "*", "Job", ")", "{", "// Generate id if needed", "if", "job", ".", "id", "==", "\"", "\"", "{", "job", ".", "id", "=", "generateRandomId", "(", ")", "\n", "}", "\n", "// Set status to saved if needed", "if", "job", ".", "status", "==", "\"", "\"", "{", "job", ".", "status", "=", "StatusSaved", "\n", "}", "\n", "// Add the job attributes to a hash", "t", ".", "command", "(", "\"", "\"", ",", "job", ".", "mainHashArgs", "(", ")", ",", "nil", ")", "\n", "// Add the job to the appropriate status set", "t", ".", "setStatus", "(", "job", ",", "job", ".", "status", ")", "\n", "// Add the job to the time index", "t", ".", "addJobToTimeIndex", "(", "job", ")", "\n", "}" ]

[ "saveJob", "adds", "commands", "to", "the", "transaction", "to", "set", "all", "the", "fields", "for", "the", "main", "hash", "for", "the", "job", "add", "the", "job", "to", "the", "time", "index", "move", "the", "job", "to", "the", "appropriate", "status", "set", ".", "It", "will", "also", "mutate", "the", "job", "by", "1", ")", "generating", "an", "id", "if", "the", "id", "is", "empty", "and", "2", ")", "setting", "the", "status", "to", "StatusSaved", "if", "the", "status", "is", "empty", "." ]

[ "func", "(", "t", "*", "transaction", ")", "addJobToTimeIndex", "(", "job", "*", "Job", ")", "{", "t", ".", "addJobToSet", "(", "job", ",", "Keys", ".", "JobsTimeIndex", ",", "float64", "(", "job", ".", "time", ")", ")", "\n", "}" ]

[ "addJobToTimeIndex", "adds", "commands", "to", "the", "transaction", "which", "will", "when", "executed", "add", "the", "job", "id", "to", "the", "time", "index", "with", "a", "score", "equal", "to", "the", "job", "s", "time", "field", ".", "If", "the", "job", "has", "been", "destroyed", "addJobToTimeIndex", "will", "have", "no", "effect", "." ]

[ "func", "(", "j", "*", "Job", ")", "Refresh", "(", ")", "error", "{", "t", ":=", "newTransaction", "(", ")", "\n", "t", ".", "scanJobById", "(", "j", ".", "id", ",", "j", ")", "\n", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Refresh", "mutates", "the", "job", "by", "setting", "its", "fields", "to", "the", "most", "recent", "data", "found", "in", "the", "database", ".", "It", "returns", "an", "error", "if", "there", "was", "a", "problem", "connecting", "to", "the", "database", "or", "if", "the", "job", "was", "destroyed", "." ]

[ "func", "(", "j", "*", "Job", ")", "enqueue", "(", ")", "error", "{", "if", "err", ":=", "j", ".", "setStatus", "(", "StatusQueued", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "enqueue", "adds", "the", "job", "to", "the", "queue", "and", "sets", "its", "status", "to", "StatusQueued", ".", "Queued", "jobs", "will", "be", "completed", "by", "workers", "in", "order", "of", "priority", ".", "Attempting", "to", "enqueue", "a", "destroyed", "job", "will", "have", "no", "effect", "." ]

[ "func", "(", "j", "*", "Job", ")", "Reschedule", "(", "time", "time", ".", "Time", ")", "error", "{", "t", ":=", "newTransaction", "(", ")", "\n", "unixNanoTime", ":=", "time", ".", "UTC", "(", ")", ".", "UnixNano", "(", ")", "\n", "t", ".", "setJobField", "(", "j", ",", "\"", "\"", ",", "unixNanoTime", ")", "\n", "t", ".", "setStatus", "(", "j", ",", "StatusQueued", ")", "\n", "j", ".", "time", "=", "unixNanoTime", "\n", "t", ".", "addJobToTimeIndex", "(", "j", ")", "\n", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "j", ".", "status", "=", "StatusQueued", "\n", "return", "nil", "\n", "}" ]

[ "Reschedule", "reschedules", "the", "job", "with", "the", "given", "time", ".", "It", "can", "be", "used", "to", "reschedule", "cancelled", "jobs", ".", "It", "may", "also", "be", "used", "to", "reschedule", "finished", "or", "failed", "jobs", "however", "in", "most", "cases", "if", "you", "want", "to", "reschedule", "finished", "jobs", "you", "should", "use", "the", "ScheduleRecurring", "method", "and", "if", "you", "want", "to", "reschedule", "failed", "jobs", "you", "should", "set", "the", "number", "of", "retries", ">", "0", "when", "registering", "the", "job", "type", ".", "Attempting", "to", "reschedule", "a", "destroyed", "job", "will", "have", "no", "effect", ".", "Reschedule", "returns", "an", "error", "if", "there", "was", "a", "problem", "connecting", "to", "the", "database", "." ]

[ "func", "(", "j", "*", "Job", ")", "Cancel", "(", ")", "error", "{", "if", "err", ":=", "j", ".", "setStatus", "(", "StatusCancelled", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Cancel", "cancels", "the", "job", "but", "does", "not", "remove", "it", "from", "the", "database", ".", "It", "will", "be", "added", "to", "a", "list", "of", "cancelled", "jobs", ".", "If", "you", "wish", "to", "remove", "it", "from", "the", "database", "use", "the", "Destroy", "method", ".", "Attempting", "to", "cancel", "a", "destroyed", "job", "will", "have", "no", "effect", "." ]

[ "func", "(", "j", "*", "Job", ")", "setError", "(", "err", "error", ")", "error", "{", "j", ".", "err", "=", "err", "\n", "t", ":=", "newTransaction", "(", ")", "\n", "t", ".", "setJobField", "(", "j", ",", "\"", "\"", ",", "j", ".", "err", ".", "Error", "(", ")", ")", "\n", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setError", "sets", "the", "err", "property", "of", "j", "and", "adds", "it", "to", "the", "set", "of", "jobs", "which", "had", "errors", ".", "If", "the", "job", "has", "been", "destroyed", "setError", "will", "have", "no", "effect", "." ]

[ "func", "(", "j", "*", "Job", ")", "Destroy", "(", ")", "error", "{", "if", "j", ".", "id", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// Start a new transaction", "t", ":=", "newTransaction", "(", ")", "\n", "// Call the script to destroy the job", "t", ".", "destroyJob", "(", "j", ")", "\n", "// Execute the transaction", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "j", ".", "status", "=", "StatusDestroyed", "\n", "return", "nil", "\n", "}" ]

[ "Destroy", "removes", "all", "traces", "of", "the", "job", "from", "the", "database", ".", "If", "the", "job", "is", "currently", "being", "executed", "by", "a", "worker", "the", "worker", "may", "still", "finish", "the", "job", ".", "Attempting", "to", "destroy", "a", "job", "that", "has", "already", "been", "destroyed", "will", "have", "no", "effect", "so", "it", "is", "safe", "to", "call", "Destroy", "multiple", "times", "." ]

[ "func", "(", "j", "*", "Job", ")", "setStatus", "(", "status", "Status", ")", "error", "{", "if", "j", ".", "id", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "status", ")", "\n", "}", "\n", "if", "j", ".", "status", "==", "StatusDestroyed", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "j", ".", "id", ",", "status", ")", "\n", "}", "\n", "// Use a transaction to move the job to the appropriate status set and set its status", "t", ":=", "newTransaction", "(", ")", "\n", "t", ".", "setStatus", "(", "j", ",", "status", ")", "\n", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "j", ".", "status", "=", "status", "\n", "return", "nil", "\n", "}" ]

[ "setStatus", "updates", "the", "job", "s", "status", "in", "the", "database", "and", "moves", "it", "to", "the", "appropriate", "status", "set", ".", "Attempting", "to", "set", "the", "status", "of", "a", "job", "which", "has", "been", "destroyed", "will", "have", "no", "effect", "." ]

[ "func", "(", "j", "*", "Job", ")", "mainHashArgs", "(", ")", "[", "]", "interface", "{", "}", "{", "hashArgs", ":=", "[", "]", "interface", "{", "}", "{", "j", ".", "Key", "(", ")", ",", "\"", "\"", ",", "string", "(", "j", ".", "data", ")", ",", "\"", "\"", ",", "j", ".", "typ", ".", "name", ",", "\"", "\"", ",", "j", ".", "time", ",", "\"", "\"", ",", "j", ".", "freq", ",", "\"", "\"", ",", "j", ".", "priority", ",", "\"", "\"", ",", "j", ".", "retries", ",", "\"", "\"", ",", "j", ".", "status", ",", "\"", "\"", ",", "j", ".", "started", ",", "\"", "\"", ",", "j", ".", "finished", ",", "\"", "\"", ",", "j", ".", "poolId", ",", "}", "\n", "if", "j", ".", "err", "!=", "nil", "{", "hashArgs", "=", "append", "(", "hashArgs", ",", "\"", "\"", ",", "j", ".", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "hashArgs", "\n", "}" ]

[ "mainHashArgs", "returns", "the", "args", "for", "the", "hash", "which", "will", "store", "the", "job", "data" ]

[ "func", "scanJob", "(", "reply", "interface", "{", "}", ",", "job", "*", "Job", ")", "error", "{", "fields", ",", "err", ":=", "redis", ".", "Values", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "len", "(", "fields", ")", "==", "0", "{", "return", "ErrorJobNotFound", "{", "}", "\n", "}", "else", "if", "len", "(", "fields", ")", "%", "2", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "fields", ")", ")", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "fields", ")", "-", "1", ";", "i", "+=", "2", "{", "fieldName", ",", "err", ":=", "redis", ".", "String", "(", "fields", "[", "i", "]", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ",", "fields", "[", "i", "]", ",", "fields", "[", "i", "]", ")", "\n", "}", "\n", "fieldValue", ":=", "fields", "[", "i", "+", "1", "]", "\n", "switch", "fieldName", "{", "case", "\"", "\"", ":", "if", "err", ":=", "scanString", "(", "fieldValue", ",", "&", "(", "job", ".", "id", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanBytes", "(", "fieldValue", ",", "&", "(", "job", ".", "data", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "typeName", ":=", "\"", "\"", "\n", "if", "err", ":=", "scanString", "(", "fieldValue", ",", "&", "typeName", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "Type", ",", "found", ":=", "Types", "[", "typeName", "]", "\n", "if", "!", "found", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "typeName", ")", "\n", "}", "\n", "job", ".", "typ", "=", "Type", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanInt64", "(", "fieldValue", ",", "&", "(", "job", ".", "time", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanInt64", "(", "fieldValue", ",", "&", "(", "job", ".", "freq", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanInt", "(", "fieldValue", ",", "&", "(", "job", ".", "priority", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanUint", "(", "fieldValue", ",", "&", "(", "job", ".", "retries", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "status", ":=", "\"", "\"", "\n", "if", "err", ":=", "scanString", "(", "fieldValue", ",", "&", "status", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "job", ".", "status", "=", "Status", "(", "status", ")", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanInt64", "(", "fieldValue", ",", "&", "(", "job", ".", "started", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanInt64", "(", "fieldValue", ",", "&", "(", "job", ".", "finished", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "if", "err", ":=", "scanString", "(", "fieldValue", ",", "&", "(", "job", ".", "poolId", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "scanJob", "scans", "the", "values", "of", "reply", "into", "job", ".", "reply", "should", "be", "the", "response", "of", "an", "HMGET", "or", "HGETALL", "query", "." ]

[ "func", "scanInt", "(", "reply", "interface", "{", "}", ",", "v", "*", "int", ")", "error", "{", "if", "v", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "val", ",", "err", ":=", "redis", ".", "Int", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reply", ",", "reply", ")", "\n", "}", "\n", "(", "*", "v", ")", "=", "val", "\n", "return", "nil", "\n", "}" ]

[ "scanInt", "converts", "a", "reply", "from", "redis", "into", "an", "int", "and", "scans", "the", "value", "into", "v", "." ]

[ "func", "scanUint", "(", "reply", "interface", "{", "}", ",", "v", "*", "uint", ")", "error", "{", "if", "v", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "val", ",", "err", ":=", "redis", ".", "Uint64", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reply", ",", "reply", ")", "\n", "}", "\n", "(", "*", "v", ")", "=", "uint", "(", "val", ")", "\n", "return", "nil", "\n", "}" ]

[ "scanUint", "converts", "a", "reply", "from", "redis", "into", "a", "uint", "and", "scans", "the", "value", "into", "v", "." ]

[ "func", "scanInt64", "(", "reply", "interface", "{", "}", ",", "v", "*", "int64", ")", "error", "{", "if", "v", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "val", ",", "err", ":=", "redis", ".", "Int64", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reply", ",", "reply", ")", "\n", "}", "\n", "(", "*", "v", ")", "=", "val", "\n", "return", "nil", "\n", "}" ]

[ "scanInt64", "converts", "a", "reply", "from", "redis", "into", "an", "int64", "and", "scans", "the", "value", "into", "v", "." ]

[ "func", "scanString", "(", "reply", "interface", "{", "}", ",", "v", "*", "string", ")", "error", "{", "if", "v", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "val", ",", "err", ":=", "redis", ".", "String", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reply", ",", "reply", ")", "\n", "}", "\n", "(", "*", "v", ")", "=", "val", "\n", "return", "nil", "\n", "}" ]

[ "scanString", "converts", "a", "reply", "from", "redis", "into", "a", "string", "and", "scans", "the", "value", "into", "v", "." ]

[ "func", "scanBytes", "(", "reply", "interface", "{", "}", ",", "v", "*", "[", "]", "byte", ")", "error", "{", "if", "v", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "val", ",", "err", ":=", "redis", ".", "Bytes", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reply", ",", "reply", ")", "\n", "}", "\n", "(", "*", "v", ")", "=", "val", "\n", "return", "nil", "\n", "}" ]

[ "scanBytes", "converts", "a", "reply", "from", "redis", "into", "a", "slice", "of", "bytes", "and", "scans", "the", "value", "into", "v", "." ]

[ "func", "(", "t", "*", "transaction", ")", "scanJobById", "(", "id", "string", ",", "job", "*", "Job", ")", "{", "job", ".", "id", "=", "id", "\n", "t", ".", "command", "(", "\"", "\"", ",", "redis", ".", "Args", "{", "job", ".", "Key", "(", ")", "}", ",", "newScanJobHandler", "(", "job", ")", ")", "\n", "}" ]

[ "scanJobById", "adds", "commands", "and", "a", "reply", "handler", "to", "the", "transaction", "which", "when", "run", "will", "scan", "the", "values", "of", "the", "job", "corresponding", "to", "id", "into", "job", ".", "It", "does", "not", "execute", "the", "transaction", "." ]

[ "func", "(", "status", "Status", ")", "Count", "(", ")", "(", "int", ",", "error", ")", "{", "conn", ":=", "redisPool", ".", "Get", "(", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n", "return", "redis", ".", "Int", "(", "conn", ".", "Do", "(", "\"", "\"", ",", "status", ".", "Key", "(", ")", ")", ")", "\n", "}" ]

[ "Count", "returns", "the", "number", "of", "jobs", "that", "currently", "have", "the", "given", "status", "or", "an", "error", "if", "there", "was", "a", "problem", "connecting", "to", "the", "database", "." ]

[ "func", "(", "status", "Status", ")", "JobIds", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "conn", ":=", "redisPool", ".", "Get", "(", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n", "return", "redis", ".", "Strings", "(", "conn", ".", "Do", "(", "\"", "\"", ",", "status", ".", "Key", "(", ")", ",", "0", ",", "-", "1", ")", ")", "\n", "}" ]

[ "JobIds", "returns", "the", "ids", "of", "all", "jobs", "that", "have", "the", "given", "status", "ordered", "by", "priority", "or", "an", "error", "if", "there", "was", "a", "problem", "connecting", "to", "the", "database", "." ]

[ "func", "(", "status", "Status", ")", "Jobs", "(", ")", "(", "[", "]", "*", "Job", ",", "error", ")", "{", "t", ":=", "newTransaction", "(", ")", "\n", "jobs", ":=", "[", "]", "*", "Job", "{", "}", "\n", "t", ".", "getJobsByIds", "(", "status", ".", "Key", "(", ")", ",", "newScanJobsHandler", "(", "&", "jobs", ")", ")", "\n", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "jobs", ",", "nil", "\n", "}" ]

[ "Jobs", "returns", "all", "jobs", "that", "have", "the", "given", "status", "ordered", "by", "priority", "or", "an", "error", "if", "there", "was", "a", "problem", "connecting", "to", "the", "database", "." ]

[ "func", "RegisterType", "(", "name", "string", ",", "retries", "uint", ",", "handler", "HandlerFunc", ")", "(", "*", "Type", ",", "error", ")", "{", "// Make sure name is unique", "if", "_", ",", "found", ":=", "Types", "[", "name", "]", ";", "found", "{", "return", "Types", "[", "name", "]", ",", "newErrorNameAlreadyRegistered", "(", "name", ")", "\n", "}", "\n", "// Make sure handler is a function", "handlerType", ":=", "reflect", ".", "TypeOf", "(", "handler", ")", "\n", "if", "handlerType", ".", "Kind", "(", ")", "!=", "reflect", ".", "Func", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "handler", ")", "\n", "}", "\n", "if", "handlerType", ".", "NumIn", "(", ")", ">", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "handlerType", ".", "NumIn", "(", ")", ")", "\n", "}", "\n", "if", "handlerType", ".", "NumOut", "(", ")", "!=", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "handlerType", ".", "NumOut", "(", ")", ")", "\n", "}", "\n", "if", "!", "typeIsError", "(", "handlerType", ".", "Out", "(", "0", ")", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "handlerType", ".", "Out", "(", "0", ")", ".", "String", "(", ")", ")", "\n", "}", "\n", "Type", ":=", "&", "Type", "{", "name", ":", "name", ",", "handler", ":", "handler", ",", "retries", ":", "retries", ",", "}", "\n", "if", "handlerType", ".", "NumIn", "(", ")", "==", "1", "{", "Type", ".", "dataType", "=", "handlerType", ".", "In", "(", "0", ")", "\n", "}", "\n", "Types", "[", "name", "]", "=", "Type", "\n", "return", "Type", ",", "nil", "\n", "}" ]

[ "RegisterType", "registers", "a", "new", "type", "of", "job", "that", "can", "be", "executed", "by", "workers", ".", "name", "should", "be", "a", "unique", "string", "identifier", "for", "the", "job", ".", "retries", "is", "the", "number", "of", "times", "this", "type", "of", "job", "should", "be", "retried", "if", "it", "fails", ".", "handler", "is", "a", "function", "that", "a", "worker", "will", "call", "in", "order", "to", "execute", "the", "job", ".", "handler", "should", "be", "a", "function", "which", "accepts", "either", "0", "or", "1", "arguments", "of", "any", "type", "corresponding", "to", "the", "data", "for", "a", "job", "of", "this", "type", ".", "All", "jobs", "of", "this", "type", "must", "have", "data", "with", "the", "same", "type", "as", "the", "first", "argument", "to", "handler", "or", "nil", "if", "the", "handler", "accepts", "no", "arguments", "." ]

[ "func", "(", "jt", "*", "Type", ")", "Schedule", "(", "priority", "int", ",", "time", "time", ".", "Time", ",", "data", "interface", "{", "}", ")", "(", "*", "Job", ",", "error", ")", "{", "// Encode the data", "encodedData", ",", "err", ":=", "jt", ".", "encodeData", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Create and save the job", "job", ":=", "&", "Job", "{", "data", ":", "encodedData", ",", "typ", ":", "jt", ",", "time", ":", "time", ".", "UTC", "(", ")", ".", "UnixNano", "(", ")", ",", "retries", ":", "jt", ".", "retries", ",", "priority", ":", "priority", ",", "}", "\n", "// Set the job's status to queued and save it in the database", "job", ".", "status", "=", "StatusQueued", "\n", "if", "err", ":=", "job", ".", "save", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "job", ",", "nil", "\n", "}" ]

[ "Schedule", "schedules", "a", "on", "-", "off", "job", "of", "the", "given", "type", "with", "the", "given", "parameters", ".", "Jobs", "with", "a", "higher", "priority", "will", "be", "executed", "first", ".", "The", "job", "will", "not", "be", "executed", "until", "after", "time", ".", "data", "is", "the", "data", "associated", "with", "this", "particular", "job", "and", "should", "have", "the", "same", "type", "as", "the", "first", "argument", "to", "the", "handler", "for", "this", "Type", "." ]

[ "func", "(", "jt", "*", "Type", ")", "encodeData", "(", "data", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Check the type of data", "dataType", ":=", "reflect", ".", "TypeOf", "(", "data", ")", "\n", "if", "dataType", "!=", "jt", ".", "dataType", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "jt", ".", "dataType", ",", "jt", ",", "dataType", ")", "\n", "}", "\n", "// Encode the data", "encodedData", ",", "err", ":=", "encode", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "encodedData", ",", "nil", "\n", "}" ]

[ "encodeData", "checks", "that", "the", "type", "of", "data", "is", "what", "we", "expect", "based", "on", "the", "handler", "for", "the", "Type", ".", "If", "it", "is", "it", "encodes", "the", "data", "into", "a", "slice", "of", "bytes", "." ]

[ "func", "NewPool", "(", "config", "*", "PoolConfig", ")", "(", "*", "Pool", ",", "error", ")", "{", "finalConfig", ":=", "getPoolConfig", "(", "config", ")", "\n", "hardwareId", ",", "err", ":=", "getHardwareId", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "Pool", "{", "config", ":", "finalConfig", ",", "id", ":", "hardwareId", ",", "wg", ":", "&", "sync", ".", "WaitGroup", "{", "}", ",", "exit", ":", "make", "(", "chan", "bool", ")", ",", "workers", ":", "make", "(", "[", "]", "*", "worker", ",", "finalConfig", ".", "NumWorkers", ")", ",", "jobs", ":", "make", "(", "chan", "*", "Job", ",", "finalConfig", ".", "BatchSize", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewPool", "creates", "and", "returns", "a", "new", "pool", "with", "the", "given", "configuration", ".", "You", "can", "pass", "in", "nil", "to", "use", "the", "default", "values", ".", "Otherwise", "any", "zero", "values", "in", "config", "will", "be", "interpreted", "as", "the", "default", "value", "." ]

[ "func", "getPoolConfig", "(", "passedConfig", "*", "PoolConfig", ")", "*", "PoolConfig", "{", "if", "passedConfig", "==", "nil", "{", "return", "DefaultPoolConfig", "\n", "}", "\n", "finalConfig", ":=", "&", "PoolConfig", "{", "}", "\n", "(", "*", "finalConfig", ")", "=", "(", "*", "passedConfig", ")", "\n", "if", "passedConfig", ".", "NumWorkers", "==", "0", "{", "finalConfig", ".", "NumWorkers", "=", "DefaultPoolConfig", ".", "NumWorkers", "\n", "}", "\n", "if", "passedConfig", ".", "BatchSize", "==", "0", "{", "finalConfig", ".", "BatchSize", "=", "DefaultPoolConfig", ".", "BatchSize", "\n", "}", "\n", "if", "passedConfig", ".", "MinWait", "==", "0", "{", "finalConfig", ".", "MinWait", "=", "DefaultPoolConfig", ".", "MinWait", "\n", "}", "\n", "if", "passedConfig", ".", "StaleTimeout", "==", "0", "{", "finalConfig", ".", "StaleTimeout", "=", "DefaultPoolConfig", ".", "StaleTimeout", "\n", "}", "\n", "return", "finalConfig", "\n", "}" ]

[ "getPoolConfig", "replaces", "any", "zero", "values", "in", "passedConfig", "with", "the", "default", "values", ".", "If", "passedConfig", "is", "nil", "every", "value", "will", "be", "set", "to", "the", "default", "." ]

[ "func", "(", "p", "*", "Pool", ")", "addToPoolSet", "(", ")", "error", "{", "conn", ":=", "redisPool", ".", "Get", "(", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n", "p", ".", "RLock", "(", ")", "\n", "thisId", ":=", "p", ".", "id", "\n", "p", ".", "RUnlock", "(", ")", "\n", "if", "_", ",", "err", ":=", "conn", ".", "Do", "(", "\"", "\"", ",", "Keys", ".", "ActivePools", ",", "thisId", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "addToPoolSet", "adds", "the", "id", "of", "the", "worker", "pool", "to", "a", "set", "of", "active", "pools", "in", "the", "database", "." ]

[ "func", "(", "p", "*", "Pool", ")", "pingAndPurgeIfNeeded", "(", "other", "*", "Pool", ")", "error", "{", "ping", ":=", "redisPool", ".", "Get", "(", ")", "\n", "pong", ":=", "redis", ".", "PubSubConn", "{", "redisPool", ".", "Get", "(", ")", "}", "\n", "// Listen for pongs by subscribing to the other pool's pong key", "pong", ".", "Subscribe", "(", "other", ".", "pongKey", "(", ")", ")", "\n", "// Ping the other pool by publishing to its ping key", "ping", ".", "Do", "(", "\"", "\"", ",", "other", ".", "pingKey", "(", ")", ",", "1", ")", "\n", "// Use a select statement to either receive the pong or timeout", "pongChan", ":=", "make", "(", "chan", "interface", "{", "}", ")", "\n", "errChan", ":=", "make", "(", "chan", "error", ")", "\n", "go", "func", "(", ")", "{", "defer", "func", "(", ")", "{", "pong", ".", "Close", "(", ")", "\n", "ping", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "select", "{", "case", "<-", "p", ".", "exit", ":", "return", "\n", "default", ":", "}", "\n", "for", "{", "reply", ":=", "pong", ".", "Receive", "(", ")", "\n", "switch", "reply", ".", "(", "type", ")", "{", "case", "redis", ".", "Message", ":", "// The pong was received", "pongChan", "<-", "reply", "\n", "return", "\n", "case", "error", ":", "// There was some unexpected error", "err", ":=", "reply", ".", "(", "error", ")", "\n", "errChan", "<-", "err", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "timeout", ":=", "time", ".", "After", "(", "p", ".", "config", ".", "StaleTimeout", ")", "\n", "select", "{", "case", "<-", "pongChan", ":", "// The other pool responded with a pong", "return", "nil", "\n", "case", "err", ":=", "<-", "errChan", ":", "// Received an error from the pubsub conn", "return", "err", "\n", "case", "<-", "timeout", ":", "// The pool is considered stale and should be purged", "t", ":=", "newTransaction", "(", ")", "\n", "other", ".", "RLock", "(", ")", "\n", "otherId", ":=", "other", ".", "id", "\n", "other", ".", "RUnlock", "(", ")", "\n", "t", ".", "purgeStalePool", "(", "otherId", ")", "\n", "if", "err", ":=", "t", ".", "exec", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "pingAndPurgeIfNeeded", "pings", "other", "by", "publishing", "to", "others", "ping", "key", ".", "If", "it", "does", "not", "receive", "a", "pong", "reply", "within", "some", "amount", "of", "time", "it", "will", "assume", "the", "pool", "is", "stale", "and", "purge", "it", "." ]

[ "func", "(", "p", "*", "Pool", ")", "respondToPings", "(", ")", "error", "{", "pong", ":=", "redisPool", ".", "Get", "(", ")", "\n", "ping", ":=", "redis", ".", "PubSubConn", "{", "redisPool", ".", "Get", "(", ")", "}", "\n", "defer", "func", "(", ")", "{", "pong", ".", "Close", "(", ")", "\n", "ping", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "// Subscribe to the ping key for this pool to receive pings.", "if", "err", ":=", "ping", ".", "Subscribe", "(", "p", ".", "pingKey", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "{", "// Whenever we recieve a ping, reply immediately with a pong by", "// publishing to the pong key for this pool.", "switch", "reply", ":=", "ping", ".", "Receive", "(", ")", ".", "(", "type", ")", "{", "case", "redis", ".", "Message", ":", "if", "_", ",", "err", ":=", "pong", ".", "Do", "(", "\"", "\"", ",", "p", ".", "pongKey", "(", ")", ",", "0", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "error", ":", "err", ":=", "reply", ".", "(", "error", ")", "\n", "return", "err", "\n", "}", "\n", "time", ".", "Sleep", "(", "1", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "}" ]

[ "respondToPings", "continuously", "listens", "for", "pings", "from", "other", "worker", "pools", "and", "immediately", "responds", "with", "a", "pong", ".", "It", "will", "only", "return", "if", "there", "is", "an", "error", "." ]

[ "func", "(", "p", "*", "Pool", ")", "Start", "(", ")", "error", "{", "// Purge stale jobs belonging to this pool if there was a recent", "// hard failure", "if", "err", ":=", "p", ".", "removeStaleSelf", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Check on the status of other worker pools by pinging them and", "// start the process to repond to pings from other pools", "if", "err", ":=", "p", ".", "addToPoolSet", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "go", "func", "(", ")", "{", "select", "{", "case", "<-", "p", ".", "exit", ":", "return", "\n", "default", ":", "}", "\n", "if", "err", ":=", "p", ".", "respondToPings", "(", ")", ";", "err", "!=", "nil", "{", "// TODO: send the err accross a channel instead of panicking", "panic", "(", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "if", "err", ":=", "p", ".", "purgeStalePools", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Initialize workers", "for", "i", ":=", "range", "p", ".", "workers", "{", "p", ".", "wg", ".", "Add", "(", "1", ")", "\n", "worker", ":=", "&", "worker", "{", "wg", ":", "p", ".", "wg", ",", "jobs", ":", "p", ".", "jobs", ",", "afterFunc", ":", "p", ".", "afterFunc", ",", "}", "\n", "p", ".", "workers", "[", "i", "]", "=", "worker", "\n", "worker", ".", "start", "(", ")", "\n", "}", "\n", "go", "func", "(", ")", "{", "if", "err", ":=", "p", ".", "queryLoop", "(", ")", ";", "err", "!=", "nil", "{", "// TODO: send the err accross a channel instead of panicking", "panic", "(", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Start", "starts", "the", "worker", "pool", ".", "This", "means", "the", "pool", "will", "initialize", "workers", "continuously", "query", "the", "database", "for", "queued", "jobs", "and", "delegate", "those", "jobs", "to", "the", "workers", "." ]

[ "func", "(", "p", "*", "Pool", ")", "queryLoop", "(", ")", "error", "{", "if", "err", ":=", "p", ".", "sendNextJobs", "(", "p", ".", "config", ".", "BatchSize", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "{", "minWait", ":=", "time", ".", "After", "(", "p", ".", "config", ".", "MinWait", ")", "\n", "select", "{", "case", "<-", "p", ".", "exit", ":", "// Close the channel to tell workers to stop executing new jobs", "close", "(", "p", ".", "jobs", ")", "\n", "return", "nil", "\n", "case", "<-", "minWait", ":", "if", "err", ":=", "p", ".", "sendNextJobs", "(", "p", ".", "config", ".", "BatchSize", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "queryLoop", "continuously", "queries", "the", "database", "for", "new", "jobs", "and", "if", "it", "finds", "any", "sends", "them", "through", "the", "jobs", "channel", "for", "execution", "by", "some", "worker", "." ]

[ "func", "(", "p", "*", "Pool", ")", "sendNextJobs", "(", "n", "int", ")", "error", "{", "jobs", ",", "err", ":=", "p", ".", "getNextJobs", "(", "p", ".", "config", ".", "BatchSize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Send the jobs across the channel, where they will be picked up", "// by exactly one worker", "for", "_", ",", "job", ":=", "range", "jobs", "{", "p", ".", "jobs", "<-", "job", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "sendNextJobs", "queries", "the", "database", "to", "find", "the", "next", "n", "ready", "jobs", "then", "sends", "those", "jobs", "to", "the", "jobs", "channel", "effectively", "delegating", "them", "to", "a", "worker", "." ]

[ "func", "(", "t", "*", "transaction", ")", "command", "(", "name", "string", ",", "args", "redis", ".", "Args", ",", "handler", "replyHandler", ")", "{", "t", ".", "actions", "=", "append", "(", "t", ".", "actions", ",", "&", "action", "{", "kind", ":", "actionCommand", ",", "name", ":", "name", ",", "args", ":", "args", ",", "handler", ":", "handler", ",", "}", ")", "\n", "}" ]

[ "command", "adds", "a", "command", "action", "to", "the", "transaction", "with", "the", "given", "args", ".", "handler", "will", "be", "called", "with", "the", "reply", "from", "this", "specific", "command", "when", "the", "transaction", "is", "executed", "." ]

[ "func", "(", "t", "*", "transaction", ")", "script", "(", "script", "*", "redis", ".", "Script", ",", "args", "redis", ".", "Args", ",", "handler", "replyHandler", ")", "{", "t", ".", "actions", "=", "append", "(", "t", ".", "actions", ",", "&", "action", "{", "kind", ":", "actionScript", ",", "script", ":", "script", ",", "args", ":", "args", ",", "handler", ":", "handler", ",", "}", ")", "\n", "}" ]

[ "command", "adds", "a", "script", "action", "to", "the", "transaction", "with", "the", "given", "args", ".", "handler", "will", "be", "called", "with", "the", "reply", "from", "this", "specific", "script", "when", "the", "transaction", "is", "executed", "." ]

[ "func", "(", "t", "*", "transaction", ")", "exec", "(", ")", "error", "{", "// Return the connection to the pool when we are done", "defer", "t", ".", "conn", ".", "Close", "(", ")", "\n\n", "if", "len", "(", "t", ".", "actions", ")", "==", "1", "{", "// If there is only one command, no need to use MULTI/EXEC", "a", ":=", "t", ".", "actions", "[", "0", "]", "\n", "reply", ",", "err", ":=", "t", ".", "doAction", "(", "a", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "a", ".", "handler", "!=", "nil", "{", "if", "err", ":=", "a", ".", "handler", "(", "reply", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "else", "{", "// Send all the commands and scripts at once using MULTI/EXEC", "t", ".", "conn", ".", "Send", "(", "\"", "\"", ")", "\n", "for", "_", ",", "a", ":=", "range", "t", ".", "actions", "{", "if", "err", ":=", "t", ".", "sendAction", "(", "a", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Invoke redis driver to execute the transaction", "replies", ",", "err", ":=", "redis", ".", "Values", "(", "t", ".", "conn", ".", "Do", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Iterate through the replies, calling the corresponding handler functions", "for", "i", ",", "reply", ":=", "range", "replies", "{", "a", ":=", "t", ".", "actions", "[", "i", "]", "\n", "if", "a", ".", "handler", "!=", "nil", "{", "if", "err", ":=", "a", ".", "handler", "(", "reply", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "exec", "executes", "the", "transaction", "sequentially", "sending", "each", "action", "and", "calling", "all", "the", "action", "handlers", "with", "the", "corresponding", "replies", "." ]

[ "func", "newScanJobsHandler", "(", "jobs", "*", "[", "]", "*", "Job", ")", "replyHandler", "{", "return", "func", "(", "reply", "interface", "{", "}", ")", "error", "{", "values", ",", "err", ":=", "redis", ".", "Values", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "for", "_", ",", "fields", ":=", "range", "values", "{", "job", ":=", "&", "Job", "{", "}", "\n", "if", "err", ":=", "scanJob", "(", "fields", ",", "job", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "(", "*", "jobs", ")", "=", "append", "(", "(", "*", "jobs", ")", ",", "job", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "newScanJobsHandler", "returns", "a", "replyHandler", "which", "when", "run", "will", "scan", "the", "values", "of", "reply", "into", "jobs", "." ]

[ "func", "(", "t", "*", "transaction", ")", "debugSet", "(", "setName", "string", ")", "{", "t", ".", "command", "(", "\"", "\"", ",", "redis", ".", "Args", "{", "setName", ",", "0", ",", "-", "1", ",", "\"", "\"", "}", ",", "func", "(", "reply", "interface", "{", "}", ")", "error", "{", "vals", ",", "err", ":=", "redis", ".", "Strings", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "setName", ",", "vals", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "debugSet", "simply", "prints", "out", "the", "value", "of", "the", "given", "set" ]

[ "func", "newScanStringsHandler", "(", "strings", "*", "[", "]", "string", ")", "replyHandler", "{", "return", "func", "(", "reply", "interface", "{", "}", ")", "error", "{", "if", "strings", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "err", "error", "\n", "(", "*", "strings", ")", ",", "err", "=", "redis", ".", "Strings", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "newScanStringsHandler", "returns", "a", "replyHandler", "which", "when", "run", "will", "scan", "the", "values", "of", "reply", "into", "strings", "." ]

[ "func", "newScanStringHandler", "(", "s", "*", "string", ")", "replyHandler", "{", "return", "func", "(", "reply", "interface", "{", "}", ")", "error", "{", "if", "s", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "err", "error", "\n", "(", "*", "s", ")", ",", "err", "=", "redis", ".", "String", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "newScanStringHandler", "returns", "a", "replyHandler", "which", "when", "run", "will", "convert", "reply", "to", "a", "string", "and", "scan", "it", "into", "s", "." ]

[ "func", "newScanIntHandler", "(", "i", "*", "int", ")", "replyHandler", "{", "return", "func", "(", "reply", "interface", "{", "}", ")", "error", "{", "if", "i", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "err", "error", "\n", "(", "*", "i", ")", ",", "err", "=", "redis", ".", "Int", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "newScanIntHandler", "returns", "a", "replyHandler", "which", "when", "run", "will", "convert", "reply", "to", "a", "int", "and", "scan", "it", "into", "i", "." ]

[ "func", "newScanBoolHandler", "(", "b", "*", "bool", ")", "replyHandler", "{", "return", "func", "(", "reply", "interface", "{", "}", ")", "error", "{", "if", "b", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "err", "error", "\n", "(", "*", "b", ")", ",", "err", "=", "redis", ".", "Bool", "(", "reply", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "newScanBoolHandler", "returns", "a", "replyHandler", "which", "when", "run", "will", "convert", "reply", "to", "a", "bool", "and", "scan", "it", "into", "b", "." ]

[ "func", "(", "t", "*", "transaction", ")", "retryOrFailJob", "(", "job", "*", "Job", ",", "handler", "replyHandler", ")", "{", "t", ".", "script", "(", "retryOrFailJobScript", ",", "redis", ".", "Args", "{", "job", ".", "id", "}", ",", "handler", ")", "\n", "}" ]

[ "retryOrFailJob", "is", "a", "small", "function", "wrapper", "around", "retryOrFailJobScript", ".", "It", "offers", "some", "type", "safety", "and", "helps", "make", "sure", "the", "arguments", "you", "pass", "through", "to", "the", "are", "correct", ".", "The", "script", "will", "either", "mark", "the", "job", "as", "failed", "or", "queue", "it", "for", "retry", "depending", "on", "the", "number", "of", "retries", "left", "." ]

[ "func", "(", "t", "*", "transaction", ")", "setStatus", "(", "job", "*", "Job", ",", "status", "Status", ")", "{", "t", ".", "script", "(", "setJobStatusScript", ",", "redis", ".", "Args", "{", "job", ".", "id", ",", "string", "(", "status", ")", "}", ",", "nil", ")", "\n", "}" ]

[ "setStatus", "is", "a", "small", "function", "wrapper", "around", "setStatusScript", ".", "It", "offers", "some", "type", "safety", "and", "helps", "make", "sure", "the", "arguments", "you", "pass", "through", "to", "the", "are", "correct", ".", "The", "script", "will", "atomically", "update", "the", "status", "of", "the", "job", "removing", "it", "from", "its", "old", "status", "set", "and", "adding", "it", "to", "the", "new", "one", "." ]

[ "func", "(", "t", "*", "transaction", ")", "destroyJob", "(", "job", "*", "Job", ")", "{", "t", ".", "script", "(", "destroyJobScript", ",", "redis", ".", "Args", "{", "job", ".", "id", "}", ",", "nil", ")", "\n", "}" ]

[ "destroyJob", "is", "a", "small", "function", "wrapper", "around", "destroyJobScript", ".", "It", "offers", "some", "type", "safety", "and", "helps", "make", "sure", "the", "arguments", "you", "pass", "through", "to", "the", "are", "correct", ".", "The", "script", "will", "remove", "all", "records", "associated", "with", "job", "from", "the", "database", "." ]

[ "func", "(", "t", "*", "transaction", ")", "purgeStalePool", "(", "poolId", "string", ")", "{", "t", ".", "script", "(", "purgeStalePoolScript", ",", "redis", ".", "Args", "{", "poolId", "}", ",", "nil", ")", "\n", "}" ]

[ "purgeStalePool", "is", "a", "small", "function", "wrapper", "around", "purgeStalePoolScript", ".", "It", "offers", "some", "type", "safety", "and", "helps", "make", "sure", "the", "arguments", "you", "pass", "through", "to", "the", "are", "correct", ".", "The", "script", "will", "remove", "the", "stale", "pool", "from", "the", "active", "pools", "set", "and", "then", "requeue", "any", "jobs", "associated", "with", "the", "stale", "pool", "that", "are", "stuck", "in", "the", "executing", "set", "." ]

[ "func", "(", "t", "*", "transaction", ")", "getJobsByIds", "(", "setKey", "string", ",", "handler", "replyHandler", ")", "{", "t", ".", "script", "(", "getJobsByIdsScript", ",", "redis", ".", "Args", "{", "setKey", "}", ",", "handler", ")", "\n", "}" ]

[ "getJobsByIds", "is", "a", "small", "function", "wrapper", "around", "getJobsByIdsScript", ".", "It", "offers", "some", "type", "safety", "and", "helps", "make", "sure", "the", "arguments", "you", "pass", "through", "to", "the", "are", "correct", ".", "The", "script", "will", "return", "all", "the", "fields", "for", "jobs", "which", "are", "identified", "by", "ids", "in", "the", "given", "sorted", "set", ".", "You", "can", "use", "the", "handler", "to", "scan", "the", "jobs", "into", "a", "slice", "of", "jobs", "." ]

[ "func", "(", "t", "*", "transaction", ")", "setJobField", "(", "job", "*", "Job", ",", "fieldName", "string", ",", "fieldValue", "interface", "{", "}", ")", "{", "t", ".", "script", "(", "setJobFieldScript", ",", "redis", ".", "Args", "{", "job", ".", "id", ",", "fieldName", ",", "fieldValue", "}", ",", "nil", ")", "\n", "}" ]

[ "setJobField", "is", "a", "small", "function", "wrapper", "around", "setJobFieldScript", ".", "It", "offers", "some", "type", "safety", "and", "helps", "make", "sure", "the", "arguments", "you", "pass", "through", "are", "correct", ".", "The", "script", "will", "set", "the", "given", "field", "to", "the", "given", "value", "iff", "the", "job", "exists", "and", "has", "not", "been", "destroyed", "." ]

[ "func", "(", "t", "*", "transaction", ")", "addJobToSet", "(", "job", "*", "Job", ",", "setName", "string", ",", "score", "float64", ")", "{", "t", ".", "script", "(", "addJobToSetScript", ",", "redis", ".", "Args", "{", "job", ".", "id", ",", "setName", ",", "score", "}", ",", "nil", ")", "\n", "}" ]

[ "addJobToSet", "is", "a", "small", "function", "wrapper", "around", "addJobToSetScript", ".", "It", "offers", "some", "type", "safety", "and", "helps", "make", "sure", "the", "arguments", "you", "pass", "through", "are", "correct", ".", "The", "script", "will", "add", "the", "job", "to", "the", "given", "set", "with", "the", "given", "score", "iff", "the", "job", "exists", "and", "has", "not", "been", "destroyed", "." ]

[ "func", "convertUnderscoresToCamelCase", "(", "s", "string", ")", "string", "{", "if", "len", "(", "s", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "result", ":=", "\"", "\"", "\n", "shouldUpper", ":=", "false", "\n", "for", "_", ",", "char", ":=", "range", "s", "{", "if", "char", "==", "'_'", "{", "shouldUpper", "=", "true", "\n", "continue", "\n", "}", "\n", "if", "shouldUpper", "{", "result", "+=", "strings", ".", "ToUpper", "(", "string", "(", "char", ")", ")", "\n", "}", "else", "{", "result", "+=", "string", "(", "char", ")", "\n", "}", "\n", "shouldUpper", "=", "false", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "convertUnderscoresToCamelCase", "converts", "a", "string", "of", "the", "form", "foo_bar_baz", "to", "fooBarBaz", "." ]

[ "func", "sendMessages", "(", "c", "net", ".", "PacketConn", ",", "source", "net", ".", "HardwareAddr", ",", "msg", "string", ")", "{", "// Message is broadcast to all machines in same network segment.", "f", ":=", "&", "ethernet", ".", "Frame", "{", "Destination", ":", "ethernet", ".", "Broadcast", ",", "Source", ":", "source", ",", "EtherType", ":", "etherType", ",", "Payload", ":", "[", "]", "byte", "(", "msg", ")", ",", "}", "\n\n", "b", ",", "err", ":=", "f", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Required by Linux, even though the Ethernet frame has a destination.", "// Unused by BSD.", "addr", ":=", "&", "raw", ".", "Addr", "{", "HardwareAddr", ":", "ethernet", ".", "Broadcast", ",", "}", "\n\n", "// Send message forever.", "t", ":=", "time", ".", "NewTicker", "(", "1", "*", "time", ".", "Second", ")", "\n", "for", "range", "t", ".", "C", "{", "if", "_", ",", "err", ":=", "c", ".", "WriteTo", "(", "b", ",", "addr", ")", ";", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "sendMessages", "continuously", "sends", "a", "message", "over", "a", "connection", "at", "regular", "intervals", "sourced", "from", "specified", "hardware", "address", "." ]

[ "func", "receiveMessages", "(", "c", "net", ".", "PacketConn", ",", "mtu", "int", ")", "{", "var", "f", "ethernet", ".", "Frame", "\n", "b", ":=", "make", "(", "[", "]", "byte", ",", "mtu", ")", "\n\n", "// Keep receiving messages forever.", "for", "{", "n", ",", "addr", ",", "err", ":=", "c", ".", "ReadFrom", "(", "b", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Unpack Ethernet II frame into Go representation.", "if", "err", ":=", "(", "&", "f", ")", ".", "UnmarshalBinary", "(", "b", "[", ":", "n", "]", ")", ";", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Display source of message and message itself.", "log", ".", "Printf", "(", "\"", "\"", ",", "addr", ".", "String", "(", ")", ",", "string", "(", "f", ".", "Payload", ")", ")", "\n", "}", "\n", "}" ]

[ "receiveMessages", "continuously", "receives", "messages", "over", "a", "connection", ".", "The", "messages", "may", "be", "up", "to", "the", "interface", "s", "MTU", "in", "size", "." ]

[ "func", "(", "v", "*", "VLAN", ")", "MarshalBinary", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "2", ")", "\n", "_", ",", "err", ":=", "v", ".", "read", "(", "b", ")", "\n", "return", "b", ",", "err", "\n", "}" ]

[ "MarshalBinary", "allocates", "a", "byte", "slice", "and", "marshals", "a", "VLAN", "into", "binary", "form", "." ]

[ "func", "(", "v", "*", "VLAN", ")", "read", "(", "b", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "// Check for VLAN priority in valid range", "if", "v", ".", "Priority", ">", "PriorityNetworkControl", "{", "return", "0", ",", "ErrInvalidVLAN", "\n", "}", "\n\n", "// Check for VLAN ID in valid range", "if", "v", ".", "ID", ">=", "VLANMax", "{", "return", "0", ",", "ErrInvalidVLAN", "\n", "}", "\n\n", "// 3 bits: priority", "ub", ":=", "uint16", "(", "v", ".", "Priority", ")", "<<", "13", "\n\n", "// 1 bit: drop eligible", "var", "drop", "uint16", "\n", "if", "v", ".", "DropEligible", "{", "drop", "=", "1", "\n", "}", "\n", "ub", "|=", "drop", "<<", "12", "\n\n", "// 12 bits: VLAN ID", "ub", "|=", "v", ".", "ID", "\n\n", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", ",", "ub", ")", "\n", "return", "2", ",", "nil", "\n", "}" ]

[ "read", "reads", "data", "from", "a", "VLAN", "into", "b", ".", "read", "is", "used", "to", "marshal", "a", "VLAN", "into", "binary", "form", "but", "does", "not", "allocate", "on", "its", "own", "." ]

[ "func", "(", "v", "*", "VLAN", ")", "UnmarshalBinary", "(", "b", "[", "]", "byte", ")", "error", "{", "// VLAN tag is always 2 bytes", "if", "len", "(", "b", ")", "!=", "2", "{", "return", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n\n", "// 3 bits: priority", "// 1 bit : drop eligible", "// 12 bits: VLAN ID", "ub", ":=", "binary", ".", "BigEndian", ".", "Uint16", "(", "b", "[", "0", ":", "2", "]", ")", "\n", "v", ".", "Priority", "=", "Priority", "(", "uint8", "(", "ub", ">>", "13", ")", ")", "\n", "v", ".", "DropEligible", "=", "ub", "&", "0x1000", "!=", "0", "\n", "v", ".", "ID", "=", "ub", "&", "0x0fff", "\n\n", "// Check for VLAN ID in valid range", "if", "v", ".", "ID", ">=", "VLANMax", "{", "return", "ErrInvalidVLAN", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "UnmarshalBinary", "unmarshals", "a", "byte", "slice", "into", "a", "VLAN", "." ]

[ "func", "(", "f", "*", "Frame", ")", "MarshalBinary", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "f", ".", "length", "(", ")", ")", "\n", "_", ",", "err", ":=", "f", ".", "read", "(", "b", ")", "\n", "return", "b", ",", "err", "\n", "}" ]

[ "MarshalBinary", "allocates", "a", "byte", "slice", "and", "marshals", "a", "Frame", "into", "binary", "form", "." ]

[ "func", "(", "f", "*", "Frame", ")", "MarshalFCS", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Frame length with 4 extra bytes for frame check sequence", "b", ":=", "make", "(", "[", "]", "byte", ",", "f", ".", "length", "(", ")", "+", "4", ")", "\n", "if", "_", ",", "err", ":=", "f", ".", "read", "(", "b", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Compute IEEE CRC32 checksum of frame bytes and place it directly", "// in the last four bytes of the slice", "binary", ".", "BigEndian", ".", "PutUint32", "(", "b", "[", "len", "(", "b", ")", "-", "4", ":", "]", ",", "crc32", ".", "ChecksumIEEE", "(", "b", "[", "0", ":", "len", "(", "b", ")", "-", "4", "]", ")", ")", "\n", "return", "b", ",", "nil", "\n", "}" ]

[ "MarshalFCS", "allocates", "a", "byte", "slice", "marshals", "a", "Frame", "into", "binary", "form", "and", "finally", "calculates", "and", "places", "a", "4", "-", "byte", "IEEE", "CRC32", "frame", "check", "sequence", "at", "the", "end", "of", "the", "slice", ".", "Most", "users", "should", "use", "MarshalBinary", "instead", ".", "MarshalFCS", "is", "provided", "as", "a", "convenience", "for", "rare", "occasions", "when", "the", "operating", "system", "cannot", "automatically", "generate", "a", "frame", "check", "sequence", "for", "an", "Ethernet", "frame", "." ]

[ "func", "(", "f", "*", "Frame", ")", "read", "(", "b", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "// S-VLAN must also have accompanying C-VLAN.", "if", "f", ".", "ServiceVLAN", "!=", "nil", "&&", "f", ".", "VLAN", "==", "nil", "{", "return", "0", ",", "ErrInvalidVLAN", "\n", "}", "\n\n", "copy", "(", "b", "[", "0", ":", "6", "]", ",", "f", ".", "Destination", ")", "\n", "copy", "(", "b", "[", "6", ":", "12", "]", ",", "f", ".", "Source", ")", "\n\n", "// Marshal each non-nil VLAN tag into bytes, inserting the appropriate", "// EtherType/TPID before each, so devices know that one or more VLANs", "// are present.", "vlans", ":=", "[", "]", "struct", "{", "vlan", "*", "VLAN", "\n", "tpid", "EtherType", "\n", "}", "{", "{", "vlan", ":", "f", ".", "ServiceVLAN", ",", "tpid", ":", "EtherTypeServiceVLAN", "}", ",", "{", "vlan", ":", "f", ".", "VLAN", ",", "tpid", ":", "EtherTypeVLAN", "}", ",", "}", "\n\n", "n", ":=", "12", "\n", "for", "_", ",", "vt", ":=", "range", "vlans", "{", "if", "vt", ".", "vlan", "==", "nil", "{", "continue", "\n", "}", "\n\n", "// Add VLAN EtherType and VLAN bytes.", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "n", ":", "n", "+", "2", "]", ",", "uint16", "(", "vt", ".", "tpid", ")", ")", "\n", "if", "_", ",", "err", ":=", "vt", ".", "vlan", ".", "read", "(", "b", "[", "n", "+", "2", ":", "n", "+", "4", "]", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "n", "+=", "4", "\n", "}", "\n\n", "// Marshal actual EtherType after any VLANs, copy payload into", "// output bytes.", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", "[", "n", ":", "n", "+", "2", "]", ",", "uint16", "(", "f", ".", "EtherType", ")", ")", "\n", "copy", "(", "b", "[", "n", "+", "2", ":", "]", ",", "f", ".", "Payload", ")", "\n\n", "return", "len", "(", "b", ")", ",", "nil", "\n", "}" ]

[ "read", "reads", "data", "from", "a", "Frame", "into", "b", ".", "read", "is", "used", "to", "marshal", "a", "Frame", "into", "binary", "form", "but", "does", "not", "allocate", "on", "its", "own", "." ]

[ "func", "(", "f", "*", "Frame", ")", "UnmarshalBinary", "(", "b", "[", "]", "byte", ")", "error", "{", "// Verify that both hardware addresses and a single EtherType are present", "if", "len", "(", "b", ")", "<", "14", "{", "return", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n\n", "// Track offset in packet for reading data", "n", ":=", "14", "\n\n", "// Continue looping and parsing VLAN tags until no more VLAN EtherType", "// values are detected", "et", ":=", "EtherType", "(", "binary", ".", "BigEndian", ".", "Uint16", "(", "b", "[", "n", "-", "2", ":", "n", "]", ")", ")", "\n", "switch", "et", "{", "case", "EtherTypeServiceVLAN", ",", "EtherTypeVLAN", ":", "// VLAN type is hinted for further parsing. An index is returned which", "// indicates how many bytes were consumed by VLAN tags.", "nn", ",", "err", ":=", "f", ".", "unmarshalVLANs", "(", "et", ",", "b", "[", "n", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "n", "+=", "nn", "\n", "default", ":", "// No VLANs detected.", "f", ".", "EtherType", "=", "et", "\n", "}", "\n\n", "// Allocate single byte slice to store destination and source hardware", "// addresses, and payload", "bb", ":=", "make", "(", "[", "]", "byte", ",", "6", "+", "6", "+", "len", "(", "b", "[", "n", ":", "]", ")", ")", "\n", "copy", "(", "bb", "[", "0", ":", "6", "]", ",", "b", "[", "0", ":", "6", "]", ")", "\n", "f", ".", "Destination", "=", "bb", "[", "0", ":", "6", "]", "\n", "copy", "(", "bb", "[", "6", ":", "12", "]", ",", "b", "[", "6", ":", "12", "]", ")", "\n", "f", ".", "Source", "=", "bb", "[", "6", ":", "12", "]", "\n\n", "// There used to be a minimum payload length restriction here, but as", "// long as two hardware addresses and an EtherType are present, it", "// doesn't really matter what is contained in the payload. We will", "// follow the \"robustness principle\".", "copy", "(", "bb", "[", "12", ":", "]", ",", "b", "[", "n", ":", "]", ")", "\n", "f", ".", "Payload", "=", "bb", "[", "12", ":", "]", "\n\n", "return", "nil", "\n", "}" ]

[ "UnmarshalBinary", "unmarshals", "a", "byte", "slice", "into", "a", "Frame", "." ]

[ "func", "(", "f", "*", "Frame", ")", "UnmarshalFCS", "(", "b", "[", "]", "byte", ")", "error", "{", "// Must contain enough data for FCS, to avoid panics", "if", "len", "(", "b", ")", "<", "4", "{", "return", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n\n", "// Verify checksum in slice versus newly computed checksum", "want", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "b", "[", "len", "(", "b", ")", "-", "4", ":", "]", ")", "\n", "got", ":=", "crc32", ".", "ChecksumIEEE", "(", "b", "[", "0", ":", "len", "(", "b", ")", "-", "4", "]", ")", "\n", "if", "want", "!=", "got", "{", "return", "ErrInvalidFCS", "\n", "}", "\n\n", "return", "f", ".", "UnmarshalBinary", "(", "b", "[", "0", ":", "len", "(", "b", ")", "-", "4", "]", ")", "\n", "}" ]

[ "UnmarshalFCS", "computes", "the", "IEEE", "CRC32", "frame", "check", "sequence", "of", "a", "Frame", "verifies", "it", "against", "the", "checksum", "present", "in", "the", "byte", "slice", "and", "finally", "unmarshals", "a", "byte", "slice", "into", "a", "Frame", ".", "Most", "users", "should", "use", "UnmarshalBinary", "instead", ".", "UnmarshalFCS", "is", "provided", "as", "a", "convenience", "for", "rare", "occasions", "when", "the", "operating", "system", "cannot", "automatically", "verify", "a", "frame", "check", "sequence", "for", "an", "Ethernet", "frame", "." ]

[ "func", "(", "f", "*", "Frame", ")", "length", "(", ")", "int", "{", "// If payload is less than the required minimum length, we zero-pad up to", "// the required minimum length", "pl", ":=", "len", "(", "f", ".", "Payload", ")", "\n", "if", "pl", "<", "minPayload", "{", "pl", "=", "minPayload", "\n", "}", "\n\n", "// Add additional length if VLAN tags are needed.", "var", "vlanLen", "int", "\n", "switch", "{", "case", "f", ".", "ServiceVLAN", "!=", "nil", "&&", "f", ".", "VLAN", "!=", "nil", ":", "vlanLen", "=", "8", "\n", "case", "f", ".", "VLAN", "!=", "nil", ":", "vlanLen", "=", "4", "\n", "}", "\n\n", "// 6 bytes: destination hardware address", "// 6 bytes: source hardware address", "// N bytes: VLAN tags (if present)", "// 2 bytes: EtherType", "// N bytes: payload length (may be padded)", "return", "6", "+", "6", "+", "vlanLen", "+", "2", "+", "pl", "\n", "}" ]

[ "length", "calculates", "the", "number", "of", "bytes", "required", "to", "store", "a", "Frame", "." ]

[ "func", "(", "r", "*", "Client", ")", "GetActualUser", "(", ")", "(", "User", ",", "error", ")", "{", "var", "(", "raw", "[", "]", "byte", "\n", "user", "User", "\n", "code", "int", "\n", "err", "error", "\n", ")", "\n", "if", "raw", ",", "code", ",", "err", "=", "r", ".", "get", "(", "\"", "\"", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "user", ",", "err", "\n", "}", "\n", "if", "code", "!=", "200", "{", "return", "user", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "code", ",", "raw", ")", "\n", "}", "\n", "dec", ":=", "json", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "raw", ")", ")", "\n", "dec", ".", "UseNumber", "(", ")", "\n", "if", "err", ":=", "dec", ".", "Decode", "(", "&", "user", ")", ";", "err", "!=", "nil", "{", "return", "user", ",", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ",", "raw", ")", "\n", "}", "\n", "return", "user", ",", "err", "\n", "}" ]

[ "GetActualUser", "gets", "an", "actual", "user", "." ]

[ "func", "NewDashlist", "(", "title", "string", ")", "*", "Panel", "{", "if", "title", "==", "\"", "\"", "{", "title", "=", "\"", "\"", "\n", "}", "\n", "render", ":=", "\"", "\"", "\n", "return", "&", "Panel", "{", "commonPanel", ":", "commonPanel", "{", "OfType", ":", "DashlistType", ",", "Title", ":", "title", ",", "Type", ":", "\"", "\"", ",", "Renderer", ":", "&", "render", ",", "IsNew", ":", "true", "}", ",", "DashlistPanel", ":", "&", "DashlistPanel", "{", "}", "}", "\n", "}" ]

[ "NewDashlist", "initializes", "panel", "with", "a", "dashlist", "panel", "." ]

[ "func", "NewGraph", "(", "title", "string", ")", "*", "Panel", "{", "if", "title", "==", "\"", "\"", "{", "title", "=", "\"", "\"", "\n", "}", "\n", "render", ":=", "\"", "\"", "\n", "return", "&", "Panel", "{", "commonPanel", ":", "commonPanel", "{", "OfType", ":", "GraphType", ",", "Title", ":", "title", ",", "Type", ":", "\"", "\"", ",", "Renderer", ":", "&", "render", ",", "Span", ":", "12", ",", "IsNew", ":", "true", "}", ",", "GraphPanel", ":", "&", "GraphPanel", "{", "NullPointMode", ":", "\"", "\"", ",", "Pointradius", ":", "5", ",", "XAxis", ":", "true", ",", "YAxis", ":", "true", ",", "}", "}", "\n", "}" ]

[ "NewGraph", "initializes", "panel", "with", "a", "graph", "panel", "." ]

[ "func", "NewTable", "(", "title", "string", ")", "*", "Panel", "{", "if", "title", "==", "\"", "\"", "{", "title", "=", "\"", "\"", "\n", "}", "\n", "render", ":=", "\"", "\"", "\n", "return", "&", "Panel", "{", "commonPanel", ":", "commonPanel", "{", "OfType", ":", "TableType", ",", "Title", ":", "title", ",", "Type", ":", "\"", "\"", ",", "Renderer", ":", "&", "render", ",", "IsNew", ":", "true", "}", ",", "TablePanel", ":", "&", "TablePanel", "{", "}", "}", "\n", "}" ]

[ "NewTable", "initializes", "panel", "with", "a", "table", "panel", "." ]

[ "func", "NewText", "(", "title", "string", ")", "*", "Panel", "{", "if", "title", "==", "\"", "\"", "{", "title", "=", "\"", "\"", "\n", "}", "\n", "render", ":=", "\"", "\"", "\n", "return", "&", "Panel", "{", "commonPanel", ":", "commonPanel", "{", "OfType", ":", "TextType", ",", "Title", ":", "title", ",", "Type", ":", "\"", "\"", ",", "Renderer", ":", "&", "render", ",", "IsNew", ":", "true", "}", ",", "TextPanel", ":", "&", "TextPanel", "{", "}", "}", "\n", "}" ]

[ "NewText", "initializes", "panel", "with", "a", "text", "panel", "." ]

[ "func", "NewSinglestat", "(", "title", "string", ")", "*", "Panel", "{", "if", "title", "==", "\"", "\"", "{", "title", "=", "\"", "\"", "\n", "}", "\n", "render", ":=", "\"", "\"", "\n", "return", "&", "Panel", "{", "commonPanel", ":", "commonPanel", "{", "OfType", ":", "SinglestatType", ",", "Title", ":", "title", ",", "Type", ":", "\"", "\"", ",", "Renderer", ":", "&", "render", ",", "IsNew", ":", "true", "}", ",", "SinglestatPanel", ":", "&", "SinglestatPanel", "{", "}", "}", "\n", "}" ]

[ "NewSinglestat", "initializes", "panel", "with", "a", "singlestat", "panel", "." ]

[ "func", "NewPluginlist", "(", "title", "string", ")", "*", "Panel", "{", "if", "title", "==", "\"", "\"", "{", "title", "=", "\"", "\"", "\n", "}", "\n", "render", ":=", "\"", "\"", "\n", "return", "&", "Panel", "{", "commonPanel", ":", "commonPanel", "{", "OfType", ":", "PluginlistType", ",", "Title", ":", "title", ",", "Type", ":", "\"", "\"", ",", "Renderer", ":", "&", "render", ",", "IsNew", ":", "true", "}", ",", "PluginlistPanel", ":", "&", "PluginlistPanel", "{", "}", "}", "\n", "}" ]

[ "NewPluginlist", "initializes", "panel", "with", "a", "singlestat", "panel", "." ]

[ "func", "NewCustom", "(", "title", "string", ")", "*", "Panel", "{", "if", "title", "==", "\"", "\"", "{", "title", "=", "\"", "\"", "\n", "}", "\n", "render", ":=", "\"", "\"", "\n", "return", "&", "Panel", "{", "commonPanel", ":", "commonPanel", "{", "OfType", ":", "CustomType", ",", "Title", ":", "title", ",", "Type", ":", "\"", "\"", ",", "Renderer", ":", "&", "render", ",", "IsNew", ":", "true", "}", ",", "CustomPanel", ":", "&", "CustomPanel", "{", "}", "}", "\n", "}" ]

[ "NewCustom", "initializes", "panel", "with", "a", "singlestat", "panel", "." ]

[ "func", "(", "p", "*", "Panel", ")", "ResetTargets", "(", ")", "{", "switch", "p", ".", "OfType", "{", "case", "GraphType", ":", "p", ".", "GraphPanel", ".", "Targets", "=", "nil", "\n", "case", "SinglestatType", ":", "p", ".", "SinglestatPanel", ".", "Targets", "=", "nil", "\n", "case", "TableType", ":", "p", ".", "TablePanel", ".", "Targets", "=", "nil", "\n", "}", "\n", "}" ]

[ "ResetTargets", "delete", "all", "targets", "defined", "for", "a", "panel", "." ]

[ "func", "(", "p", "*", "Panel", ")", "AddTarget", "(", "t", "*", "Target", ")", "{", "switch", "p", ".", "OfType", "{", "case", "GraphType", ":", "p", ".", "GraphPanel", ".", "Targets", "=", "append", "(", "p", ".", "GraphPanel", ".", "Targets", ",", "*", "t", ")", "\n", "case", "SinglestatType", ":", "p", ".", "SinglestatPanel", ".", "Targets", "=", "append", "(", "p", ".", "SinglestatPanel", ".", "Targets", ",", "*", "t", ")", "\n", "case", "TableType", ":", "p", ".", "TablePanel", ".", "Targets", "=", "append", "(", "p", ".", "TablePanel", ".", "Targets", ",", "*", "t", ")", "\n", "}", "\n", "// TODO check for existing refID", "}" ]

[ "AddTarget", "adds", "a", "new", "target", "as", "defined", "in", "the", "argument", "but", "with", "refId", "letter", "incremented", ".", "Value", "of", "refID", "from", "the", "argument", "will", "be", "used", "only", "if", "no", "target", "with", "such", "value", "already", "exists", "." ]

[ "func", "(", "p", "*", "Panel", ")", "SetTarget", "(", "t", "*", "Target", ")", "{", "setTarget", ":=", "func", "(", "t", "*", "Target", ",", "targets", "*", "[", "]", "Target", ")", "{", "for", "i", ",", "target", ":=", "range", "*", "targets", "{", "if", "t", ".", "RefID", "==", "target", ".", "RefID", "{", "(", "*", "targets", ")", "[", "i", "]", "=", "*", "t", "\n", "return", "\n", "}", "\n", "}", "\n", "(", "*", "targets", ")", "=", "append", "(", "(", "*", "targets", ")", ",", "*", "t", ")", "\n", "}", "\n", "switch", "p", ".", "OfType", "{", "case", "GraphType", ":", "setTarget", "(", "t", ",", "&", "p", ".", "GraphPanel", ".", "Targets", ")", "\n", "case", "SinglestatType", ":", "setTarget", "(", "t", ",", "&", "p", ".", "SinglestatPanel", ".", "Targets", ")", "\n", "case", "TableType", ":", "setTarget", "(", "t", ",", "&", "p", ".", "TablePanel", ".", "Targets", ")", "\n", "}", "\n", "}" ]

[ "SetTarget", "updates", "a", "target", "if", "target", "with", "such", "refId", "exists", "or", "creates", "a", "new", "one", "." ]

[ "func", "(", "p", "*", "Panel", ")", "RepeatDatasourcesForEachTarget", "(", "dsNames", "...", "string", ")", "{", "repeatDS", ":=", "func", "(", "dsNames", "[", "]", "string", ",", "targets", "*", "[", "]", "Target", ")", "{", "var", "refID", "=", "\"", "\"", "\n", "originalTargets", ":=", "*", "targets", "\n", "cleanedTargets", ":=", "make", "(", "[", "]", "Target", ",", "0", ",", "len", "(", "originalTargets", ")", "*", "len", "(", "dsNames", ")", ")", "\n", "*", "targets", "=", "cleanedTargets", "\n", "for", "_", ",", "target", ":=", "range", "originalTargets", "{", "for", "_", ",", "ds", ":=", "range", "dsNames", "{", "newTarget", ":=", "target", "\n", "newTarget", ".", "RefID", "=", "refID", "\n", "newTarget", ".", "Datasource", "=", "ds", "\n", "refID", "=", "incRefID", "(", "refID", ")", "\n", "*", "targets", "=", "append", "(", "*", "targets", ",", "newTarget", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "switch", "p", ".", "OfType", "{", "case", "GraphType", ":", "repeatDS", "(", "dsNames", ",", "&", "p", ".", "GraphPanel", ".", "Targets", ")", "\n", "case", "SinglestatType", ":", "repeatDS", "(", "dsNames", ",", "&", "p", ".", "SinglestatPanel", ".", "Targets", ")", "\n", "case", "TableType", ":", "repeatDS", "(", "dsNames", ",", "&", "p", ".", "TablePanel", ".", "Targets", ")", "\n", "}", "\n", "}" ]

[ "MapDatasources", "on", "all", "existing", "targets", "for", "the", "panel", "." ]

[ "func", "(", "p", "*", "Panel", ")", "RepeatTargetsForDatasources", "(", "dsNames", "...", "string", ")", "{", "repeatTarget", ":=", "func", "(", "dsNames", "[", "]", "string", ",", "targets", "*", "[", "]", "Target", ")", "{", "var", "lastRefID", "string", "\n", "lenTargets", ":=", "len", "(", "*", "targets", ")", "\n", "for", "i", ",", "name", ":=", "range", "dsNames", "{", "if", "i", "<", "lenTargets", "{", "(", "*", "targets", ")", "[", "i", "]", ".", "Datasource", "=", "name", "\n", "lastRefID", "=", "(", "*", "targets", ")", "[", "i", "]", ".", "RefID", "\n", "}", "else", "{", "newTarget", ":=", "(", "*", "targets", ")", "[", "i", "%", "lenTargets", "]", "\n", "lastRefID", "=", "incRefID", "(", "lastRefID", ")", "\n", "newTarget", ".", "RefID", "=", "lastRefID", "\n", "newTarget", ".", "Datasource", "=", "name", "\n", "*", "targets", "=", "append", "(", "*", "targets", ",", "newTarget", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "switch", "p", ".", "OfType", "{", "case", "GraphType", ":", "repeatTarget", "(", "dsNames", ",", "&", "p", ".", "GraphPanel", ".", "Targets", ")", "\n", "case", "SinglestatType", ":", "repeatTarget", "(", "dsNames", ",", "&", "p", ".", "SinglestatPanel", ".", "Targets", ")", "\n", "case", "TableType", ":", "repeatTarget", "(", "dsNames", ",", "&", "p", ".", "TablePanel", ".", "Targets", ")", "\n", "}", "\n", "}" ]

[ "RepeatTargetsForDatasources", "repeats", "all", "existing", "targets", "for", "a", "panel", "for", "all", "provided", "in", "the", "argument", "datasources", ".", "Existing", "datasources", "of", "targets", "are", "ignored", "." ]

[ "func", "(", "p", "*", "Panel", ")", "GetTargets", "(", ")", "*", "[", "]", "Target", "{", "switch", "p", ".", "OfType", "{", "case", "GraphType", ":", "return", "&", "p", ".", "GraphPanel", ".", "Targets", "\n", "case", "SinglestatType", ":", "return", "&", "p", ".", "SinglestatPanel", ".", "Targets", "\n", "case", "TableType", ":", "return", "&", "p", ".", "TablePanel", ".", "Targets", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}" ]

[ "GetTargets", "is", "iterate", "over", "all", "panel", "targets", ".", "It", "just", "returns", "nil", "if", "no", "targets", "defined", "for", "panel", "of", "concrete", "type", "." ]

[ "func", "(", "r", "*", "Client", ")", "SetDashboard", "(", "board", "Board", ",", "overwrite", "bool", ")", "error", "{", "var", "(", "isBoardFromDB", "bool", "\n", "newBoard", "struct", "{", "Dashboard", "Board", "`json:\"dashboard\"`", "\n", "Overwrite", "bool", "`json:\"overwrite\"`", "\n", "}", "\n", "raw", "[", "]", "byte", "\n", "resp", "StatusMessage", "\n", "code", "int", "\n", "err", "error", "\n", ")", "\n", "if", "board", ".", "Slug", ",", "isBoardFromDB", "=", "cleanPrefix", "(", "board", ".", "Slug", ")", ";", "!", "isBoardFromDB", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "newBoard", ".", "Dashboard", "=", "board", "\n", "newBoard", ".", "Overwrite", "=", "overwrite", "\n", "if", "!", "overwrite", "{", "newBoard", ".", "Dashboard", ".", "ID", "=", "0", "\n", "}", "\n", "if", "raw", ",", "err", "=", "json", ".", "Marshal", "(", "newBoard", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "raw", ",", "code", ",", "err", "=", "r", ".", "post", "(", "\"", "\"", ",", "nil", ",", "raw", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", "=", "json", ".", "Unmarshal", "(", "raw", ",", "&", "resp", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "switch", "code", "{", "case", "401", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "code", ",", "*", "resp", ".", "Message", ")", "\n", "case", "412", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "code", ",", "*", "resp", ".", "Message", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetDashboard", "updates", "existing", "dashboard", "or", "creates", "a", "new", "one", ".", "Set", "dasboard", "ID", "to", "nil", "to", "create", "a", "new", "dashboard", ".", "Set", "overwrite", "to", "true", "if", "you", "want", "to", "overwrite", "existing", "dashboard", "with", "newer", "version", "or", "with", "same", "dashboard", "title", ".", "Grafana", "only", "can", "create", "or", "update", "a", "dashboard", "in", "a", "database", ".", "File", "dashboards", "may", "be", "only", "loaded", "with", "HTTP", "API", "but", "not", "created", "or", "updated", "." ]

[ "func", "(", "r", "*", "Client", ")", "DeleteDashboard", "(", "slug", "string", ")", "(", "StatusMessage", ",", "error", ")", "{", "var", "(", "isBoardFromDB", "bool", "\n", "raw", "[", "]", "byte", "\n", "reply", "StatusMessage", "\n", "err", "error", "\n", ")", "\n", "if", "slug", ",", "isBoardFromDB", "=", "cleanPrefix", "(", "slug", ")", ";", "!", "isBoardFromDB", "{", "return", "StatusMessage", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "raw", ",", "_", ",", "err", "=", "r", ".", "delete", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "slug", ")", ")", ";", "err", "!=", "nil", "{", "return", "StatusMessage", "{", "}", ",", "err", "\n", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "raw", ",", "&", "reply", ")", "\n", "return", "reply", ",", "err", "\n", "}" ]

[ "DeleteDashboard", "deletes", "dashboard", "that", "selected", "by", "slug", "string", ".", "Grafana", "only", "can", "delete", "a", "dashboard", "in", "a", "database", ".", "File", "dashboards", "may", "be", "only", "loaded", "with", "HTTP", "API", "but", "not", "deteled", "." ]

[ "func", "setPrefix", "(", "slug", "string", ")", "(", "string", ",", "bool", ")", "{", "if", "strings", ".", "HasPrefix", "(", "slug", ",", "\"", "\"", ")", "{", "return", "slug", ",", "true", "\n", "}", "\n", "if", "strings", ".", "HasPrefix", "(", "slug", ",", "\"", "\"", ")", "{", "return", "slug", ",", "false", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "slug", ")", ",", "true", "\n", "}" ]

[ "implicitly", "use", "dashboards", "from", "Grafana", "DB", "not", "from", "a", "file", "system" ]

[ "func", "(", "v", "*", "IntString", ")", "UnmarshalJSON", "(", "raw", "[", "]", "byte", ")", "error", "{", "if", "raw", "==", "nil", "||", "bytes", ".", "Equal", "(", "raw", ",", "[", "]", "byte", "(", "`\"null\"`", ")", ")", "||", "bytes", ".", "Equal", "(", "raw", ",", "[", "]", "byte", "(", "`\"\"`", ")", ")", "{", "return", "nil", "\n", "}", "\n\n", "strVal", ":=", "string", "(", "raw", ")", "\n", "if", "rune", "(", "raw", "[", "0", "]", ")", "==", "'\"'", "{", "strVal", "=", "strings", ".", "Trim", "(", "strVal", ",", "`\"`", ")", "\n", "}", "\n\n", "i", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "strVal", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "v", ".", "Value", "=", "i", "\n", "v", ".", "Valid", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "UnmarshalJSON", "implements", "custom", "unmarshalling", "for", "IntString", "type" ]

[ "func", "(", "v", "*", "IntString", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "v", ".", "Valid", "{", "strVal", ":=", "strconv", ".", "FormatInt", "(", "v", ".", "Value", ",", "10", ")", "\n", "return", "[", "]", "byte", "(", "strVal", ")", ",", "nil", "\n", "}", "\n\n", "return", "[", "]", "byte", "(", "`\"null\"`", ")", ",", "nil", "\n", "}" ]

[ "MarshalJSON", "implements", "custom", "marshalling", "for", "IntString", "type" ]

[ "func", "(", "v", "*", "FloatString", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "v", ".", "Valid", "{", "strVal", ":=", "strconv", ".", "FormatFloat", "(", "v", ".", "Value", ",", "'g'", ",", "-", "1", ",", "64", ")", "\n", "return", "[", "]", "byte", "(", "strVal", ")", ",", "nil", "\n", "}", "\n\n", "return", "[", "]", "byte", "(", "`\"null\"`", ")", ",", "nil", "\n", "}" ]

[ "MarshalJSON", "implements", "custom", "marshalling", "for", "FloatString", "type" ]

[ "func", "NewDearmor62VerifyStream", "(", "versionValidator", "VersionValidator", ",", "r", "io", ".", "Reader", ",", "keyring", "SigKeyring", ")", "(", "skey", "SigningPublicKey", ",", "vs", "io", ".", "Reader", ",", "brand", "string", ",", "err", "error", ")", "{", "dearmored", ",", "frame", ",", "err", ":=", "NewArmor62DecoderStream", "(", "r", ",", "armor62SignatureHeaderChecker", ",", "armor62SignatureFrameChecker", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "skey", ",", "vs", ",", "err", "=", "NewVerifyStream", "(", "versionValidator", ",", "dearmored", ",", "keyring", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "brand", ",", "err", "=", "frame", ".", "GetBrand", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "skey", ",", "vs", ",", "brand", ",", "nil", "\n", "}" ]

[ "NewDearmor62VerifyStream", "creates", "a", "stream", "that", "consumes", "data", "from", "reader", "r", ".", "It", "returns", "the", "signer", "s", "public", "key", "and", "a", "reader", "that", "only", "contains", "verified", "data", ".", "If", "the", "signer", "s", "key", "is", "not", "in", "keyring", "it", "will", "return", "an", "error", ".", "It", "expects", "the", "data", "it", "reads", "from", "r", "to", "be", "armor62", "-", "encoded", "." ]

[ "func", "Dearmor62Verify", "(", "versionValidator", "VersionValidator", ",", "signedMsg", "string", ",", "keyring", "SigKeyring", ")", "(", "skey", "SigningPublicKey", ",", "verifiedMsg", "[", "]", "byte", ",", "brand", "string", ",", "err", "error", ")", "{", "skey", ",", "stream", ",", "brand", ",", "err", ":=", "NewDearmor62VerifyStream", "(", "versionValidator", ",", "bytes", ".", "NewBufferString", "(", "signedMsg", ")", ",", "keyring", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "verifiedMsg", ",", "err", "=", "ioutil", ".", "ReadAll", "(", "stream", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "skey", ",", "verifiedMsg", ",", "brand", ",", "nil", "\n", "}" ]

[ "Dearmor62Verify", "checks", "the", "signature", "in", "signedMsg", ".", "It", "returns", "the", "signer", "s", "public", "key", "and", "a", "verified", "message", ".", "It", "expects", "signedMsg", "to", "be", "armor62", "-", "encoded", "." ]

[ "func", "Dearmor62VerifyDetachedReader", "(", "versionValidator", "VersionValidator", ",", "r", "io", ".", "Reader", ",", "signature", "string", ",", "keyring", "SigKeyring", ")", "(", "skey", "SigningPublicKey", ",", "brand", "string", ",", "err", "error", ")", "{", "dearmored", ",", "brand", ",", "_", ",", "_", ",", "err", ":=", "Armor62OpenWithValidation", "(", "signature", ",", "armor62DetachedSignatureHeaderChecker", ",", "armor62DetachedSignatureFrameChecker", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "skey", ",", "err", "=", "VerifyDetachedReader", "(", "versionValidator", ",", "r", ",", "dearmored", ",", "keyring", ")", "\n", "return", "skey", ",", "brand", ",", "err", "\n", "}" ]

[ "Dearmor62VerifyDetachedReader", "verifies", "that", "signature", "is", "a", "valid", "armor62", "-", "encoded", "signature", "for", "entire", "message", "read", "from", "Reader", "and", "that", "the", "public", "key", "for", "the", "signer", "is", "in", "keyring", ".", "It", "returns", "the", "signer", "s", "public", "key", "." ]

[ "func", "Dearmor62VerifyDetached", "(", "versionValidator", "VersionValidator", ",", "message", "[", "]", "byte", ",", "signature", "string", ",", "keyring", "SigKeyring", ")", "(", "skey", "SigningPublicKey", ",", "brand", "string", ",", "err", "error", ")", "{", "return", "Dearmor62VerifyDetachedReader", "(", "versionValidator", ",", "bytes", ".", "NewReader", "(", "message", ")", ",", "signature", ",", "keyring", ")", "\n", "}" ]

[ "Dearmor62VerifyDetached", "verifies", "that", "signature", "is", "a", "valid", "armor62", "-", "encoded", "signature", "for", "message", "and", "that", "the", "public", "key", "for", "the", "signer", "is", "in", "keyring", ".", "It", "returns", "the", "signer", "s", "public", "key", "." ]

[ "func", "(", "sss", "*", "signcryptSealStream", ")", "init", "(", "receiverBoxKeys", "[", "]", "BoxPublicKey", ",", "receiverSymmetricKeys", "[", "]", "ReceiverSymmetricKey", ",", "ephemeralKeyCreator", "EphemeralKeyCreator", ",", "rng", "signcryptRNG", ")", "error", "{", "if", "err", ":=", "checkSigncryptReceivers", "(", "receiverBoxKeys", ",", "receiverSymmetricKeys", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "receivers", ",", "err", ":=", "rng", ".", "shuffleReceivers", "(", "receiverBoxKeys", ",", "receiverSymmetricKeys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ephemeralKey", ",", "err", ":=", "ephemeralKeyCreator", ".", "CreateEphemeralKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "eh", ":=", "SigncryptionHeader", "{", "FormatName", ":", "FormatName", ",", "Version", ":", "sss", ".", "version", ",", "Type", ":", "MessageTypeSigncryption", ",", "Ephemeral", ":", "ephemeralKey", ".", "GetPublicKey", "(", ")", ".", "ToKID", "(", ")", ",", "}", "\n", "encryptionKey", ",", "err", ":=", "rng", ".", "createSymmetricKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sss", ".", "encryptionKey", "=", "*", "encryptionKey", "\n\n", "// Prepare the secretbox that contains the sender's public key. If the", "// sender is anonymous, use an all-zeros key, so that the anonymity bit", "// doesn't leak out.", "nonce", ":=", "nonceForSenderKeySecretBox", "(", ")", "\n", "if", "sss", ".", "signingKey", "==", "nil", "{", "// anonymous sender mode, all zeros", "eh", ".", "SenderSecretbox", "=", "secretbox", ".", "Seal", "(", "[", "]", "byte", "{", "}", ",", "make", "(", "[", "]", "byte", ",", "ed25519", ".", "PublicKeySize", ")", ",", "(", "*", "[", "24", "]", "byte", ")", "(", "&", "nonce", ")", ",", "(", "*", "[", "32", "]", "byte", ")", "(", "&", "sss", ".", "encryptionKey", ")", ")", "\n", "}", "else", "{", "// regular sender mode, an actual key", "signingPublicKeyBytes", ":=", "sss", ".", "signingKey", ".", "GetPublicKey", "(", ")", ".", "ToKID", "(", ")", "\n", "if", "len", "(", "signingPublicKeyBytes", ")", "!=", "ed25519", ".", "PublicKeySize", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "eh", ".", "SenderSecretbox", "=", "secretbox", ".", "Seal", "(", "[", "]", "byte", "{", "}", ",", "sss", ".", "signingKey", ".", "GetPublicKey", "(", ")", ".", "ToKID", "(", ")", ",", "(", "*", "[", "24", "]", "byte", ")", "(", "&", "nonce", ")", ",", "(", "*", "[", "32", "]", "byte", ")", "(", "&", "sss", ".", "encryptionKey", ")", ")", "\n", "}", "\n\n", "// Collect all the recipient identifiers, and encrypt the payload key for", "// all of them.", "for", "i", ",", "r", ":=", "range", "receivers", "{", "eh", ".", "Receivers", "=", "append", "(", "eh", ".", "Receivers", ",", "r", ".", "makeReceiverKeys", "(", "ephemeralKey", ",", "sss", ".", "encryptionKey", ",", "uint64", "(", "i", ")", ")", ")", "\n", "}", "\n\n", "// Encode the header to bytes, hash it, then double encode it.", "headerBytes", ",", "err", ":=", "encodeToBytes", "(", "eh", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sss", ".", "headerHash", "=", "sha512", ".", "Sum512", "(", "headerBytes", ")", "\n", "err", "=", "sss", ".", "encoder", ".", "Encode", "(", "headerBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "This", "generates", "the", "payload", "key", "and", "encrypts", "it", "for", "all", "the", "different", "recipients", "of", "the", "two", "different", "types", ".", "Symmetric", "key", "recipients", "and", "DH", "key", "recipients", "use", "different", "types", "of", "identifiers", "but", "they", "are", "the", "same", "length", "and", "should", "both", "be", "indistinguishable", "from", "random", "noise", "." ]

[ "func", "NewSigncryptSealStream", "(", "ciphertext", "io", ".", "Writer", ",", "ephemeralKeyCreator", "EphemeralKeyCreator", ",", "sender", "SigningSecretKey", ",", "receiverBoxKeys", "[", "]", "BoxPublicKey", ",", "receiverSymmetricKeys", "[", "]", "ReceiverSymmetricKey", ")", "(", "io", ".", "WriteCloser", ",", "error", ")", "{", "return", "newSigncryptSealStream", "(", "ciphertext", ",", "sender", ",", "receiverBoxKeys", ",", "receiverSymmetricKeys", ",", "ephemeralKeyCreator", ",", "defaultSigncryptRNG", "{", "}", ")", "\n", "}" ]

[ "NewSigncryptSealStream", "creates", "a", "stream", "that", "consumes", "plaintext", "data", ".", "It", "will", "write", "out", "signed", "and", "encrypted", "data", "to", "the", "io", ".", "Writer", "passed", "in", "as", "ciphertext", ".", "The", "encryption", "is", "from", "the", "specified", "sender", "and", "is", "encrypted", "for", "the", "given", "receivers", ".", "ephemeralKeyCreator", "should", "be", "the", "last", "argument", ";", "it", "s", "the", "2nd", "one", "to", "preserve", "the", "public", "API", ".", "If", "initialization", "succeeds", "returns", "an", "io", ".", "WriteCloser", "that", "accepts", "plaintext", "data", "to", "be", "encrypted", "and", "a", "nil", "error", ".", "Otherwise", "returns", "nil", "and", "the", "initialization", "error", "." ]

[ "func", "SigncryptSeal", "(", "plaintext", "[", "]", "byte", ",", "ephemeralKeyCreator", "EphemeralKeyCreator", ",", "sender", "SigningSecretKey", ",", "receiverBoxKeys", "[", "]", "BoxPublicKey", ",", "receiverSymmetricKeys", "[", "]", "ReceiverSymmetricKey", ")", "(", "out", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "signcryptSeal", "(", "plaintext", ",", "sender", ",", "receiverBoxKeys", ",", "receiverSymmetricKeys", ",", "ephemeralKeyCreator", ",", "defaultSigncryptRNG", "{", "}", ")", "\n", "}" ]

[ "SigncryptSeal", "a", "plaintext", "from", "the", "given", "sender", "for", "the", "specified", "receiver", "groups", ".", "Returns", "a", "ciphertext", "or", "an", "error", "if", "something", "bad", "happened", ".", "ephemeralKeyCreator", "should", "be", "the", "last", "argument", ";", "it", "s", "the", "2nd", "one", "to", "preserve", "the", "public", "API", "." ]