Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "p", "*", "Process", ")", "Restore", "(", "r", "io", ".", "Reader", ")", "(", "*", "BackupInfo", ",", "error", ")", "{", "if", "err", ":=", "p", ".", "writeConfig", "(", "configData", "{", "}", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "p", ".", "unpackXbstream", "(", "r", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "backupInfo", ",", "err", ":=", "p", ".", "extractBackupInfo", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "p", ".", "restoreApplyLog", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "backupInfo", ",", "nil", "\n", "}" ]

[ "Restore", "restores", "the", "database", "from", "an", "xbstream", "backup", "." ]

[ "func", "(", "p", "*", "Process", ")", "DSN", "(", ")", "*", "DSN", "{", "return", "&", "DSN", "{", "Host", ":", "\"", "\"", "+", "p", ".", "Port", ",", "User", ":", "\"", "\"", ",", "Password", ":", "p", ".", "Password", ",", "Timeout", ":", "p", ".", "OpTimeout", ",", "}", "\n", "}" ]

[ "DSN", "returns", "the", "data", "source", "name", "for", "connecting", "to", "the", "local", "process", "as", "the", "flynn", "user", "." ]

[ "func", "(", "p", "*", "Process", ")", "nodeXLogPosition", "(", "dsn", "*", "DSN", ")", "(", "xlog", ".", "Position", ",", "error", ")", "{", "db", ",", "err", ":=", "sql", ".", "Open", "(", "\"", "\"", ",", "dsn", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "p", ".", "XLog", "(", ")", ".", "Zero", "(", ")", ",", "err", "\n", "}", "\n", "defer", "db", ".", "Close", "(", ")", "\n\n", "var", "gtid", "string", "\n", "if", "err", ":=", "db", ".", "QueryRow", "(", "`SELECT @@gtid_current_pos`", ")", ".", "Scan", "(", "&", "gtid", ")", ";", "err", "!=", "nil", "{", "return", "p", ".", "XLog", "(", ")", ".", "Zero", "(", ")", ",", "err", "\n", "}", "\n", "return", "xlog", ".", "Position", "(", "gtid", ")", ",", "nil", "\n\n", "}" ]

[ "XLogPosition", "returns", "the", "current", "XLogPosition", "of", "node", "specified", "by", "DSN", "." ]

[ "func", "(", "p", "*", "Process", ")", "installDB", "(", ")", "error", "{", "logger", ":=", "p", ".", "Logger", ".", "New", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "p", ".", "DataDir", ")", "\n", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// Ignore errors, since the db could be already initialized", "p", ".", "runCmd", "(", "exec", ".", "Command", "(", "filepath", ".", "Join", "(", "p", ".", "BinDir", ",", "\"", "\"", ")", ",", "\"", "\"", "+", "p", ".", "ConfigPath", "(", ")", ",", ")", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "installDB", "initializes", "the", "data", "directory", "for", "a", "new", "database", "." ]

[ "func", "(", "r", "*", "backupReadCloser", ")", "Close", "(", ")", "error", "{", "defer", "r", ".", "stdout", ".", "Close", "(", ")", "\n\n", "if", "err", ":=", "r", ".", "cmd", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Verify that innobackupex prints \"completed OK!\" at the end of STDERR.", "if", "!", "strings", ".", "HasSuffix", "(", "strings", ".", "TrimSpace", "(", "r", ".", "stderr", ".", "String", "(", ")", ")", ",", "\"", "\"", ")", "{", "r", ".", "stderr", ".", "WriteTo", "(", "os", ".", "Stderr", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Close", "waits", "for", "the", "backup", "command", "to", "finish", "and", "verifies", "that", "the", "backup", "completed", "successfully", "." ]

[ "func", "(", "r", "*", "backupReadCloser", ")", "Read", "(", "p", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "r", ".", "stdout", ".", "Read", "(", "p", ")", "\n", "}" ]

[ "Read", "reads", "n", "bytes", "of", "backup", "data", "into", "p", "." ]

[ "func", "(", "l", "*", "LibcontainerBackend", ")", "discoverdDial", "(", "network", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "host", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "strings", ".", "HasSuffix", "(", "host", ",", "\"", "\"", ")", "{", "// ensure discoverd is configured", "<-", "l", ".", "discoverdConfigured", "\n", "// lookup the service and pick a random address", "service", ":=", "strings", ".", "TrimSuffix", "(", "host", ",", "\"", "\"", ")", "\n", "addrs", ",", "err", ":=", "l", ".", "discoverdClient", ".", "Service", "(", "service", ")", ".", "Addrs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "len", "(", "addrs", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "host", ")", "\n", "}", "\n", "addr", "=", "addrs", "[", "random", ".", "Math", ".", "Intn", "(", "len", "(", "addrs", ")", ")", "]", "\n", "}", "\n", "return", "dialer", ".", "Default", ".", "Dial", "(", "network", ",", "addr", ")", "\n", "}" ]

[ "discoverdDial", "is", "a", "discoverd", "aware", "dialer", "which", "resolves", "a", "discoverd", "host", "to", "an", "address", "using", "the", "configured", "discoverd", "client", "as", "the", "host", "is", "likely", "not", "using", "discoverd", "to", "resolve", "DNS", "queries" ]

[ "func", "NewPostgresDataStore", "(", "routeType", "string", ",", "pgx", "*", "pgx", ".", "ConnPool", ")", "*", "pgDataStore", "{", "tableName", ":=", "\"", "\"", "\n", "switch", "routeType", "{", "case", "routeTypeHTTP", ":", "tableName", "=", "tableNameHTTP", "\n", "case", "routeTypeTCP", ":", "tableName", "=", "tableNameTCP", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "routeType", ")", ")", "\n", "}", "\n", "return", "&", "pgDataStore", "{", "pgx", ":", "pgx", ",", "routeType", ":", "routeType", ",", "tableName", ":", "tableName", ",", "}", "\n", "}" ]

[ "NewPostgresDataStore", "returns", "a", "DataStore", "that", "stores", "route", "information", "in", "a", "Postgres", "database", ".", "It", "uses", "pg_notify", "and", "a", "listener", "connection", "to", "watch", "for", "route", "changes", "." ]

[ "func", "updateImageIDs", "(", "env", "map", "[", "string", "]", "string", ")", "bool", "{", "updated", ":=", "false", "\n", "for", "prefix", ",", "newID", ":=", "range", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "redisImage", ".", "ID", ",", "\"", "\"", ":", "slugBuilder", ".", "ID", ",", "\"", "\"", ":", "slugRunner", ".", "ID", ",", "}", "{", "idKey", ":=", "prefix", "+", "\"", "\"", "\n", "if", "id", ",", "ok", ":=", "env", "[", "idKey", "]", ";", "ok", "&&", "id", "!=", "newID", "{", "env", "[", "idKey", "]", "=", "newID", "\n", "updated", "=", "true", "\n", "}", "\n\n", "uriKey", ":=", "prefix", "+", "\"", "\"", "\n", "if", "_", ",", "ok", ":=", "env", "[", "uriKey", "]", ";", "ok", "{", "delete", "(", "env", ",", "uriKey", ")", "\n", "env", "[", "idKey", "]", "=", "newID", "\n", "updated", "=", "true", "\n", "}", "\n", "}", "\n", "return", "updated", "\n", "}" ]

[ "updateImageIDs", "updates", "REDIS_IMAGE_ID", "SLUGBUILDER_IMAGE_ID", "and", "SLUGRUNNER_IMAGE_ID", "if", "they", "are", "set", "and", "have", "an", "old", "ID", "and", "also", "replaces", "the", "legacy", "REDIS_IMAGE_URI", "SLUGBUILDER_IMAGE_URI", "and", "SLUGRUNNER_IMAGE_URI" ]

[ "func", "(", "p", "PgXLog", ")", "Increment", "(", "pos", "xlog", ".", "Position", ",", "increment", "int", ")", "(", "xlog", ".", "Position", ",", "error", ")", "{", "parts", ",", "err", ":=", "parse", "(", "pos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "makePosition", "(", "parts", "[", "0", "]", ",", "parts", "[", "1", "]", "+", "increment", ")", ",", "nil", "\n", "}" ]

[ "Increment", "increments", "an", "xlog", "position", "by", "the", "given", "number", "." ]

[ "func", "parse", "(", "xlog", "xlog", ".", "Position", ")", "(", "res", "[", "2", "]", "int", ",", "err", "error", ")", "{", "parts", ":=", "strings", ".", "SplitN", "(", "string", "(", "xlog", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "xlog", ")", "\n", "return", "\n", "}", "\n\n", "res", "[", "0", "]", ",", "err", "=", "parseHex", "(", "parts", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "res", "[", "1", "]", ",", "err", "=", "parseHex", "(", "parts", "[", "1", "]", ")", "\n\n", "return", "\n", "}" ]

[ "parse", "takes", "an", "xlog", "position", "emitted", "by", "postgres", "and", "returns", "an", "array", "of", "two", "integers", "representing", "the", "filepart", "and", "offset", "components", "of", "the", "xlog", "position", ".", "This", "is", "an", "internal", "representation", "that", "should", "not", "be", "exposed", "outside", "of", "this", "package", "." ]

[ "func", "makePosition", "(", "filepart", "int", ",", "offset", "int", ")", "xlog", ".", "Position", "{", "return", "xlog", ".", "Position", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "filepart", ",", "offset", ")", ")", "\n", "}" ]

[ "MakePosition", "constructs", "an", "xlog", "position", "string", "from", "a", "numeric", "file", "part", "and", "offset", "." ]

[ "func", "parseProcID", "(", "procID", "[", "]", "byte", ")", "(", "string", ",", "string", ")", "{", "procTypeID", ":=", "strings", ".", "SplitN", "(", "string", "(", "procID", ")", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "procTypeID", ")", "==", "2", "{", "return", "procTypeID", "[", "1", "]", ",", "procTypeID", "[", "0", "]", "\n", "}", "\n", "return", "procTypeID", "[", "0", "]", ",", "\"", "\"", "\n", "}" ]

[ "Parses", "JobID", "and", "ProcType", "from", "header", "ProcID", "field", "Always", "returns", "JobID", "returns", "ProcType", "if", "available" ]

[ "func", "CheckScale", "(", "app", ",", "controllerKey", ",", "procName", "string", ",", "logger", "log15", ".", "Logger", ")", "(", "bool", ",", "error", ")", "{", "logger", "=", "logger", ".", "New", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "// Connect to controller.", "logger", ".", "Info", "(", "\"", "\"", ")", "\n", "client", ",", "err", ":=", "controller", ".", "NewClient", "(", "\"", "\"", ",", "controllerKey", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n\n", "// Retrieve app release.", "logger", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "app", ")", "\n", "release", ",", "err", ":=", "client", ".", "GetAppRelease", "(", "app", ")", "\n", "if", "err", "==", "controller", ".", "ErrNotFound", "{", "logger", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "app", ")", "\n", "return", "false", ",", "err", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logger", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "app", ",", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n\n", "// Retrieve current formation.", "logger", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "app", ",", "\"", "\"", ",", "release", ".", "ID", ")", "\n", "formation", ",", "err", ":=", "client", ".", "GetFormation", "(", "app", ",", "release", ".", "ID", ")", "\n", "if", "err", "==", "controller", ".", "ErrNotFound", "{", "logger", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "app", ",", "\"", "\"", ",", "release", ".", "ID", ")", "\n", "return", "false", ",", "err", "\n", "}", "else", "if", "err", "!=", "nil", "{", "logger", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "app", ",", "\"", "\"", ",", "release", ".", "ID", ",", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n\n", "// Database hasn't been scaled up yet", "if", "formation", ".", "Processes", "[", "procName", "]", "==", "0", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n\n", "}" ]

[ "CheckScale", "examines", "sirenia", "cluster", "formation", "to", "check", "if", "cluster", "has", "been", "scaled", "up", "yet", ".", "Returns", "true", "if", "scaled", "false", "if", "not", "." ]

[ "func", "(", "worker", "*", "Worker", ")", "Launch", "(", ")", "error", "{", "errorsChan", ":=", "make", "(", "chan", "error", ")", "\n\n", "worker", ".", "LaunchAsync", "(", "errorsChan", ")", "\n\n", "return", "<-", "errorsChan", "\n", "}" ]

[ "Launch", "starts", "a", "new", "worker", "process", ".", "The", "worker", "subscribes", "to", "the", "default", "queue", "and", "processes", "incoming", "registered", "tasks" ]

[ "func", "(", "worker", "*", "Worker", ")", "LaunchAsync", "(", "errorsChan", "chan", "<-", "error", ")", "{", "cnf", ":=", "worker", ".", "server", ".", "GetConfig", "(", ")", "\n", "broker", ":=", "worker", ".", "server", ".", "GetBroker", "(", ")", "\n\n", "// Log some useful information about worker configuration", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ")", "\n", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "Broker", ")", "\n", "if", "worker", ".", "Queue", "==", "\"", "\"", "{", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "DefaultQueue", ")", "\n", "}", "else", "{", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "worker", ".", "Queue", ")", "\n", "}", "\n", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "ResultBackend", ")", "\n", "if", "cnf", ".", "AMQP", "!=", "nil", "{", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "AMQP", ".", "Exchange", ")", "\n", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "AMQP", ".", "Exchange", ")", "\n", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "AMQP", ".", "ExchangeType", ")", "\n", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "AMQP", ".", "BindingKey", ")", "\n", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnf", ".", "AMQP", ".", "PrefetchCount", ")", "\n", "}", "\n\n", "// Goroutine to start broker consumption and handle retries when broker connection dies", "go", "func", "(", ")", "{", "for", "{", "retry", ",", "err", ":=", "broker", ".", "StartConsuming", "(", "worker", ".", "ConsumerTag", ",", "worker", ".", "Concurrency", ",", "worker", ")", "\n\n", "if", "retry", "{", "if", "worker", ".", "errorHandler", "!=", "nil", "{", "worker", ".", "errorHandler", "(", "err", ")", "\n", "}", "else", "{", "log", ".", "WARNING", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "errorsChan", "<-", "err", "// stop the goroutine", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "if", "!", "cnf", ".", "NoUnixSignals", "{", "sig", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "sig", ",", "os", ".", "Interrupt", ",", "syscall", ".", "SIGTERM", ")", "\n", "var", "signalsReceived", "uint", "\n\n", "// Goroutine Handle SIGINT and SIGTERM signals", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "s", ":=", "<-", "sig", ":", "log", ".", "WARNING", ".", "Printf", "(", "\"", "\"", ",", "s", ")", "\n", "signalsReceived", "++", "\n\n", "if", "signalsReceived", "<", "2", "{", "// After first Ctrl+C start quitting the worker gracefully", "log", ".", "WARNING", ".", "Print", "(", "\"", "\"", ")", "\n", "go", "func", "(", ")", "{", "worker", ".", "Quit", "(", ")", "\n", "errorsChan", "<-", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "(", ")", "\n", "}", "else", "{", "// Abort the program when user hits Ctrl+C second time in a row", "errorsChan", "<-", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "LaunchAsync", "is", "a", "non", "blocking", "version", "of", "Launch" ]

[ "func", "(", "worker", "*", "Worker", ")", "taskRetry", "(", "signature", "*", "tasks", ".", "Signature", ")", "error", "{", "// Update task state to RETRY", "if", "err", ":=", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "SetStateRetry", "(", "signature", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "signature", ".", "UUID", ",", "err", ")", "\n", "}", "\n\n", "// Decrement the retry counter, when it reaches 0, we won't retry again", "signature", ".", "RetryCount", "--", "\n\n", "// Increase retry timeout", "signature", ".", "RetryTimeout", "=", "retry", ".", "FibonacciNext", "(", "signature", ".", "RetryTimeout", ")", "\n\n", "// Delay task by signature.RetryTimeout seconds", "eta", ":=", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Add", "(", "time", ".", "Second", "*", "time", ".", "Duration", "(", "signature", ".", "RetryTimeout", ")", ")", "\n", "signature", ".", "ETA", "=", "&", "eta", "\n\n", "log", ".", "WARNING", ".", "Printf", "(", "\"", "\"", ",", "signature", ".", "UUID", ",", "signature", ".", "RetryTimeout", ")", "\n\n", "// Send the task back to the queue", "_", ",", "err", ":=", "worker", ".", "server", ".", "SendTask", "(", "signature", ")", "\n", "return", "err", "\n", "}" ]

[ "retryTask", "decrements", "RetryCount", "counter", "and", "republishes", "the", "task", "to", "the", "queue" ]

[ "func", "(", "worker", "*", "Worker", ")", "taskSucceeded", "(", "signature", "*", "tasks", ".", "Signature", ",", "taskResults", "[", "]", "*", "tasks", ".", "TaskResult", ")", "error", "{", "// Update task state to SUCCESS", "if", "err", ":=", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "SetStateSuccess", "(", "signature", ",", "taskResults", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "signature", ".", "UUID", ",", "err", ")", "\n", "}", "\n\n", "// Log human readable results of the processed task", "var", "debugResults", "=", "\"", "\"", "\n", "results", ",", "err", ":=", "tasks", ".", "ReflectTaskResults", "(", "taskResults", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WARNING", ".", "Print", "(", "err", ")", "\n", "}", "else", "{", "debugResults", "=", "tasks", ".", "HumanReadableResults", "(", "results", ")", "\n", "}", "\n", "log", ".", "DEBUG", ".", "Printf", "(", "\"", "\"", ",", "signature", ".", "UUID", ",", "debugResults", ")", "\n\n", "// Trigger success callbacks", "for", "_", ",", "successTask", ":=", "range", "signature", ".", "OnSuccess", "{", "if", "signature", ".", "Immutable", "==", "false", "{", "// Pass results of the task to success callbacks", "for", "_", ",", "taskResult", ":=", "range", "taskResults", "{", "successTask", ".", "Args", "=", "append", "(", "successTask", ".", "Args", ",", "tasks", ".", "Arg", "{", "Type", ":", "taskResult", ".", "Type", ",", "Value", ":", "taskResult", ".", "Value", ",", "}", ")", "\n", "}", "\n", "}", "\n\n", "worker", ".", "server", ".", "SendTask", "(", "successTask", ")", "\n", "}", "\n\n", "// If the task was not part of a group, just return", "if", "signature", ".", "GroupUUID", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "// Check if all task in the group has completed", "groupCompleted", ",", "err", ":=", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "GroupCompleted", "(", "signature", ".", "GroupUUID", ",", "signature", ".", "GroupTaskCount", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "signature", ".", "GroupUUID", ",", "err", ")", "\n", "}", "\n\n", "// If the group has not yet completed, just return", "if", "!", "groupCompleted", "{", "return", "nil", "\n", "}", "\n\n", "// Defer purging of group meta queue if we are using AMQP backend", "if", "worker", ".", "hasAMQPBackend", "(", ")", "{", "defer", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "PurgeGroupMeta", "(", "signature", ".", "GroupUUID", ")", "\n", "}", "\n\n", "// There is no chord callback, just return", "if", "signature", ".", "ChordCallback", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// Trigger chord callback", "shouldTrigger", ",", "err", ":=", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "TriggerChord", "(", "signature", ".", "GroupUUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "signature", ".", "GroupUUID", ",", "err", ")", "\n", "}", "\n\n", "// Chord has already been triggered", "if", "!", "shouldTrigger", "{", "return", "nil", "\n", "}", "\n\n", "// Get task states", "taskStates", ",", "err", ":=", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "GroupTaskStates", "(", "signature", ".", "GroupUUID", ",", "signature", ".", "GroupTaskCount", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// Append group tasks' return values to chord task if it's not immutable", "for", "_", ",", "taskState", ":=", "range", "taskStates", "{", "if", "!", "taskState", ".", "IsSuccess", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "signature", ".", "ChordCallback", ".", "Immutable", "==", "false", "{", "// Pass results of the task to the chord callback", "for", "_", ",", "taskResult", ":=", "range", "taskState", ".", "Results", "{", "signature", ".", "ChordCallback", ".", "Args", "=", "append", "(", "signature", ".", "ChordCallback", ".", "Args", ",", "tasks", ".", "Arg", "{", "Type", ":", "taskResult", ".", "Type", ",", "Value", ":", "taskResult", ".", "Value", ",", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Send the chord task", "_", ",", "err", "=", "worker", ".", "server", ".", "SendTask", "(", "signature", ".", "ChordCallback", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "taskSucceeded", "updates", "the", "task", "state", "and", "triggers", "success", "callbacks", "or", "a", "chord", "callback", "if", "this", "was", "the", "last", "task", "of", "a", "group", "with", "a", "chord", "callback" ]

[ "func", "(", "worker", "*", "Worker", ")", "taskFailed", "(", "signature", "*", "tasks", ".", "Signature", ",", "taskErr", "error", ")", "error", "{", "// Update task state to FAILURE", "if", "err", ":=", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "SetStateFailure", "(", "signature", ",", "taskErr", ".", "Error", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "signature", ".", "UUID", ",", "err", ")", "\n", "}", "\n\n", "if", "worker", ".", "errorHandler", "!=", "nil", "{", "worker", ".", "errorHandler", "(", "taskErr", ")", "\n", "}", "else", "{", "log", ".", "ERROR", ".", "Printf", "(", "\"", "\"", ",", "signature", ".", "UUID", ",", "taskErr", ")", "\n", "}", "\n\n", "// Trigger error callbacks", "for", "_", ",", "errorTask", ":=", "range", "signature", ".", "OnError", "{", "// Pass error as a first argument to error callbacks", "args", ":=", "append", "(", "[", "]", "tasks", ".", "Arg", "{", "{", "Type", ":", "\"", "\"", ",", "Value", ":", "taskErr", ".", "Error", "(", ")", ",", "}", "}", ",", "errorTask", ".", "Args", "...", ")", "\n", "errorTask", ".", "Args", "=", "args", "\n", "worker", ".", "server", ".", "SendTask", "(", "errorTask", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "taskFailed", "updates", "the", "task", "state", "and", "triggers", "error", "callbacks" ]

[ "func", "(", "worker", "*", "Worker", ")", "hasAMQPBackend", "(", ")", "bool", "{", "_", ",", "ok", ":=", "worker", ".", "server", ".", "GetBackend", "(", ")", ".", "(", "*", "amqp", ".", "Backend", ")", "\n", "return", "ok", "\n", "}" ]

[ "Returns", "true", "if", "the", "worker", "uses", "AMQP", "backend" ]

[ "func", "(", "ac", "*", "AMQPConnector", ")", "Connect", "(", "url", "string", ",", "tlsConfig", "*", "tls", ".", "Config", ",", "exchange", ",", "exchangeType", ",", "queueName", "string", ",", "queueDurable", ",", "queueDelete", "bool", ",", "queueBindingKey", "string", ",", "exchangeDeclareArgs", ",", "queueDeclareArgs", ",", "queueBindingArgs", "amqp", ".", "Table", ")", "(", "*", "amqp", ".", "Connection", ",", "*", "amqp", ".", "Channel", ",", "amqp", ".", "Queue", ",", "<-", "chan", "amqp", ".", "Confirmation", ",", "<-", "chan", "*", "amqp", ".", "Error", ",", "error", ")", "{", "// Connect to server", "conn", ",", "channel", ",", "err", ":=", "ac", ".", "Open", "(", "url", ",", "tlsConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "amqp", ".", "Queue", "{", "}", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "if", "exchange", "!=", "\"", "\"", "{", "// Declare an exchange", "if", "err", "=", "channel", ".", "ExchangeDeclare", "(", "exchange", ",", "// name of the exchange", "exchangeType", ",", "// type", "true", ",", "// durable", "false", ",", "// delete when complete", "false", ",", "// internal", "false", ",", "// noWait", "exchangeDeclareArgs", ",", "// arguments", ")", ";", "err", "!=", "nil", "{", "return", "conn", ",", "channel", ",", "amqp", ".", "Queue", "{", "}", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "var", "queue", "amqp", ".", "Queue", "\n", "if", "queueName", "!=", "\"", "\"", "{", "// Declare a queue", "queue", ",", "err", "=", "channel", ".", "QueueDeclare", "(", "queueName", ",", "// name", "queueDurable", ",", "// durable", "queueDelete", ",", "// delete when unused", "false", ",", "// exclusive", "false", ",", "// no-wait", "queueDeclareArgs", ",", "// arguments", ")", "\n", "if", "err", "!=", "nil", "{", "return", "conn", ",", "channel", ",", "amqp", ".", "Queue", "{", "}", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Bind the queue", "if", "err", "=", "channel", ".", "QueueBind", "(", "queue", ".", "Name", ",", "// name of the queue", "queueBindingKey", ",", "// binding key", "exchange", ",", "// source exchange", "false", ",", "// noWait", "queueBindingArgs", ",", "// arguments", ")", ";", "err", "!=", "nil", "{", "return", "conn", ",", "channel", ",", "queue", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// Enable publish confirmations", "if", "err", "=", "channel", ".", "Confirm", "(", "false", ")", ";", "err", "!=", "nil", "{", "return", "conn", ",", "channel", ",", "queue", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "conn", ",", "channel", ",", "queue", ",", "channel", ".", "NotifyPublish", "(", "make", "(", "chan", "amqp", ".", "Confirmation", ",", "1", ")", ")", ",", "conn", ".", "NotifyClose", "(", "make", "(", "chan", "*", "amqp", ".", "Error", ",", "1", ")", ")", ",", "nil", "\n", "}" ]

[ "Connect", "opens", "a", "connection", "to", "RabbitMQ", "declares", "an", "exchange", "opens", "a", "channel", "declares", "and", "binds", "the", "queue", "and", "enables", "publish", "notifications" ]

[ "func", "(", "ac", "*", "AMQPConnector", ")", "DeleteQueue", "(", "channel", "*", "amqp", ".", "Channel", ",", "queueName", "string", ")", "error", "{", "// First return value is number of messages removed", "_", ",", "err", ":=", "channel", ".", "QueueDelete", "(", "queueName", ",", "// name", "false", ",", "// ifUnused", "false", ",", "// ifEmpty", "false", ",", "// noWait", ")", "\n\n", "return", "err", "\n", "}" ]

[ "DeleteQueue", "deletes", "a", "queue", "by", "name" ]

[ "func", "(", "*", "AMQPConnector", ")", "InspectQueue", "(", "channel", "*", "amqp", ".", "Channel", ",", "queueName", "string", ")", "(", "*", "amqp", ".", "Queue", ",", "error", ")", "{", "queueState", ",", "err", ":=", "channel", ".", "QueueInspect", "(", "queueName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "&", "queueState", ",", "nil", "\n", "}" ]

[ "InspectQueue", "provides", "information", "about", "a", "specific", "queue" ]

[ "func", "(", "ac", "*", "AMQPConnector", ")", "Open", "(", "url", "string", ",", "tlsConfig", "*", "tls", ".", "Config", ")", "(", "*", "amqp", ".", "Connection", ",", "*", "amqp", ".", "Channel", ",", "error", ")", "{", "// Connect", "// From amqp docs: DialTLS will use the provided tls.Config when it encounters an amqps:// scheme", "// and will dial a plain connection when it encounters an amqp:// scheme.", "conn", ",", "err", ":=", "amqp", ".", "DialTLS", "(", "url", ",", "tlsConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Open a channel", "channel", ",", "err", ":=", "conn", ".", "Channel", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "conn", ",", "channel", ",", "nil", "\n", "}" ]

[ "Open", "new", "RabbitMQ", "connection" ]

[ "func", "SignatureFromContext", "(", "ctx", "context", ".", "Context", ")", "*", "Signature", "{", "if", "ctx", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "v", ":=", "ctx", ".", "Value", "(", "signatureCtx", ")", "\n", "if", "v", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "signature", ",", "_", ":=", "v", ".", "(", "*", "Signature", ")", "\n", "return", "signature", "\n", "}" ]

[ "SignatureFromContext", "gets", "the", "signature", "from", "the", "context" ]

[ "func", "NewWithSignature", "(", "taskFunc", "interface", "{", "}", ",", "signature", "*", "Signature", ")", "(", "*", "Task", ",", "error", ")", "{", "args", ":=", "signature", ".", "Args", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "signatureCtx", ",", "signature", ")", "\n", "task", ":=", "&", "Task", "{", "TaskFunc", ":", "reflect", ".", "ValueOf", "(", "taskFunc", ")", ",", "Context", ":", "ctx", ",", "}", "\n\n", "taskFuncType", ":=", "reflect", ".", "TypeOf", "(", "taskFunc", ")", "\n", "if", "taskFuncType", ".", "NumIn", "(", ")", ">", "0", "{", "arg0Type", ":=", "taskFuncType", ".", "In", "(", "0", ")", "\n", "if", "IsContextType", "(", "arg0Type", ")", "{", "task", ".", "UseContext", "=", "true", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "task", ".", "ReflectArgs", "(", "args", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "task", ",", "nil", "\n", "}" ]

[ "NewWithSignature", "is", "the", "same", "as", "New", "but", "injects", "the", "signature" ]

[ "func", "New", "(", "taskFunc", "interface", "{", "}", ",", "args", "[", "]", "Arg", ")", "(", "*", "Task", ",", "error", ")", "{", "task", ":=", "&", "Task", "{", "TaskFunc", ":", "reflect", ".", "ValueOf", "(", "taskFunc", ")", ",", "Context", ":", "context", ".", "Background", "(", ")", ",", "}", "\n\n", "taskFuncType", ":=", "reflect", ".", "TypeOf", "(", "taskFunc", ")", "\n", "if", "taskFuncType", ".", "NumIn", "(", ")", ">", "0", "{", "arg0Type", ":=", "taskFuncType", ".", "In", "(", "0", ")", "\n", "if", "IsContextType", "(", "arg0Type", ")", "{", "task", ".", "UseContext", "=", "true", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "task", ".", "ReflectArgs", "(", "args", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "task", ",", "nil", "\n", "}" ]

[ "New", "tries", "to", "use", "reflection", "to", "convert", "the", "function", "and", "arguments", "into", "a", "reflect", ".", "Value", "and", "prepare", "it", "for", "invocation" ]

[ "func", "StartSpanFromHeaders", "(", "headers", "tasks", ".", "Headers", ",", "operationName", "string", ")", "opentracing", ".", "Span", "{", "// Try to extract the span context from the carrier.", "spanContext", ",", "err", ":=", "opentracing", ".", "GlobalTracer", "(", ")", ".", "Extract", "(", "opentracing", ".", "TextMap", ",", "headers", ")", "\n\n", "// Create a new span from the span context if found or start a new trace with the function name.", "// For clarity add the machinery component tag.", "span", ":=", "opentracing", ".", "StartSpan", "(", "operationName", ",", "ConsumerOption", "(", "spanContext", ")", ",", "MachineryTag", ",", ")", "\n\n", "// Log any error but don't fail", "if", "err", "!=", "nil", "{", "span", ".", "LogFields", "(", "opentracing_log", ".", "Error", "(", "err", ")", ")", "\n", "}", "\n\n", "return", "span", "\n", "}" ]

[ "StartSpanFromHeaders", "will", "extract", "a", "span", "from", "the", "signature", "headers", "and", "start", "a", "new", "span", "with", "the", "given", "operation", "name", "." ]

[ "func", "HeadersWithSpan", "(", "headers", "tasks", ".", "Headers", ",", "span", "opentracing", ".", "Span", ")", "tasks", ".", "Headers", "{", "// check if the headers aren't nil", "if", "headers", "==", "nil", "{", "headers", "=", "make", "(", "tasks", ".", "Headers", ")", "\n", "}", "\n\n", "if", "err", ":=", "opentracing", ".", "GlobalTracer", "(", ")", ".", "Inject", "(", "span", ".", "Context", "(", ")", ",", "opentracing", ".", "TextMap", ",", "headers", ")", ";", "err", "!=", "nil", "{", "span", ".", "LogFields", "(", "opentracing_log", ".", "Error", "(", "err", ")", ")", "\n", "}", "\n\n", "return", "headers", "\n", "}" ]

[ "HeadersWithSpan", "will", "inject", "a", "span", "into", "the", "signature", "headers" ]

[ "func", "(", "b", "*", "Broker", ")", "consume", "(", "deliveries", "<-", "chan", "*", "awssqs", ".", "ReceiveMessageOutput", ",", "concurrency", "int", ",", "taskProcessor", "iface", ".", "TaskProcessor", ")", "error", "{", "pool", ":=", "make", "(", "chan", "struct", "{", "}", ",", "concurrency", ")", "\n\n", "// initialize worker pool with maxWorkers workers", "go", "func", "(", ")", "{", "b", ".", "initializePool", "(", "pool", ",", "concurrency", ")", "\n", "}", "(", ")", "\n\n", "errorsChan", ":=", "make", "(", "chan", "error", ")", "\n\n", "for", "{", "whetherContinue", ",", "err", ":=", "b", ".", "consumeDeliveries", "(", "deliveries", ",", "concurrency", ",", "taskProcessor", ",", "pool", ",", "errorsChan", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "whetherContinue", "==", "false", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "consume", "is", "a", "method", "which", "keeps", "consuming", "deliveries", "from", "a", "channel", "until", "there", "is", "an", "error", "or", "a", "stop", "signal" ]

[ "func", "(", "b", "*", "Broker", ")", "consumeOne", "(", "delivery", "*", "awssqs", ".", "ReceiveMessageOutput", ",", "taskProcessor", "iface", ".", "TaskProcessor", ")", "error", "{", "if", "len", "(", "delivery", ".", "Messages", ")", "==", "0", "{", "log", ".", "ERROR", ".", "Printf", "(", "\"", "\"", ",", "delivery", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", "+", "delivery", ".", "GoString", "(", ")", ")", "\n", "}", "\n\n", "sig", ":=", "new", "(", "tasks", ".", "Signature", ")", "\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "strings", ".", "NewReader", "(", "*", "delivery", ".", "Messages", "[", "0", "]", ".", "Body", ")", ")", "\n", "decoder", ".", "UseNumber", "(", ")", "\n", "if", "err", ":=", "decoder", ".", "Decode", "(", "sig", ")", ";", "err", "!=", "nil", "{", "log", ".", "ERROR", ".", "Printf", "(", "\"", "\"", ",", "delivery", ")", "\n", "return", "err", "\n", "}", "\n\n", "// If the task is not registered return an error", "// and leave the message in the queue", "if", "!", "b", ".", "IsTaskRegistered", "(", "sig", ".", "Name", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sig", ".", "Name", ")", "\n", "}", "\n\n", "err", ":=", "taskProcessor", ".", "Process", "(", "sig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Delete message after successfully consuming and processing the message", "if", "err", "=", "b", ".", "deleteOne", "(", "delivery", ")", ";", "err", "!=", "nil", "{", "log", ".", "ERROR", ".", "Printf", "(", "\"", "\"", ",", "delivery", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "consumeOne", "is", "a", "method", "consumes", "a", "delivery", ".", "If", "a", "delivery", "was", "consumed", "successfully", "it", "will", "be", "deleted", "from", "AWS", "SQS" ]

[ "func", "(", "b", "*", "Broker", ")", "deleteOne", "(", "delivery", "*", "awssqs", ".", "ReceiveMessageOutput", ")", "error", "{", "qURL", ":=", "b", ".", "defaultQueueURL", "(", ")", "\n", "_", ",", "err", ":=", "b", ".", "service", ".", "DeleteMessage", "(", "&", "awssqs", ".", "DeleteMessageInput", "{", "QueueUrl", ":", "qURL", ",", "ReceiptHandle", ":", "delivery", ".", "Messages", "[", "0", "]", ".", "ReceiptHandle", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "deleteOne", "is", "a", "method", "delete", "a", "delivery", "from", "AWS", "SQS" ]

[ "func", "(", "b", "*", "Broker", ")", "defaultQueueURL", "(", ")", "*", "string", "{", "if", "b", ".", "queueUrl", "!=", "nil", "{", "return", "b", ".", "queueUrl", "\n", "}", "else", "{", "return", "aws", ".", "String", "(", "b", ".", "GetConfig", "(", ")", ".", "Broker", "+", "\"", "\"", "+", "b", ".", "GetConfig", "(", ")", ".", "DefaultQueue", ")", "\n", "}", "\n\n", "}" ]

[ "defaultQueueURL", "is", "a", "method", "returns", "the", "default", "queue", "url" ]

[ "func", "(", "b", "*", "Broker", ")", "receiveMessage", "(", "qURL", "*", "string", ")", "(", "*", "awssqs", ".", "ReceiveMessageOutput", ",", "error", ")", "{", "var", "waitTimeSeconds", "int", "\n", "var", "visibilityTimeout", "*", "int", "\n", "if", "b", ".", "GetConfig", "(", ")", ".", "SQS", "!=", "nil", "{", "waitTimeSeconds", "=", "b", ".", "GetConfig", "(", ")", ".", "SQS", ".", "WaitTimeSeconds", "\n", "visibilityTimeout", "=", "b", ".", "GetConfig", "(", ")", ".", "SQS", ".", "VisibilityTimeout", "\n", "}", "else", "{", "waitTimeSeconds", "=", "0", "\n", "}", "\n", "input", ":=", "&", "awssqs", ".", "ReceiveMessageInput", "{", "AttributeNames", ":", "[", "]", "*", "string", "{", "aws", ".", "String", "(", "awssqs", ".", "MessageSystemAttributeNameSentTimestamp", ")", ",", "}", ",", "MessageAttributeNames", ":", "[", "]", "*", "string", "{", "aws", ".", "String", "(", "awssqs", ".", "QueueAttributeNameAll", ")", ",", "}", ",", "QueueUrl", ":", "qURL", ",", "MaxNumberOfMessages", ":", "aws", ".", "Int64", "(", "1", ")", ",", "WaitTimeSeconds", ":", "aws", ".", "Int64", "(", "int64", "(", "waitTimeSeconds", ")", ")", ",", "}", "\n", "if", "visibilityTimeout", "!=", "nil", "{", "input", ".", "VisibilityTimeout", "=", "aws", ".", "Int64", "(", "int64", "(", "*", "visibilityTimeout", ")", ")", "\n", "}", "\n", "result", ",", "err", ":=", "b", ".", "service", ".", "ReceiveMessage", "(", "input", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "receiveMessage", "is", "a", "method", "receives", "a", "message", "from", "specified", "queue", "url" ]

[ "func", "(", "b", "*", "Broker", ")", "initializePool", "(", "pool", "chan", "struct", "{", "}", ",", "concurrency", "int", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "concurrency", ";", "i", "++", "{", "pool", "<-", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}" ]

[ "initializePool", "is", "a", "method", "which", "initializes", "concurrency", "pool" ]

[ "func", "(", "b", "*", "Broker", ")", "consumeDeliveries", "(", "deliveries", "<-", "chan", "*", "awssqs", ".", "ReceiveMessageOutput", ",", "concurrency", "int", ",", "taskProcessor", "iface", ".", "TaskProcessor", ",", "pool", "chan", "struct", "{", "}", ",", "errorsChan", "chan", "error", ")", "(", "bool", ",", "error", ")", "{", "select", "{", "case", "err", ":=", "<-", "errorsChan", ":", "return", "false", ",", "err", "\n", "case", "d", ":=", "<-", "deliveries", ":", "if", "concurrency", ">", "0", "{", "// get worker from pool (blocks until one is available)", "<-", "pool", "\n", "}", "\n\n", "b", ".", "processingWG", ".", "Add", "(", "1", ")", "\n\n", "// Consume the task inside a goroutine so multiple tasks", "// can be processed concurrently", "go", "func", "(", ")", "{", "if", "err", ":=", "b", ".", "consumeOne", "(", "d", ",", "taskProcessor", ")", ";", "err", "!=", "nil", "{", "errorsChan", "<-", "err", "\n", "}", "\n\n", "b", ".", "processingWG", ".", "Done", "(", ")", "\n\n", "if", "concurrency", ">", "0", "{", "// give worker back to pool", "pool", "<-", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "(", ")", "\n", "case", "<-", "b", ".", "GetStopChan", "(", ")", ":", "return", "false", ",", "nil", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "consumeDeliveries", "is", "a", "method", "consuming", "deliveries", "from", "deliveries", "channel" ]

[ "func", "(", "b", "*", "Broker", ")", "continueReceivingMessages", "(", "qURL", "*", "string", ",", "deliveries", "chan", "*", "awssqs", ".", "ReceiveMessageOutput", ")", "(", "bool", ",", "error", ")", "{", "select", "{", "// A way to stop this goroutine from b.StopConsuming", "case", "<-", "b", ".", "stopReceivingChan", ":", "return", "false", ",", "nil", "\n", "default", ":", "output", ",", "err", ":=", "b", ".", "receiveMessage", "(", "qURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "true", ",", "err", "\n", "}", "\n", "if", "len", "(", "output", ".", "Messages", ")", "==", "0", "{", "return", "true", ",", "nil", "\n", "}", "\n", "go", "func", "(", ")", "{", "deliveries", "<-", "output", "}", "(", ")", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "continueReceivingMessages", "is", "a", "method", "returns", "a", "continue", "signal" ]

[ "func", "(", "b", "*", "Broker", ")", "getQueueURL", "(", "taskProcessor", "iface", ".", "TaskProcessor", ")", "*", "string", "{", "queueName", ":=", "b", ".", "GetConfig", "(", ")", ".", "DefaultQueue", "\n", "if", "taskProcessor", ".", "CustomQueue", "(", ")", "!=", "\"", "\"", "{", "queueName", "=", "taskProcessor", ".", "CustomQueue", "(", ")", "\n", "}", "\n\n", "return", "aws", ".", "String", "(", "b", ".", "GetConfig", "(", ")", ".", "Broker", "+", "\"", "\"", "+", "queueName", ")", "\n", "}" ]

[ "getQueueURL", "is", "a", "method", "returns", "that", "returns", "queueURL", "first", "by", "checking", "if", "custom", "queue", "was", "set", "and", "usign", "it", "otherwise", "using", "default", "queueName", "from", "config" ]

[ "func", "(", "group", "*", "Group", ")", "GetUUIDs", "(", ")", "[", "]", "string", "{", "taskUUIDs", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "group", ".", "Tasks", ")", ")", "\n", "for", "i", ",", "signature", ":=", "range", "group", ".", "Tasks", "{", "taskUUIDs", "[", "i", "]", "=", "signature", ".", "UUID", "\n", "}", "\n", "return", "taskUUIDs", "\n", "}" ]

[ "GetUUIDs", "returns", "slice", "of", "task", "UUIDS" ]

[ "func", "NewChain", "(", "signatures", "...", "*", "Signature", ")", "(", "*", "Chain", ",", "error", ")", "{", "// Auto generate task UUIDs if needed", "for", "_", ",", "signature", ":=", "range", "signatures", "{", "if", "signature", ".", "UUID", "==", "\"", "\"", "{", "signatureID", ":=", "uuid", ".", "New", "(", ")", ".", "String", "(", ")", "\n", "signature", ".", "UUID", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "signatureID", ")", "\n", "}", "\n", "}", "\n\n", "for", "i", ":=", "len", "(", "signatures", ")", "-", "1", ";", "i", ">", "0", ";", "i", "--", "{", "if", "i", ">", "0", "{", "signatures", "[", "i", "-", "1", "]", ".", "OnSuccess", "=", "[", "]", "*", "Signature", "{", "signatures", "[", "i", "]", "}", "\n", "}", "\n", "}", "\n\n", "chain", ":=", "&", "Chain", "{", "Tasks", ":", "signatures", "}", "\n\n", "return", "chain", ",", "nil", "\n", "}" ]

[ "NewChain", "creates", "a", "new", "chain", "of", "tasks", "to", "be", "processed", "one", "by", "one", "passing", "results", "unless", "task", "signatures", "are", "set", "to", "be", "immutable" ]

[ "func", "NewGroup", "(", "signatures", "...", "*", "Signature", ")", "(", "*", "Group", ",", "error", ")", "{", "// Generate a group UUID", "groupUUID", ":=", "uuid", ".", "New", "(", ")", ".", "String", "(", ")", "\n", "groupID", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "groupUUID", ")", "\n\n", "// Auto generate task UUIDs if needed, group tasks by common group UUID", "for", "_", ",", "signature", ":=", "range", "signatures", "{", "if", "signature", ".", "UUID", "==", "\"", "\"", "{", "signatureID", ":=", "uuid", ".", "New", "(", ")", ".", "String", "(", ")", "\n", "signature", ".", "UUID", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "signatureID", ")", "\n", "}", "\n", "signature", ".", "GroupUUID", "=", "groupID", "\n", "signature", ".", "GroupTaskCount", "=", "len", "(", "signatures", ")", "\n", "}", "\n\n", "return", "&", "Group", "{", "GroupUUID", ":", "groupID", ",", "Tasks", ":", "signatures", ",", "}", ",", "nil", "\n", "}" ]

[ "NewGroup", "creates", "a", "new", "group", "of", "tasks", "to", "be", "processed", "in", "parallel" ]

[ "func", "(", "b", "*", "Backend", ")", "GetState", "(", "taskUUID", "string", ")", "(", "*", "tasks", ".", "TaskState", ",", "error", ")", "{", "declareQueueArgs", ":=", "amqp", ".", "Table", "{", "// Time in milliseconds", "// after that message will expire", "\"", "\"", ":", "int32", "(", "b", ".", "getExpiresIn", "(", ")", ")", ",", "// Time after that the queue will be deleted.", "\"", "\"", ":", "int32", "(", "b", ".", "getExpiresIn", "(", ")", ")", ",", "}", "\n", "conn", ",", "channel", ",", "_", ",", "_", ",", "_", ",", "err", ":=", "b", ".", "Connect", "(", "b", ".", "GetConfig", "(", ")", ".", "Broker", ",", "b", ".", "GetConfig", "(", ")", ".", "TLSConfig", ",", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "Exchange", ",", "// exchange name", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "ExchangeType", ",", "// exchange type", "taskUUID", ",", "// queue name", "false", ",", "// queue durable", "true", ",", "// queue delete when unused", "taskUUID", ",", "// queue binding key", "nil", ",", "// exchange declare args", "declareQueueArgs", ",", "// queue declare args", "nil", ",", "// queue binding args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "b", ".", "Close", "(", "channel", ",", "conn", ")", "\n\n", "d", ",", "ok", ",", "err", ":=", "channel", ".", "Get", "(", "taskUUID", ",", "// queue name", "false", ",", "// multiple", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "d", ".", "Ack", "(", "false", ")", "\n\n", "state", ":=", "new", "(", "tasks", ".", "TaskState", ")", "\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "[", "]", "byte", "(", "d", ".", "Body", ")", ")", ")", "\n", "decoder", ".", "UseNumber", "(", ")", "\n", "if", "err", ":=", "decoder", ".", "Decode", "(", "state", ")", ";", "err", "!=", "nil", "{", "log", ".", "ERROR", ".", "Printf", "(", "\"", "\"", ",", "string", "(", "d", ".", "Body", ")", ")", "\n", "log", ".", "ERROR", ".", "Print", "(", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "state", ",", "nil", "\n", "}" ]

[ "GetState", "returns", "the", "latest", "task", "state", ".", "It", "will", "only", "return", "the", "status", "once", "as", "the", "message", "will", "get", "consumed", "and", "removed", "from", "the", "queue", "." ]

[ "func", "(", "b", "*", "Backend", ")", "getExpiresIn", "(", ")", "int", "{", "resultsExpireIn", ":=", "b", ".", "GetConfig", "(", ")", ".", "ResultsExpireIn", "*", "1000", "\n", "if", "resultsExpireIn", "==", "0", "{", "// // expire results after 1 hour by default", "resultsExpireIn", "=", "config", ".", "DefaultResultsExpireIn", "*", "1000", "\n", "}", "\n", "return", "resultsExpireIn", "\n", "}" ]

[ "getExpiresIn", "returns", "expiration", "time" ]

[ "func", "(", "rc", "*", "RedisConnector", ")", "NewPool", "(", "socketPath", ",", "host", ",", "password", "string", ",", "db", "int", ",", "cnf", "*", "config", ".", "RedisConfig", ",", "tlsConfig", "*", "tls", ".", "Config", ")", "*", "redis", ".", "Pool", "{", "if", "cnf", "==", "nil", "{", "cnf", "=", "defaultConfig", "\n", "}", "\n", "return", "&", "redis", ".", "Pool", "{", "MaxIdle", ":", "cnf", ".", "MaxIdle", ",", "IdleTimeout", ":", "time", ".", "Duration", "(", "cnf", ".", "IdleTimeout", ")", "*", "time", ".", "Second", ",", "MaxActive", ":", "cnf", ".", "MaxActive", ",", "Wait", ":", "cnf", ".", "Wait", ",", "Dial", ":", "func", "(", ")", "(", "redis", ".", "Conn", ",", "error", ")", "{", "c", ",", "err", ":=", "rc", ".", "open", "(", "socketPath", ",", "host", ",", "password", ",", "db", ",", "cnf", ",", "tlsConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "db", "!=", "0", "{", "_", ",", "err", "=", "c", ".", "Do", "(", "\"", "\"", ",", "db", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "c", ",", "err", "\n", "}", ",", "// PINGs connections that have been idle more than 10 seconds", "TestOnBorrow", ":", "func", "(", "c", "redis", ".", "Conn", ",", "t", "time", ".", "Time", ")", "error", "{", "if", "time", ".", "Since", "(", "t", ")", "<", "time", ".", "Duration", "(", "10", "*", "time", ".", "Second", ")", "{", "return", "nil", "\n", "}", "\n", "_", ",", "err", ":=", "c", ".", "Do", "(", "\"", "\"", ")", "\n", "return", "err", "\n", "}", ",", "}", "\n", "}" ]

[ "NewPool", "returns", "a", "new", "pool", "of", "Redis", "connections" ]

[ "func", "(", "rc", "*", "RedisConnector", ")", "open", "(", "socketPath", ",", "host", ",", "password", "string", ",", "db", "int", ",", "cnf", "*", "config", ".", "RedisConfig", ",", "tlsConfig", "*", "tls", ".", "Config", ")", "(", "redis", ".", "Conn", ",", "error", ")", "{", "var", "opts", "=", "[", "]", "redis", ".", "DialOption", "{", "redis", ".", "DialDatabase", "(", "db", ")", ",", "redis", ".", "DialReadTimeout", "(", "time", ".", "Duration", "(", "cnf", ".", "ReadTimeout", ")", "*", "time", ".", "Second", ")", ",", "redis", ".", "DialWriteTimeout", "(", "time", ".", "Duration", "(", "cnf", ".", "WriteTimeout", ")", "*", "time", ".", "Second", ")", ",", "redis", ".", "DialConnectTimeout", "(", "time", ".", "Duration", "(", "cnf", ".", "ConnectTimeout", ")", "*", "time", ".", "Second", ")", ",", "}", "\n\n", "if", "tlsConfig", "!=", "nil", "{", "opts", "=", "append", "(", "opts", ",", "redis", ".", "DialTLSConfig", "(", "tlsConfig", ")", ",", "redis", ".", "DialUseTLS", "(", "true", ")", ")", "\n", "}", "\n\n", "if", "password", "!=", "\"", "\"", "{", "opts", "=", "append", "(", "opts", ",", "redis", ".", "DialPassword", "(", "password", ")", ")", "\n", "}", "\n\n", "if", "socketPath", "!=", "\"", "\"", "{", "return", "redis", ".", "Dial", "(", "\"", "\"", ",", "socketPath", ",", "opts", "...", ")", "\n", "}", "\n\n", "return", "redis", ".", "Dial", "(", "\"", "\"", ",", "host", ",", "opts", "...", ")", "\n", "}" ]

[ "Open", "a", "new", "Redis", "connection" ]

[ "func", "NewAsyncResult", "(", "signature", "*", "tasks", ".", "Signature", ",", "backend", "iface", ".", "Backend", ")", "*", "AsyncResult", "{", "return", "&", "AsyncResult", "{", "Signature", ":", "signature", ",", "taskState", ":", "new", "(", "tasks", ".", "TaskState", ")", ",", "backend", ":", "backend", ",", "}", "\n", "}" ]

[ "NewAsyncResult", "creates", "AsyncResult", "instance" ]

[ "func", "NewChordAsyncResult", "(", "groupTasks", "[", "]", "*", "tasks", ".", "Signature", ",", "chordCallback", "*", "tasks", ".", "Signature", ",", "backend", "iface", ".", "Backend", ")", "*", "ChordAsyncResult", "{", "asyncResults", ":=", "make", "(", "[", "]", "*", "AsyncResult", ",", "len", "(", "groupTasks", ")", ")", "\n", "for", "i", ",", "task", ":=", "range", "groupTasks", "{", "asyncResults", "[", "i", "]", "=", "NewAsyncResult", "(", "task", ",", "backend", ")", "\n", "}", "\n", "return", "&", "ChordAsyncResult", "{", "groupAsyncResults", ":", "asyncResults", ",", "chordAsyncResult", ":", "NewAsyncResult", "(", "chordCallback", ",", "backend", ")", ",", "backend", ":", "backend", ",", "}", "\n", "}" ]

[ "NewChordAsyncResult", "creates", "ChordAsyncResult", "instance" ]

[ "func", "NewChainAsyncResult", "(", "tasks", "[", "]", "*", "tasks", ".", "Signature", ",", "backend", "iface", ".", "Backend", ")", "*", "ChainAsyncResult", "{", "asyncResults", ":=", "make", "(", "[", "]", "*", "AsyncResult", ",", "len", "(", "tasks", ")", ")", "\n", "for", "i", ",", "task", ":=", "range", "tasks", "{", "asyncResults", "[", "i", "]", "=", "NewAsyncResult", "(", "task", ",", "backend", ")", "\n", "}", "\n", "return", "&", "ChainAsyncResult", "{", "asyncResults", ":", "asyncResults", ",", "backend", ":", "backend", ",", "}", "\n", "}" ]

[ "NewChainAsyncResult", "creates", "ChainAsyncResult", "instance" ]

[ "func", "(", "asyncResult", "*", "AsyncResult", ")", "Touch", "(", ")", "(", "[", "]", "reflect", ".", "Value", ",", "error", ")", "{", "if", "asyncResult", ".", "backend", "==", "nil", "{", "return", "nil", ",", "ErrBackendNotConfigured", "\n", "}", "\n\n", "asyncResult", ".", "GetState", "(", ")", "\n\n", "// Purge state if we are using AMQP backend", "if", "asyncResult", ".", "backend", ".", "IsAMQP", "(", ")", "&&", "asyncResult", ".", "taskState", ".", "IsCompleted", "(", ")", "{", "asyncResult", ".", "backend", ".", "PurgeState", "(", "asyncResult", ".", "taskState", ".", "TaskUUID", ")", "\n", "}", "\n\n", "if", "asyncResult", ".", "taskState", ".", "IsFailure", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "asyncResult", ".", "taskState", ".", "Error", ")", "\n", "}", "\n\n", "if", "asyncResult", ".", "taskState", ".", "IsSuccess", "(", ")", "{", "return", "tasks", ".", "ReflectTaskResults", "(", "asyncResult", ".", "taskState", ".", "Results", ")", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Touch", "the", "state", "and", "don", "t", "wait" ]

[ "func", "(", "asyncResult", "*", "AsyncResult", ")", "GetState", "(", ")", "*", "tasks", ".", "TaskState", "{", "if", "asyncResult", ".", "taskState", ".", "IsCompleted", "(", ")", "{", "return", "asyncResult", ".", "taskState", "\n", "}", "\n\n", "taskState", ",", "err", ":=", "asyncResult", ".", "backend", ".", "GetState", "(", "asyncResult", ".", "Signature", ".", "UUID", ")", "\n", "if", "err", "==", "nil", "{", "asyncResult", ".", "taskState", "=", "taskState", "\n", "}", "\n\n", "return", "asyncResult", ".", "taskState", "\n", "}" ]

[ "GetState", "returns", "latest", "task", "state" ]

[ "func", "ValidateTask", "(", "task", "interface", "{", "}", ")", "error", "{", "v", ":=", "reflect", ".", "ValueOf", "(", "task", ")", "\n", "t", ":=", "v", ".", "Type", "(", ")", "\n\n", "// Task must be a function", "if", "t", ".", "Kind", "(", ")", "!=", "reflect", ".", "Func", "{", "return", "ErrTaskMustBeFunc", "\n", "}", "\n\n", "// Task must return at least a single value", "if", "t", ".", "NumOut", "(", ")", "<", "1", "{", "return", "ErrTaskReturnsNoValue", "\n", "}", "\n\n", "// Last return value must be error", "lastReturnType", ":=", "t", ".", "Out", "(", "t", ".", "NumOut", "(", ")", "-", "1", ")", "\n", "errorInterface", ":=", "reflect", ".", "TypeOf", "(", "(", "*", "error", ")", "(", "nil", ")", ")", ".", "Elem", "(", ")", "\n", "if", "!", "lastReturnType", ".", "Implements", "(", "errorInterface", ")", "{", "return", "ErrLastReturnValueMustBeError", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ValidateTask", "validates", "task", "function", "using", "reflection", "and", "makes", "sure", "it", "has", "a", "proper", "signature", ".", "Functions", "used", "as", "tasks", "must", "return", "at", "least", "a", "single", "value", "and", "the", "last", "return", "type", "must", "be", "error" ]

[ "func", "New", "(", "cnf", "*", "config", ".", "Config", ")", "iface", ".", "Backend", "{", "backend", ":=", "&", "Backend", "{", "Backend", ":", "common", ".", "NewBackend", "(", "cnf", ")", ",", "cnf", ":", "cnf", "}", "\n\n", "if", "cnf", ".", "DynamoDB", "!=", "nil", "&&", "cnf", ".", "DynamoDB", ".", "Client", "!=", "nil", "{", "backend", ".", "client", "=", "cnf", ".", "DynamoDB", ".", "Client", "\n", "}", "else", "{", "sess", ":=", "session", ".", "Must", "(", "session", ".", "NewSessionWithOptions", "(", "session", ".", "Options", "{", "SharedConfigState", ":", "session", ".", "SharedConfigEnable", ",", "}", ")", ")", "\n", "backend", ".", "client", "=", "dynamodb", ".", "New", "(", "sess", ")", "\n", "}", "\n\n", "// Check if needed tables exist", "err", ":=", "backend", ".", "checkRequiredTablesIfExist", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "FATAL", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "backend", "\n", "}" ]

[ "New", "creates", "a", "Backend", "instance" ]

[ "func", "NewFromEnvironment", "(", "keepReloading", "bool", ")", "(", "*", "Config", ",", "error", ")", "{", "cnf", ",", "err", ":=", "fromEnvironment", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "log", ".", "INFO", ".", "Print", "(", "\"", "\"", ")", "\n\n", "if", "keepReloading", "{", "// Open a goroutine to watch remote changes forever", "go", "func", "(", ")", "{", "for", "{", "// Delay after each request", "time", ".", "Sleep", "(", "reloadDelay", ")", "\n\n", "// Attempt to reload the config", "newCnf", ",", "newErr", ":=", "fromEnvironment", "(", ")", "\n", "if", "newErr", "!=", "nil", "{", "log", ".", "WARNING", ".", "Printf", "(", "\"", "\"", ",", "newErr", ")", "\n", "continue", "\n", "}", "\n\n", "*", "cnf", "=", "*", "newCnf", "\n", "// log.INFO.Printf(\"Successfully reloaded config from the environment\")", "}", "\n", "}", "(", ")", "\n", "}", "\n\n", "return", "cnf", ",", "nil", "\n", "}" ]

[ "NewFromEnvironment", "creates", "a", "config", "object", "from", "environment", "variables" ]

[ "func", "NewBroker", "(", "cnf", "*", "config", ".", "Config", ")", "Broker", "{", "return", "Broker", "{", "cnf", ":", "cnf", ",", "retry", ":", "true", "}", "\n", "}" ]

[ "NewBroker", "creates", "new", "Broker", "instance" ]

[ "func", "(", "b", "*", "Broker", ")", "IsTaskRegistered", "(", "name", "string", ")", "bool", "{", "for", "_", ",", "registeredTaskName", ":=", "range", "b", ".", "registeredTaskNames", "{", "if", "registeredTaskName", "==", "name", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsTaskRegistered", "returns", "true", "if", "the", "task", "is", "registered", "with", "this", "broker" ]

[ "func", "(", "b", "*", "Broker", ")", "StartConsuming", "(", "consumerTag", "string", ",", "concurrency", "int", ",", "taskProcessor", "iface", ".", "TaskProcessor", ")", "{", "if", "b", ".", "retryFunc", "==", "nil", "{", "b", ".", "retryFunc", "=", "retry", ".", "Closure", "(", ")", "\n", "}", "\n\n", "b", ".", "stopChan", "=", "make", "(", "chan", "int", ")", "\n", "b", ".", "retryStopChan", "=", "make", "(", "chan", "int", ")", "\n", "}" ]

[ "StartConsuming", "is", "a", "common", "part", "of", "StartConsuming", "method" ]

[ "func", "(", "b", "*", "Broker", ")", "StopConsuming", "(", ")", "{", "// Do not retry from now on", "b", ".", "retry", "=", "false", "\n", "// Stop the retry closure earlier", "select", "{", "case", "b", ".", "retryStopChan", "<-", "1", ":", "log", ".", "WARNING", ".", "Print", "(", "\"", "\"", ")", "\n", "default", ":", "}", "\n", "// Notifying the stop channel stops consuming of messages", "select", "{", "case", "b", ".", "stopChan", "<-", "1", ":", "log", ".", "WARNING", ".", "Print", "(", "\"", "\"", ")", "\n", "default", ":", "}", "\n", "}" ]

[ "StopConsuming", "is", "a", "common", "part", "of", "StopConsuming" ]

[ "func", "(", "b", "*", "Backend", ")", "lockGroupMeta", "(", "groupMeta", "*", "tasks", ".", "GroupMeta", ")", "error", "{", "groupMeta", ".", "Lock", "=", "true", "\n", "encoded", ",", "err", ":=", "json", ".", "Marshal", "(", "groupMeta", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "b", ".", "getClient", "(", ")", ".", "Set", "(", "&", "gomemcache", ".", "Item", "{", "Key", ":", "groupMeta", ".", "GroupUUID", ",", "Value", ":", "encoded", ",", "Expiration", ":", "b", ".", "getExpirationTimestamp", "(", ")", ",", "}", ")", "\n", "}" ]

[ "lockGroupMeta", "acquires", "lock", "on", "group", "meta", "data" ]

[ "func", "(", "b", "*", "Backend", ")", "getExpirationTimestamp", "(", ")", "int32", "{", "expiresIn", ":=", "b", ".", "GetConfig", "(", ")", ".", "ResultsExpireIn", "\n", "if", "expiresIn", "==", "0", "{", "// // expire results after 1 hour by default", "expiresIn", "=", "config", ".", "DefaultResultsExpireIn", "\n", "}", "\n", "return", "int32", "(", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "+", "int64", "(", "expiresIn", ")", ")", "\n", "}" ]

[ "getExpirationTimestamp", "returns", "expiration", "timestamp" ]

[ "func", "(", "b", "*", "Backend", ")", "getClient", "(", ")", "*", "gomemcache", ".", "Client", "{", "if", "b", ".", "client", "==", "nil", "{", "b", ".", "client", "=", "gomemcache", ".", "New", "(", "b", ".", "servers", "...", ")", "\n", "}", "\n", "return", "b", ".", "client", "\n", "}" ]

[ "getClient", "returns", "or", "creates", "instance", "of", "Memcache", "client" ]

[ "func", "New", "(", ")", "iface", ".", "Backend", "{", "return", "&", "Backend", "{", "Backend", ":", "common", ".", "NewBackend", "(", "new", "(", "config", ".", "Config", ")", ")", ",", "groups", ":", "make", "(", "map", "[", "string", "]", "[", "]", "string", ")", ",", "tasks", ":", "make", "(", "map", "[", "string", "]", "[", "]", "byte", ")", ",", "}", "\n", "}" ]

[ "New", "creates", "EagerBackend", "instance" ]

[ "func", "NewFromYaml", "(", "cnfPath", "string", ",", "keepReloading", "bool", ")", "(", "*", "Config", ",", "error", ")", "{", "cnf", ",", "err", ":=", "fromFile", "(", "cnfPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "cnfPath", ")", "\n\n", "if", "keepReloading", "{", "// Open a goroutine to watch remote changes forever", "go", "func", "(", ")", "{", "for", "{", "// Delay after each request", "time", ".", "Sleep", "(", "reloadDelay", ")", "\n\n", "// Attempt to reload the config", "newCnf", ",", "newErr", ":=", "fromFile", "(", "cnfPath", ")", "\n", "if", "newErr", "!=", "nil", "{", "log", ".", "WARNING", ".", "Printf", "(", "\"", "\"", ",", "cnfPath", ",", "newErr", ")", "\n", "continue", "\n", "}", "\n\n", "*", "cnf", "=", "*", "newCnf", "\n", "// log.INFO.Printf(\"Successfully reloaded config from file %s\", cnfPath)", "}", "\n", "}", "(", ")", "\n", "}", "\n\n", "return", "cnf", ",", "nil", "\n", "}" ]

[ "NewFromYaml", "creates", "a", "config", "object", "from", "YAML", "file" ]

[ "func", "ReadFromFile", "(", "cnfPath", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "file", ",", "err", ":=", "os", ".", "Open", "(", "cnfPath", ")", "\n\n", "// Config file not found", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Config file found, let's try to read it", "data", ":=", "make", "(", "[", "]", "byte", ",", "1000", ")", "\n", "count", ",", "err", ":=", "file", ".", "Read", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "data", "[", ":", "count", "]", ",", "nil", "\n", "}" ]

[ "ReadFromFile", "reads", "data", "from", "a", "file" ]

[ "func", "NewSignature", "(", "name", "string", ",", "args", "[", "]", "Arg", ")", "(", "*", "Signature", ",", "error", ")", "{", "signatureID", ":=", "uuid", ".", "New", "(", ")", ".", "String", "(", ")", "\n", "return", "&", "Signature", "{", "UUID", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "signatureID", ")", ",", "Name", ":", "name", ",", "Args", ":", "args", ",", "}", ",", "nil", "\n", "}" ]

[ "NewSignature", "creates", "a", "new", "task", "signature" ]

[ "func", "NewServer", "(", "cnf", "*", "config", ".", "Config", ")", "(", "*", "Server", ",", "error", ")", "{", "broker", ",", "err", ":=", "BrokerFactory", "(", "cnf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Backend is optional so we ignore the error", "backend", ",", "_", ":=", "BackendFactory", "(", "cnf", ")", "\n\n", "srv", ":=", "NewServerWithBrokerBackend", "(", "cnf", ",", "broker", ",", "backend", ")", "\n\n", "// init for eager-mode", "eager", ",", "ok", ":=", "broker", ".", "(", "eager", ".", "Mode", ")", "\n", "if", "ok", "{", "// we don't have to call worker.Launch in eager mode", "eager", ".", "AssignWorker", "(", "srv", ".", "NewWorker", "(", "\"", "\"", ",", "0", ")", ")", "\n", "}", "\n\n", "return", "srv", ",", "nil", "\n", "}" ]

[ "NewServer", "creates", "Server", "instance" ]

[ "func", "(", "server", "*", "Server", ")", "NewWorker", "(", "consumerTag", "string", ",", "concurrency", "int", ")", "*", "Worker", "{", "return", "&", "Worker", "{", "server", ":", "server", ",", "ConsumerTag", ":", "consumerTag", ",", "Concurrency", ":", "concurrency", ",", "Queue", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "NewWorker", "creates", "Worker", "instance" ]

[ "func", "(", "server", "*", "Server", ")", "NewCustomQueueWorker", "(", "consumerTag", "string", ",", "concurrency", "int", ",", "queue", "string", ")", "*", "Worker", "{", "return", "&", "Worker", "{", "server", ":", "server", ",", "ConsumerTag", ":", "consumerTag", ",", "Concurrency", ":", "concurrency", ",", "Queue", ":", "queue", ",", "}", "\n", "}" ]

[ "NewCustomQueueWorker", "creates", "Worker", "instance", "with", "Custom", "Queue" ]

[ "func", "(", "server", "*", "Server", ")", "RegisterTasks", "(", "namedTaskFuncs", "map", "[", "string", "]", "interface", "{", "}", ")", "error", "{", "for", "_", ",", "task", ":=", "range", "namedTaskFuncs", "{", "if", "err", ":=", "tasks", ".", "ValidateTask", "(", "task", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "server", ".", "registeredTasks", "=", "namedTaskFuncs", "\n", "server", ".", "broker", ".", "SetRegisteredTaskNames", "(", "server", ".", "GetRegisteredTaskNames", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "RegisterTasks", "registers", "all", "tasks", "at", "once" ]

[ "func", "(", "server", "*", "Server", ")", "RegisterTask", "(", "name", "string", ",", "taskFunc", "interface", "{", "}", ")", "error", "{", "if", "err", ":=", "tasks", ".", "ValidateTask", "(", "taskFunc", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "server", ".", "registeredTasks", "[", "name", "]", "=", "taskFunc", "\n", "server", ".", "broker", ".", "SetRegisteredTaskNames", "(", "server", ".", "GetRegisteredTaskNames", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "RegisterTask", "registers", "a", "single", "task" ]

[ "func", "(", "server", "*", "Server", ")", "IsTaskRegistered", "(", "name", "string", ")", "bool", "{", "_", ",", "ok", ":=", "server", ".", "registeredTasks", "[", "name", "]", "\n", "return", "ok", "\n", "}" ]

[ "IsTaskRegistered", "returns", "true", "if", "the", "task", "name", "is", "registered", "with", "this", "broker" ]

[ "func", "(", "server", "*", "Server", ")", "GetRegisteredTask", "(", "name", "string", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "taskFunc", ",", "ok", ":=", "server", ".", "registeredTasks", "[", "name", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "return", "taskFunc", ",", "nil", "\n", "}" ]

[ "GetRegisteredTask", "returns", "registered", "task", "by", "name" ]

[ "func", "(", "server", "*", "Server", ")", "SendTaskWithContext", "(", "ctx", "context", ".", "Context", ",", "signature", "*", "tasks", ".", "Signature", ")", "(", "*", "result", ".", "AsyncResult", ",", "error", ")", "{", "span", ",", "_", ":=", "opentracing", ".", "StartSpanFromContext", "(", "ctx", ",", "\"", "\"", ",", "tracing", ".", "ProducerOption", "(", ")", ",", "tracing", ".", "MachineryTag", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "// tag the span with some info about the signature", "signature", ".", "Headers", "=", "tracing", ".", "HeadersWithSpan", "(", "signature", ".", "Headers", ",", "span", ")", "\n\n", "// Make sure result backend is defined", "if", "server", ".", "backend", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Auto generate a UUID if not set already", "if", "signature", ".", "UUID", "==", "\"", "\"", "{", "taskID", ":=", "uuid", ".", "New", "(", ")", ".", "String", "(", ")", "\n", "signature", ".", "UUID", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "taskID", ")", "\n", "}", "\n\n", "// Set initial task state to PENDING", "if", "err", ":=", "server", ".", "backend", ".", "SetStatePending", "(", "signature", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "server", ".", "prePublishHandler", "!=", "nil", "{", "server", ".", "prePublishHandler", "(", "signature", ")", "\n", "}", "\n\n", "if", "err", ":=", "server", ".", "broker", ".", "Publish", "(", "ctx", ",", "signature", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "result", ".", "NewAsyncResult", "(", "signature", ",", "server", ".", "backend", ")", ",", "nil", "\n", "}" ]

[ "SendTaskWithContext", "will", "inject", "the", "trace", "context", "in", "the", "signature", "headers", "before", "publishing", "it" ]

[ "func", "(", "server", "*", "Server", ")", "SendTask", "(", "signature", "*", "tasks", ".", "Signature", ")", "(", "*", "result", ".", "AsyncResult", ",", "error", ")", "{", "return", "server", ".", "SendTaskWithContext", "(", "context", ".", "Background", "(", ")", ",", "signature", ")", "\n", "}" ]

[ "SendTask", "publishes", "a", "task", "to", "the", "default", "queue" ]

[ "func", "(", "server", "*", "Server", ")", "SendChainWithContext", "(", "ctx", "context", ".", "Context", ",", "chain", "*", "tasks", ".", "Chain", ")", "(", "*", "result", ".", "ChainAsyncResult", ",", "error", ")", "{", "span", ",", "_", ":=", "opentracing", ".", "StartSpanFromContext", "(", "ctx", ",", "\"", "\"", ",", "tracing", ".", "ProducerOption", "(", ")", ",", "tracing", ".", "MachineryTag", ",", "tracing", ".", "WorkflowChainTag", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "tracing", ".", "AnnotateSpanWithChainInfo", "(", "span", ",", "chain", ")", "\n\n", "return", "server", ".", "SendChain", "(", "chain", ")", "\n", "}" ]

[ "SendChainWithContext", "will", "inject", "the", "trace", "context", "in", "all", "the", "signature", "headers", "before", "publishing", "it" ]

[ "func", "(", "server", "*", "Server", ")", "SendChain", "(", "chain", "*", "tasks", ".", "Chain", ")", "(", "*", "result", ".", "ChainAsyncResult", ",", "error", ")", "{", "_", ",", "err", ":=", "server", ".", "SendTask", "(", "chain", ".", "Tasks", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "result", ".", "NewChainAsyncResult", "(", "chain", ".", "Tasks", ",", "server", ".", "backend", ")", ",", "nil", "\n", "}" ]

[ "SendChain", "triggers", "a", "chain", "of", "tasks" ]

[ "func", "(", "server", "*", "Server", ")", "SendGroupWithContext", "(", "ctx", "context", ".", "Context", ",", "group", "*", "tasks", ".", "Group", ",", "sendConcurrency", "int", ")", "(", "[", "]", "*", "result", ".", "AsyncResult", ",", "error", ")", "{", "span", ",", "_", ":=", "opentracing", ".", "StartSpanFromContext", "(", "ctx", ",", "\"", "\"", ",", "tracing", ".", "ProducerOption", "(", ")", ",", "tracing", ".", "MachineryTag", ",", "tracing", ".", "WorkflowGroupTag", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "tracing", ".", "AnnotateSpanWithGroupInfo", "(", "span", ",", "group", ",", "sendConcurrency", ")", "\n\n", "// Make sure result backend is defined", "if", "server", ".", "backend", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "asyncResults", ":=", "make", "(", "[", "]", "*", "result", ".", "AsyncResult", ",", "len", "(", "group", ".", "Tasks", ")", ")", "\n\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "wg", ".", "Add", "(", "len", "(", "group", ".", "Tasks", ")", ")", "\n", "errorsChan", ":=", "make", "(", "chan", "error", ",", "len", "(", "group", ".", "Tasks", ")", "*", "2", ")", "\n\n", "// Init group", "server", ".", "backend", ".", "InitGroup", "(", "group", ".", "GroupUUID", ",", "group", ".", "GetUUIDs", "(", ")", ")", "\n\n", "// Init the tasks Pending state first", "for", "_", ",", "signature", ":=", "range", "group", ".", "Tasks", "{", "if", "err", ":=", "server", ".", "backend", ".", "SetStatePending", "(", "signature", ")", ";", "err", "!=", "nil", "{", "errorsChan", "<-", "err", "\n", "continue", "\n", "}", "\n", "}", "\n\n", "pool", ":=", "make", "(", "chan", "struct", "{", "}", ",", "sendConcurrency", ")", "\n", "go", "func", "(", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "sendConcurrency", ";", "i", "++", "{", "pool", "<-", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "for", "i", ",", "signature", ":=", "range", "group", ".", "Tasks", "{", "if", "sendConcurrency", ">", "0", "{", "<-", "pool", "\n", "}", "\n\n", "go", "func", "(", "s", "*", "tasks", ".", "Signature", ",", "index", "int", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n\n", "// Publish task", "err", ":=", "server", ".", "broker", ".", "Publish", "(", "ctx", ",", "s", ")", "\n\n", "if", "sendConcurrency", ">", "0", "{", "pool", "<-", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "errorsChan", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "asyncResults", "[", "index", "]", "=", "result", ".", "NewAsyncResult", "(", "s", ",", "server", ".", "backend", ")", "\n", "}", "(", "signature", ",", "i", ")", "\n", "}", "\n\n", "done", ":=", "make", "(", "chan", "int", ")", "\n", "go", "func", "(", ")", "{", "wg", ".", "Wait", "(", ")", "\n", "done", "<-", "1", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "err", ":=", "<-", "errorsChan", ":", "return", "asyncResults", ",", "err", "\n", "case", "<-", "done", ":", "return", "asyncResults", ",", "nil", "\n", "}", "\n", "}" ]

[ "SendGroupWithContext", "will", "inject", "the", "trace", "context", "in", "all", "the", "signature", "headers", "before", "publishing", "it" ]

[ "func", "(", "server", "*", "Server", ")", "SendGroup", "(", "group", "*", "tasks", ".", "Group", ",", "sendConcurrency", "int", ")", "(", "[", "]", "*", "result", ".", "AsyncResult", ",", "error", ")", "{", "return", "server", ".", "SendGroupWithContext", "(", "context", ".", "Background", "(", ")", ",", "group", ",", "sendConcurrency", ")", "\n", "}" ]

[ "SendGroup", "triggers", "a", "group", "of", "parallel", "tasks" ]

[ "func", "(", "server", "*", "Server", ")", "SendChordWithContext", "(", "ctx", "context", ".", "Context", ",", "chord", "*", "tasks", ".", "Chord", ",", "sendConcurrency", "int", ")", "(", "*", "result", ".", "ChordAsyncResult", ",", "error", ")", "{", "span", ",", "_", ":=", "opentracing", ".", "StartSpanFromContext", "(", "ctx", ",", "\"", "\"", ",", "tracing", ".", "ProducerOption", "(", ")", ",", "tracing", ".", "MachineryTag", ",", "tracing", ".", "WorkflowChordTag", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "tracing", ".", "AnnotateSpanWithChordInfo", "(", "span", ",", "chord", ",", "sendConcurrency", ")", "\n\n", "_", ",", "err", ":=", "server", ".", "SendGroupWithContext", "(", "ctx", ",", "chord", ".", "Group", ",", "sendConcurrency", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "result", ".", "NewChordAsyncResult", "(", "chord", ".", "Group", ".", "Tasks", ",", "chord", ".", "Callback", ",", "server", ".", "backend", ",", ")", ",", "nil", "\n", "}" ]

[ "SendChordWithContext", "will", "inject", "the", "trace", "context", "in", "all", "the", "signature", "headers", "before", "publishing", "it" ]

[ "func", "(", "server", "*", "Server", ")", "SendChord", "(", "chord", "*", "tasks", ".", "Chord", ",", "sendConcurrency", "int", ")", "(", "*", "result", ".", "ChordAsyncResult", ",", "error", ")", "{", "return", "server", ".", "SendChordWithContext", "(", "context", ".", "Background", "(", ")", ",", "chord", ",", "sendConcurrency", ")", "\n", "}" ]

[ "SendChord", "triggers", "a", "group", "of", "parallel", "tasks", "with", "a", "callback" ]

[ "func", "(", "server", "*", "Server", ")", "GetRegisteredTaskNames", "(", ")", "[", "]", "string", "{", "taskNames", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "server", ".", "registeredTasks", ")", ")", "\n", "var", "i", "=", "0", "\n", "for", "name", ":=", "range", "server", ".", "registeredTasks", "{", "taskNames", "[", "i", "]", "=", "name", "\n", "i", "++", "\n", "}", "\n", "return", "taskNames", "\n", "}" ]

[ "GetRegisteredTaskNames", "returns", "slice", "of", "registered", "task", "names" ]

[ "func", "Set", "(", "l", "logging", ".", "LoggerInterface", ")", "{", "DEBUG", "=", "l", "\n", "INFO", "=", "l", "\n", "WARNING", "=", "l", "\n", "ERROR", "=", "l", "\n", "FATAL", "=", "l", "\n", "}" ]

[ "Set", "sets", "a", "custom", "logger", "for", "all", "log", "levels" ]

[ "func", "(", "b", "*", "Broker", ")", "GetPendingTasks", "(", "queue", "string", ")", "(", "[", "]", "*", "tasks", ".", "Signature", ",", "error", ")", "{", "conn", ":=", "b", ".", "open", "(", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "if", "queue", "==", "\"", "\"", "{", "queue", "=", "b", ".", "GetConfig", "(", ")", ".", "DefaultQueue", "\n", "}", "\n", "dataBytes", ",", "err", ":=", "conn", ".", "Do", "(", "\"", "\"", ",", "queue", ",", "0", ",", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "results", ",", "err", ":=", "redis", ".", "ByteSlices", "(", "dataBytes", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "taskSignatures", ":=", "make", "(", "[", "]", "*", "tasks", ".", "Signature", ",", "len", "(", "results", ")", ")", "\n", "for", "i", ",", "result", ":=", "range", "results", "{", "signature", ":=", "new", "(", "tasks", ".", "Signature", ")", "\n", "decoder", ":=", "json", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "result", ")", ")", "\n", "decoder", ".", "UseNumber", "(", ")", "\n", "if", "err", ":=", "decoder", ".", "Decode", "(", "signature", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "taskSignatures", "[", "i", "]", "=", "signature", "\n", "}", "\n", "return", "taskSignatures", ",", "nil", "\n", "}" ]

[ "GetPendingTasks", "returns", "a", "slice", "of", "task", "signatures", "waiting", "in", "the", "queue" ]

[ "func", "(", "b", "*", "Broker", ")", "nextTask", "(", "queue", "string", ")", "(", "result", "[", "]", "byte", ",", "err", "error", ")", "{", "conn", ":=", "b", ".", "open", "(", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "items", ",", "err", ":=", "redis", ".", "ByteSlices", "(", "conn", ".", "Do", "(", "\"", "\"", ",", "queue", ",", "1000", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "]", "byte", "{", "}", ",", "err", "\n", "}", "\n\n", "// items[0] - the name of the key where an element was popped", "// items[1] - the value of the popped element", "if", "len", "(", "items", ")", "!=", "2", "{", "return", "[", "]", "byte", "{", "}", ",", "redis", ".", "ErrNil", "\n", "}", "\n\n", "result", "=", "items", "[", "1", "]", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "nextTask", "pops", "next", "available", "task", "from", "the", "default", "queue" ]

[ "func", "(", "b", "*", "Broker", ")", "open", "(", ")", "redis", ".", "Conn", "{", "b", ".", "redisOnce", ".", "Do", "(", "func", "(", ")", "{", "b", ".", "pool", "=", "b", ".", "NewPool", "(", "b", ".", "socketPath", ",", "b", ".", "host", ",", "b", ".", "password", ",", "b", ".", "db", ",", "b", ".", "GetConfig", "(", ")", ".", "Redis", ",", "b", ".", "GetConfig", "(", ")", ".", "TLSConfig", ")", "\n", "b", ".", "redsync", "=", "redsync", ".", "New", "(", "[", "]", "redsync", ".", "Pool", "{", "b", ".", "pool", "}", ")", "\n", "}", ")", "\n\n", "return", "b", ".", "pool", ".", "Get", "(", ")", "\n", "}" ]

[ "open", "returns", "or", "creates", "instance", "of", "Redis", "connection" ]

[ "func", "Fibonacci", "(", ")", "func", "(", ")", "int", "{", "a", ",", "b", ":=", "0", ",", "1", "\n", "return", "func", "(", ")", "int", "{", "a", ",", "b", "=", "b", ",", "a", "+", "b", "\n", "return", "a", "\n", "}", "\n", "}" ]

[ "Fibonacci", "returns", "successive", "Fibonacci", "numbers", "starting", "from", "1" ]

[ "func", "FibonacciNext", "(", "start", "int", ")", "int", "{", "fib", ":=", "Fibonacci", "(", ")", "\n", "num", ":=", "fib", "(", ")", "\n", "for", "num", "<=", "start", "{", "num", "=", "fib", "(", ")", "\n", "}", "\n", "return", "num", "\n", "}" ]

[ "FibonacciNext", "returns", "next", "number", "in", "Fibonacci", "sequence", "greater", "than", "start" ]

[ "func", "(", "b", "*", "Backend", ")", "decodeResults", "(", "results", "[", "]", "*", "tasks", ".", "TaskResult", ")", "[", "]", "*", "tasks", ".", "TaskResult", "{", "l", ":=", "len", "(", "results", ")", "\n", "jsonResults", ":=", "make", "(", "[", "]", "*", "tasks", ".", "TaskResult", ",", "l", ",", "l", ")", "\n", "for", "i", ",", "result", ":=", "range", "results", "{", "jsonResult", ":=", "new", "(", "bson", ".", "M", ")", "\n", "resultType", ":=", "reflect", ".", "TypeOf", "(", "result", ".", "Value", ")", ".", "Kind", "(", ")", "\n", "if", "resultType", "==", "reflect", ".", "String", "{", "err", ":=", "json", ".", "NewDecoder", "(", "strings", ".", "NewReader", "(", "result", ".", "Value", ".", "(", "string", ")", ")", ")", ".", "Decode", "(", "&", "jsonResult", ")", "\n", "if", "err", "==", "nil", "{", "jsonResults", "[", "i", "]", "=", "&", "tasks", ".", "TaskResult", "{", "Type", ":", "\"", "\"", ",", "Value", ":", "jsonResult", ",", "}", "\n", "continue", "\n", "}", "\n", "}", "\n", "jsonResults", "[", "i", "]", "=", "result", "\n", "}", "\n", "return", "jsonResults", "\n", "}" ]

[ "decodeResults", "detects", "&", "decodes", "json", "strings", "in", "TaskResult", ".", "Value", "and", "returns", "a", "new", "slice" ]

[ "func", "(", "b", "*", "Backend", ")", "lockGroupMeta", "(", "groupUUID", "string", ")", "error", "{", "query", ":=", "bson", ".", "M", "{", "\"", "\"", ":", "groupUUID", ",", "\"", "\"", ":", "false", ",", "}", "\n", "change", ":=", "bson", ".", "M", "{", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "true", ",", "}", ",", "}", "\n\n", "_", ",", "err", ":=", "b", ".", "groupMetasCollection", ".", "UpdateOne", "(", "context", ".", "Background", "(", ")", ",", "query", ",", "change", ",", "options", ".", "Update", "(", ")", ".", "SetUpsert", "(", "true", ")", ")", "\n\n", "return", "err", "\n", "}" ]

[ "lockGroupMeta", "acquires", "lock", "on", "groupUUID", "document" ]

[ "func", "(", "b", "*", "Backend", ")", "unlockGroupMeta", "(", "groupUUID", "string", ")", "error", "{", "update", ":=", "bson", ".", "M", "{", "\"", "\"", ":", "bson", ".", "M", "{", "\"", "\"", ":", "false", "}", "}", "\n", "_", ",", "err", ":=", "b", ".", "groupMetasCollection", ".", "UpdateOne", "(", "context", ".", "Background", "(", ")", ",", "bson", ".", "M", "{", "\"", "\"", ":", "groupUUID", "}", ",", "update", ",", "options", ".", "Update", "(", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "unlockGroupMeta", "releases", "lock", "on", "groupUUID", "document" ]

[ "func", "(", "b", "*", "Backend", ")", "connect", "(", ")", "error", "{", "client", ",", "err", ":=", "b", ".", "dial", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "b", ".", "client", "=", "client", "\n\n", "database", ":=", "\"", "\"", "\n\n", "if", "b", ".", "GetConfig", "(", ")", ".", "MongoDB", "!=", "nil", "{", "database", "=", "b", ".", "GetConfig", "(", ")", ".", "MongoDB", ".", "Database", "\n", "}", "\n\n", "b", ".", "tasksCollection", "=", "b", ".", "client", ".", "Database", "(", "database", ")", ".", "Collection", "(", "\"", "\"", ")", "\n", "b", ".", "groupMetasCollection", "=", "b", ".", "client", ".", "Database", "(", "database", ")", ".", "Collection", "(", "\"", "\"", ")", "\n\n", "err", "=", "b", ".", "createMongoIndexes", "(", "database", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "connect", "creates", "the", "underlying", "mgo", "connection", "if", "it", "doesn", "t", "exist", "creates", "required", "indexes", "for", "our", "collections" ]

[ "func", "(", "b", "*", "Backend", ")", "dial", "(", ")", "(", "*", "mongo", ".", "Client", ",", "error", ")", "{", "if", "b", ".", "GetConfig", "(", ")", ".", "MongoDB", "!=", "nil", "&&", "b", ".", "GetConfig", "(", ")", ".", "MongoDB", ".", "Client", "!=", "nil", "{", "return", "b", ".", "GetConfig", "(", ")", ".", "MongoDB", ".", "Client", ",", "nil", "\n", "}", "\n\n", "uri", ":=", "b", ".", "GetConfig", "(", ")", ".", "ResultBackend", "\n", "if", "strings", ".", "HasPrefix", "(", "uri", ",", "\"", "\"", ")", "==", "false", "&&", "strings", ".", "HasPrefix", "(", "uri", ",", "\"", "\"", ")", "==", "false", "{", "uri", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "uri", ")", "\n", "}", "\n\n", "client", ",", "err", ":=", "mongo", ".", "NewClient", "(", "options", ".", "Client", "(", ")", ".", "ApplyURI", "(", "uri", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "context", ".", "Background", "(", ")", ",", "10", "*", "time", ".", "Second", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "if", "err", ":=", "client", ".", "Connect", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "client", ",", "nil", "\n", "}" ]

[ "dial", "connects", "to", "mongo", "with", "TLSConfig", "if", "provided", "else", "connects", "via", "ResultBackend", "uri" ]

[ "func", "(", "b", "*", "Backend", ")", "createMongoIndexes", "(", "database", "string", ")", "error", "{", "tasksCollection", ":=", "b", ".", "client", ".", "Database", "(", "database", ")", ".", "Collection", "(", "\"", "\"", ")", "\n\n", "expireIn", ":=", "int32", "(", "b", ".", "GetConfig", "(", ")", ".", "ResultsExpireIn", ")", "\n\n", "_", ",", "err", ":=", "tasksCollection", ".", "Indexes", "(", ")", ".", "CreateMany", "(", "context", ".", "Background", "(", ")", ",", "[", "]", "mongo", ".", "IndexModel", "{", "{", "Keys", ":", "bson", ".", "M", "{", "\"", "\"", ":", "1", "}", ",", "Options", ":", "options", ".", "Index", "(", ")", ".", "SetBackground", "(", "true", ")", ".", "SetExpireAfterSeconds", "(", "expireIn", ")", ",", "}", ",", "mongo", ".", "IndexModel", "{", "Keys", ":", "bson", ".", "M", "{", "\"", "\"", ":", "1", "}", ",", "Options", ":", "options", ".", "Index", "(", ")", ".", "SetBackground", "(", "true", ")", ".", "SetExpireAfterSeconds", "(", "expireIn", ")", ",", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "createMongoIndexes", "ensures", "all", "indexes", "are", "in", "place" ]

[ "func", "NewErrCouldNotUnmarshaTaskSignature", "(", "msg", "[", "]", "byte", ",", "err", "error", ")", "ErrCouldNotUnmarshaTaskSignature", "{", "return", "ErrCouldNotUnmarshaTaskSignature", "{", "msg", ":", "msg", ",", "reason", ":", "err", ".", "Error", "(", ")", "}", "\n", "}" ]

[ "NewErrCouldNotUnmarshaTaskSignature", "returns", "new", "ErrCouldNotUnmarshaTaskSignature", "instance" ]

[ "func", "NewErrRetryTaskLater", "(", "msg", "string", ",", "retryIn", "time", ".", "Duration", ")", "ErrRetryTaskLater", "{", "return", "ErrRetryTaskLater", "{", "msg", ":", "msg", ",", "retryIn", ":", "retryIn", "}", "\n", "}" ]

[ "NewErrRetryTaskLater", "returns", "new", "ErrRetryTaskLater", "instance" ]

[ "func", "(", "b", "*", "Backend", ")", "setExpirationTime", "(", "key", "string", ")", "error", "{", "expiresIn", ":=", "b", ".", "GetConfig", "(", ")", ".", "ResultsExpireIn", "\n", "if", "expiresIn", "==", "0", "{", "// // expire results after 1 hour by default", "expiresIn", "=", "config", ".", "DefaultResultsExpireIn", "\n", "}", "\n", "expirationTimestamp", ":=", "int32", "(", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "+", "int64", "(", "expiresIn", ")", ")", "\n\n", "conn", ":=", "b", ".", "open", "(", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "_", ",", "err", ":=", "conn", ".", "Do", "(", "\"", "\"", ",", "key", ",", "expirationTimestamp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "setExpirationTime", "sets", "expiration", "timestamp", "on", "a", "stored", "task", "state" ]

[ "func", "(", "b", "*", "Broker", ")", "GetOrOpenConnection", "(", "queueName", "string", ",", "queueBindingKey", "string", ",", "exchangeDeclareArgs", ",", "queueDeclareArgs", ",", "queueBindingArgs", "amqp", ".", "Table", ")", "(", "*", "AMQPConnection", ",", "error", ")", "{", "var", "err", "error", "\n\n", "b", ".", "connectionsMutex", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "connectionsMutex", ".", "Unlock", "(", ")", "\n\n", "conn", ",", "ok", ":=", "b", ".", "connections", "[", "queueName", "]", "\n", "if", "!", "ok", "{", "conn", "=", "&", "AMQPConnection", "{", "queueName", ":", "queueName", ",", "cleanup", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "conn", ".", "connection", ",", "conn", ".", "channel", ",", "conn", ".", "queue", ",", "conn", ".", "confirmation", ",", "conn", ".", "errorchan", ",", "err", "=", "b", ".", "Connect", "(", "b", ".", "GetConfig", "(", ")", ".", "Broker", ",", "b", ".", "GetConfig", "(", ")", ".", "TLSConfig", ",", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "Exchange", ",", "// exchange name", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "ExchangeType", ",", "// exchange type", "queueName", ",", "// queue name", "true", ",", "// queue durable", "false", ",", "// queue delete when unused", "queueBindingKey", ",", "// queue binding key", "exchangeDeclareArgs", ",", "// exchange declare args", "queueDeclareArgs", ",", "// queue declare args", "queueBindingArgs", ",", "// queue binding args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Reconnect to the channel if it disconnects/errors out", "go", "func", "(", ")", "{", "select", "{", "case", "err", "=", "<-", "conn", ".", "errorchan", ":", "log", ".", "INFO", ".", "Printf", "(", "\"", "\"", ",", "queueName", ")", "\n", "_", ",", "err", ":=", "b", ".", "GetOrOpenConnection", "(", "queueName", ",", "queueBindingKey", ",", "exchangeDeclareArgs", ",", "queueDeclareArgs", ",", "queueBindingArgs", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "ERROR", ".", "Printf", "(", "\"", "\"", ",", "queueName", ")", "\n", "}", "\n", "case", "<-", "conn", ".", "cleanup", ":", "return", "\n", "}", "\n", "return", "\n", "}", "(", ")", "\n", "b", ".", "connections", "[", "queueName", "]", "=", "conn", "\n", "}", "\n", "return", "conn", ",", "nil", "\n", "}" ]

[ "GetOrOpenConnection", "will", "return", "a", "connection", "on", "a", "particular", "queue", "name", ".", "Open", "connections", "are", "saved", "to", "avoid", "having", "to", "reopen", "connection", "for", "multiple", "queues" ]

[ "func", "(", "b", "*", "Broker", ")", "delay", "(", "signature", "*", "tasks", ".", "Signature", ",", "delayMs", "int64", ")", "error", "{", "if", "delayMs", "<=", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "message", ",", "err", ":=", "json", ".", "Marshal", "(", "signature", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// It's necessary to redeclare the queue each time (to zero its TTL timer).", "queueName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "delayMs", ",", "// delay duration in mileseconds", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "Exchange", ",", "signature", ".", "RoutingKey", ",", "// routing key", ")", "\n", "declareQueueArgs", ":=", "amqp", ".", "Table", "{", "// Exchange where to send messages after TTL expiration.", "\"", "\"", ":", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "Exchange", ",", "// Routing key which use when resending expired messages.", "\"", "\"", ":", "signature", ".", "RoutingKey", ",", "// Time in milliseconds", "// after that message will expire and be sent to destination.", "\"", "\"", ":", "delayMs", ",", "// Time after that the queue will be deleted.", "\"", "\"", ":", "delayMs", "*", "2", ",", "}", "\n", "conn", ",", "channel", ",", "_", ",", "_", ",", "_", ",", "err", ":=", "b", ".", "Connect", "(", "b", ".", "GetConfig", "(", ")", ".", "Broker", ",", "b", ".", "GetConfig", "(", ")", ".", "TLSConfig", ",", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "Exchange", ",", "// exchange name", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "ExchangeType", ",", "// exchange type", "queueName", ",", "// queue name", "true", ",", "// queue durable", "false", ",", "// queue delete when unused", "queueName", ",", "// queue binding key", "nil", ",", "// exchange declare args", "declareQueueArgs", ",", "// queue declare args", "amqp", ".", "Table", "(", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "QueueBindingArgs", ")", ",", "// queue binding args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "b", ".", "Close", "(", "channel", ",", "conn", ")", "\n\n", "if", "err", ":=", "channel", ".", "Publish", "(", "b", ".", "GetConfig", "(", ")", ".", "AMQP", ".", "Exchange", ",", "// exchange", "queueName", ",", "// routing key", "false", ",", "// mandatory", "false", ",", "// immediate", "amqp", ".", "Publishing", "{", "Headers", ":", "amqp", ".", "Table", "(", "signature", ".", "Headers", ")", ",", "ContentType", ":", "\"", "\"", ",", "Body", ":", "message", ",", "DeliveryMode", ":", "amqp", ".", "Persistent", ",", "}", ",", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "delay", "a", "task", "by", "delayDuration", "miliseconds", "the", "way", "it", "works", "is", "a", "new", "queue", "is", "created", "without", "any", "consumers", "the", "message", "is", "then", "published", "to", "this", "queue", "with", "appropriate", "ttl", "expiration", "headers", "after", "the", "expiration", "it", "is", "sent", "to", "the", "proper", "queue", "with", "consumers" ]

[ "func", "(", "s", "*", "Server", ")", "Version", "(", "ctx", "context", ".", "Context", ",", "req", "*", "pb", ".", "VersionRequest", ")", "(", "resp", "*", "pb", ".", "VersionResponse", ",", "err", "error", ")", "{", "const", "operation", "=", "\"", "\"", "\n", "defer", "func", "(", ")", "{", "recordOperation", "(", "operation", ",", "time", ".", "Now", "(", ")", ")", "\n", "recordError", "(", "operation", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "return", "&", "pb", ".", "VersionResponse", "{", "Version", ":", "kubeAPIVersion", ",", "RuntimeName", ":", "containerName", ",", "RuntimeVersion", ":", "version", ".", "Version", ",", "RuntimeApiVersion", ":", "runtimeAPIVersion", ",", "}", ",", "nil", "\n", "}" ]

[ "Version", "returns", "the", "runtime", "name", "runtime", "version", "and", "runtime", "API", "version" ]

[ "func", "(", "s", "*", "Sandbox", ")", "NetNsGet", "(", "nspath", ",", "name", "string", ")", "(", "*", "NetNs", ",", "error", ")", "{", "if", "err", ":=", "ns", ".", "IsNSorErr", "(", "nspath", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "ErrClosedNetNS", "\n", "}", "\n\n", "symlink", ",", "symlinkErr", ":=", "isSymbolicLink", "(", "nspath", ")", "\n", "if", "symlinkErr", "!=", "nil", "{", "return", "nil", ",", "symlinkErr", "\n", "}", "\n\n", "var", "resolvedNsPath", "string", "\n", "if", "symlink", "{", "path", ",", "err", ":=", "os", ".", "Readlink", "(", "nspath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "resolvedNsPath", "=", "path", "\n", "}", "else", "{", "resolvedNsPath", "=", "nspath", "\n", "}", "\n\n", "netNs", ",", "err", ":=", "getNetNs", "(", "resolvedNsPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "symlink", "{", "fd", ",", "err", ":=", "os", ".", "Open", "(", "nspath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "netNs", ".", "symlink", "=", "fd", "\n", "}", "else", "if", "err", ":=", "netNs", ".", "SymlinkCreate", "(", "name", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "netNs", ",", "nil", "\n", "}" ]

[ "NetNsGet", "returns", "the", "NetNs", "associated", "with", "the", "given", "nspath", "and", "name" ]

[ "func", "New", "(", "id", ",", "namespace", ",", "name", ",", "kubeName", ",", "logDir", "string", ",", "labels", ",", "annotations", "map", "[", "string", "]", "string", ",", "processLabel", ",", "mountLabel", "string", ",", "metadata", "*", "pb", ".", "PodSandboxMetadata", ",", "shmPath", ",", "cgroupParent", "string", ",", "privileged", "bool", ",", "runtimeHandler", "string", ",", "resolvPath", ",", "hostname", "string", ",", "portMappings", "[", "]", "*", "hostport", ".", "PortMapping", ",", "hostNetwork", "bool", ")", "(", "*", "Sandbox", ",", "error", ")", "{", "sb", ":=", "new", "(", "Sandbox", ")", "\n", "sb", ".", "id", "=", "id", "\n", "sb", ".", "namespace", "=", "namespace", "\n", "sb", ".", "name", "=", "name", "\n", "sb", ".", "kubeName", "=", "kubeName", "\n", "sb", ".", "logDir", "=", "logDir", "\n", "sb", ".", "labels", "=", "labels", "\n", "sb", ".", "annotations", "=", "annotations", "\n", "sb", ".", "containers", "=", "oci", ".", "NewMemoryStore", "(", ")", "\n", "sb", ".", "processLabel", "=", "processLabel", "\n", "sb", ".", "mountLabel", "=", "mountLabel", "\n", "sb", ".", "metadata", "=", "metadata", "\n", "sb", ".", "shmPath", "=", "shmPath", "\n", "sb", ".", "cgroupParent", "=", "cgroupParent", "\n", "sb", ".", "privileged", "=", "privileged", "\n", "sb", ".", "runtimeHandler", "=", "runtimeHandler", "\n", "sb", ".", "resolvPath", "=", "resolvPath", "\n", "sb", ".", "hostname", "=", "hostname", "\n", "sb", ".", "portMappings", "=", "portMappings", "\n", "sb", ".", "createdAt", "=", "time", ".", "Now", "(", ")", "\n", "sb", ".", "hostNetwork", "=", "hostNetwork", "\n\n", "return", "sb", ",", "nil", "\n", "}" ]

[ "New", "creates", "and", "populates", "a", "new", "pod", "sandbox", "New", "sandboxes", "have", "no", "containers", "no", "infra", "container", "and", "no", "network", "namespaces", "associated", "with", "them", "An", "infra", "container", "must", "be", "attached", "before", "the", "sandbox", "is", "added", "to", "the", "state" ]