Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "pe", "*", "PathExp", ")", "Contains", "(", "other", "*", "PathExp", ")", "bool", "{", "return", "pe", ".", "Org", ".", "Contains", "(", "other", ".", "Org", ".", "String", "(", ")", ")", "&&", "pe", ".", "Project", ".", "Contains", "(", "other", ".", "Project", ".", "String", "(", ")", ")", "&&", "pe", ".", "Envs", ".", "Contains", "(", "other", ".", "Envs", ".", "String", "(", ")", ")", "&&", "pe", ".", "Services", ".", "Contains", "(", "other", ".", "Services", ".", "String", "(", ")", ")", "&&", "pe", ".", "Identities", ".", "Contains", "(", "other", ".", "Identities", ".", "String", "(", ")", ")", "&&", "pe", ".", "Instances", ".", "Contains", "(", "other", ".", "Instances", ".", "String", "(", ")", ")", "\n", "}" ]

[ "Contains", "returns", "whether", "this", "path", "contains", "the", "subject", ".", "A", "path", "Contains", "another", "if", "it", "resolves", "to", "the", "other", "or", "they", "are", "equal", "." ]

[ "func", "(", "pe", "*", "PathExp", ")", "UnmarshalText", "(", "b", "[", "]", "byte", ")", "error", "{", "o", ",", "err", ":=", "Parse", "(", "string", "(", "b", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "pe", ".", "Org", "=", "o", ".", "Org", "\n", "pe", ".", "Project", "=", "o", ".", "Project", "\n", "pe", ".", "Envs", "=", "o", ".", "Envs", "\n", "pe", ".", "Services", "=", "o", ".", "Services", "\n", "pe", ".", "Instances", "=", "o", ".", "Instances", "\n", "pe", ".", "Identities", "=", "o", ".", "Identities", "\n\n", "return", "nil", "\n", "}" ]

[ "UnmarshalText", "implements", "the", "encoding", ".", "TextUnmarshaler", "interface", ".", "This", "will", "be", "used", "in", "json", "decoding", "." ]

[ "func", "(", "p", "*", "AuthProxy", ")", "Listen", "(", ")", "error", "{", "mux", ":=", "bone", ".", "New", "(", ")", "\n", "proxy", ":=", "&", "httputil", ".", "ReverseProxy", "{", "Transport", ":", "p", ".", "t", ",", "Director", ":", "func", "(", "r", "*", "http", ".", "Request", ")", "{", "r", ".", "URL", ".", "Scheme", "=", "p", ".", "u", ".", "Scheme", "\n", "r", ".", "URL", ".", "Host", "=", "p", ".", "u", ".", "Host", "\n", "r", ".", "Host", "=", "p", ".", "u", ".", "Host", "\n", "r", ".", "URL", ".", "Path", "=", "r", ".", "URL", ".", "Path", "[", "6", ":", "]", "\n\n", "if", "p", ".", "sess", ".", "HasToken", "(", ")", "{", "tok", ":=", "string", "(", "p", ".", "sess", ".", "Token", "(", ")", ")", "\n", "r", ".", "Header", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "\"", "\"", "+", "tok", "}", "\n", "}", "\n\n", "r", ".", "Header", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "\"", "\"", "+", "p", ".", "c", ".", "Version", "}", "\n", "r", ".", "Header", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "p", ".", "c", ".", "APIVersion", "}", "\n", "}", ",", "}", "\n\n", "go", "p", ".", "o", ".", "Start", "(", ")", "\n\n", "mux", ".", "HandleFunc", "(", "\"", "\"", ",", "proxyCanceler", "(", "proxy", ")", ")", "\n", "mux", ".", "SubRoute", "(", "\"", "\"", ",", "routes", ".", "NewRouteMux", "(", "p", ".", "c", ",", "p", ".", "sess", ",", "p", ".", "db", ",", "p", ".", "t", ",", "p", ".", "o", ",", "p", ".", "client", ",", "p", ".", "logic", ",", "p", ".", "updates", ")", ")", "\n\n", "h", ":=", "httpdown", ".", "HTTP", "{", "}", "\n", "p", ".", "s", "=", "h", ".", "Serve", "(", "&", "http", ".", "Server", "{", "Handler", ":", "requestIDHandler", "(", "loggingHandler", "(", "mux", ")", ")", "}", ",", "p", ".", "l", ")", "\n\n", "return", "p", ".", "s", ".", "Wait", "(", ")", "\n", "}" ]

[ "Listen", "starts", "the", "main", "loop", "of", "the", "AuthProxy", ".", "It", "returns", "on", "error", "or", "when", "the", "AuthProxy", "is", "closed", "." ]

[ "func", "(", "p", "*", "AuthProxy", ")", "Close", "(", ")", "error", "{", "p", ".", "o", ".", "Stop", "(", ")", "\n", "return", "p", ".", "s", ".", "Stop", "(", ")", "\n", "}" ]

[ "Close", "gracefully", "closes", "the", "socket", "ensuring", "all", "requests", "are", "finished", "within", "the", "timeout", "." ]

[ "func", "proxyCanceler", "(", "proxy", "http", ".", "Handler", ")", "http", ".", "HandlerFunc", "{", "return", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "ctx", ",", "cancelFunc", ":=", "context", ".", "WithTimeout", "(", "context", ".", "Background", "(", ")", ",", "60", "*", "time", ".", "Second", ")", "\n", "defer", "cancelFunc", "(", ")", "\n\n", "cw", ":=", "cancelingProxyResponseWriter", "{", "redirect", ":", "false", ",", "written", ":", "false", ",", "rw", ":", "w", ",", "}", "\n\n", "r", "=", "r", ".", "WithContext", "(", "ctx", ")", "\n", "done", ":=", "make", "(", "chan", "bool", ")", "\n", "go", "func", "(", ")", "{", "proxy", ".", "ServeHTTP", "(", "&", "cw", ",", "r", ")", "\n", "close", "(", "done", ")", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "<-", "done", ":", "return", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "if", "ctx", ".", "Err", "(", ")", "!=", "context", ".", "DeadlineExceeded", "{", "return", "\n", "}", "\n\n", "cw", ".", "redirect", "=", "true", "\n", "if", "!", "cw", ".", "written", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusRequestTimeout", ")", "\n\n", "enc", ":=", "json", ".", "NewEncoder", "(", "w", ")", "\n", "err", ":=", "enc", ".", "Encode", "(", "&", "apitypes", ".", "Error", "{", "Type", ":", "\"", "\"", ",", "Err", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "proxyCanceler", "supports", "canceling", "proxied", "requests", "via", "a", "timeout", "and", "returning", "a", "custom", "error", "response", "." ]

[ "func", "(", "c", "credentialSet", ")", "Add", "(", "cred", "apitypes", ".", "CredentialEnvelope", ")", "error", "{", "if", "(", "*", "cred", ".", "Body", ")", ".", "GetValue", "(", ")", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "name", ":=", "(", "*", "cred", ".", "Body", ")", ".", "GetName", "(", ")", "\n", "if", "existing", ",", "ok", ":=", "c", "[", "name", "]", ";", "ok", "{", "// The new credential is either as specific, or less specific than", "// the existing one. Keep the existing one.", "eBody", ":=", "*", "existing", ".", "Body", "\n", "if", "(", "*", "cred", ".", "Body", ")", ".", "GetPathExp", "(", ")", ".", "CompareSpecificity", "(", "eBody", ".", "GetPathExp", "(", ")", ")", "!=", "1", "{", "return", "nil", "\n", "}", "\n", "}", "\n\n", "c", "[", "name", "]", "=", "&", "cred", "\n", "return", "nil", "\n", "}" ]

[ "Add", "adds", "a", "credential", "to", "the", "credentialSet", "replacing", "an", "existing", "credential", "of", "the", "same", "name", "if", "the", "new", "credential", "is", "more", "specific", ".", "If", "the", "added", "credential", "is", "an", "unset", "value", "it", "is", "ignored", "." ]

[ "func", "(", "c", "credentialSet", ")", "ToSlice", "(", ")", "[", "]", "apitypes", ".", "CredentialEnvelope", "{", "creds", ":=", "make", "(", "[", "]", "apitypes", ".", "CredentialEnvelope", ",", "len", "(", "c", ")", ")", "\n", "i", ":=", "0", "\n", "for", "_", ",", "cred", ":=", "range", "c", "{", "creds", "[", "i", "]", "=", "*", "cred", "\n", "i", "++", "\n", "}", "\n\n", "sort", ".", "Sort", "(", "credSorter", "(", "creds", ")", ")", "\n", "return", "creds", "\n", "}" ]

[ "ToSlice", "returns", "a", "slice", "of", "the", "credentials", "in", "the", "set", "in", "lexicographically", "sorted", "order", "by", "name", "." ]

[ "func", "Display", "(", "possible", "...", "Cmd", ")", "{", "hint", ":=", "randHint", "(", "possible", ")", "\n", "if", "hint", "!=", "\"", "\"", "{", "ui", ".", "Hint", "(", "hint", ",", "false", ",", "nil", ")", "\n", "}", "\n", "}" ]

[ "Display", "chooses", "a", "random", "hint", "from", "the", "allotted", "commands", "and", "displays", "it" ]

[ "func", "randHint", "(", "possible", "[", "]", "Cmd", ")", "string", "{", "l", ":=", "len", "(", "possible", ")", "\n", "if", "l", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n\n", "// Seed random integer", "r", ":=", "rand", ".", "New", "(", "rand", ".", "NewSource", "(", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "UnixNano", "(", ")", ")", ")", "\n", "i", ":=", "r", ".", "Intn", "(", "l", ")", "\n", "cmd", ":=", "possible", "[", "i", "]", "\n", "if", "hints", ",", "ok", ":=", "commandHints", "[", "cmd", "]", ";", "ok", "{", "item", ":=", "r", ".", "Intn", "(", "len", "(", "hints", ")", ")", "\n", "if", "len", "(", "hints", ")", ">", "item", "{", "return", "hints", "[", "item", "]", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "randHint", "returns", "random", "hint", "from", "chosen", "command", "s", "list" ]

[ "func", "(", "c", "*", "CredentialsClient", ")", "Search", "(", "ctx", "context", ".", "Context", ",", "pathexp", "string", ",", "teamIDs", "[", "]", "identity", ".", "ID", ",", "p", "ProgressFunc", ")", "(", "[", "]", "apitypes", ".", "CredentialEnvelope", ",", "error", ")", "{", "v", ":=", "&", "url", ".", "Values", "{", "}", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "pathexp", ")", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "for", "_", ",", "id", ":=", "range", "teamIDs", "{", "v", ".", "Add", "(", "\"", "\"", ",", "id", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "return", "c", ".", "listWorker", "(", "ctx", ",", "v", ",", "p", ")", "\n", "}" ]

[ "Search", "returns", "all", "credentials", "at", "the", "given", "pathexp", "in", "an", "undecrypted", "state" ]

[ "func", "(", "c", "*", "CredentialsClient", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "path", "string", ",", "p", "ProgressFunc", ")", "(", "[", "]", "apitypes", ".", "CredentialEnvelope", ",", "error", ")", "{", "v", ":=", "&", "url", ".", "Values", "{", "}", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "path", ")", "\n\n", "return", "c", ".", "listWorker", "(", "ctx", ",", "v", ",", "p", ")", "\n", "}" ]

[ "Get", "returns", "all", "credentials", "at", "the", "given", "path", "." ]

[ "func", "(", "c", "*", "CredentialsClient", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "creds", "[", "]", "*", "apitypes", ".", "CredentialEnvelope", ",", "progress", "ProgressFunc", ")", "(", "[", "]", "apitypes", ".", "CredentialEnvelope", ",", "error", ")", "{", "resp", ":=", "[", "]", "apitypes", ".", "CredentialResp", "{", "}", "\n", "err", ":=", "c", ".", "client", ".", "DaemonRoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "creds", ",", "&", "resp", ",", "progress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "createEnvelopesFromResp", "(", "resp", ")", "\n", "}" ]

[ "Create", "creates", "the", "given", "credential" ]

[ "func", "NewMutable", "(", "body", "Mutable", ")", "(", "ID", ",", "error", ")", "{", "id", ":=", "ID", "{", "idVersion", ",", "body", ".", "Type", "(", ")", "}", "\n", "_", ",", "err", ":=", "rand", ".", "Read", "(", "id", "[", "2", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "return", "id", ",", "nil", "\n", "}" ]

[ "NewMutable", "returns", "a", "new", "ID", "for", "a", "mutable", "object", "." ]

[ "func", "DeriveMutable", "(", "body", "Mutable", ",", "base", "*", "ID", ",", "derivableType", "byte", ")", "ID", "{", "id", ":=", "ID", "{", "idVersion", ",", "body", ".", "Type", "(", ")", ",", "derivableType", "}", "\n", "copy", "(", "id", "[", "3", ":", "]", ",", "base", "[", "2", ":", "17", "]", ")", "\n\n", "return", "id", "\n", "}" ]

[ "DeriveMutable", "returns", "a", "ID", "for", "a", "mutable", "object", "based", "on", "another", "ID", "." ]

[ "func", "NewImmutable", "(", "body", "Immutable", ",", "sig", "interface", "{", "}", ")", "(", "ID", ",", "error", ")", "{", "h", ",", "err", ":=", "blake2b", ".", "New", "(", "&", "blake2b", ".", "Config", "{", "Size", ":", "16", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n\n", "h", ".", "Write", "(", "[", "]", "byte", "(", "strconv", ".", "Itoa", "(", "body", ".", "Version", "(", ")", ")", ")", ")", "\n\n", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "h", ".", "Write", "(", "b", ")", "\n\n", "b", ",", "err", "=", "json", ".", "Marshal", "(", "sig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "h", ".", "Write", "(", "b", ")", "\n\n", "id", ":=", "ID", "{", "idVersion", ",", "body", ".", "Type", "(", ")", "}", "\n\n", "copy", "(", "id", "[", "2", ":", "]", ",", "h", ".", "Sum", "(", "nil", ")", ")", "\n\n", "return", "id", ",", "nil", "\n", "}" ]

[ "NewImmutable", "returns", "a", "new", "signed", "ID", "for", "an", "immutable", "object", ".", "sig", "should", "be", "a", "registry", ".", "Signature", "type" ]

[ "func", "(", "id", "*", "ID", ")", "UnmarshalJSON", "(", "b", "[", "]", "byte", ")", "error", "{", "if", "len", "(", "b", ")", "<", "2", "||", "b", "[", "0", "]", "!=", "byte", "(", "'\"'", ")", "||", "b", "[", "len", "(", "b", ")", "-", "1", "]", "!=", "byte", "(", "'\"'", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "id", ".", "fillID", "(", "b", "[", "1", ":", "len", "(", "b", ")", "-", "1", "]", ")", "\n", "}" ]

[ "UnmarshalJSON", "implements", "the", "json", ".", "Unmarshaler", "interface", "for", "IDs", "." ]

[ "func", "New", "(", "org", ",", "team", ",", "certpath", ",", "keypath", "string", ",", "cfg", "*", "config", ".", "Config", ")", "(", "g", "*", "http", ".", "Gatekeeper", ",", "err", "error", ")", "{", "api", ":=", "api", ".", "NewClient", "(", "cfg", ")", "\n", "http", ",", "err", ":=", "http", ".", "NewGatekeeper", "(", "org", ",", "team", ",", "certpath", ",", "keypath", ",", "cfg", ",", "api", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "http", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "new", "Gatekeeper" ]

[ "func", "(", "p", "*", "PoliciesClient", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "policy", "*", "primitive", ".", "Policy", ")", "(", "*", "envelope", ".", "Policy", ",", "error", ")", "{", "ID", ",", "err", ":=", "identity", ".", "NewMutable", "(", "policy", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "env", ":=", "envelope", ".", "Policy", "{", "ID", ":", "&", "ID", ",", "Version", ":", "1", ",", "Body", ":", "policy", ",", "}", "\n\n", "res", ":=", "envelope", ".", "Policy", "{", "}", "\n", "err", "=", "p", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "env", ",", "&", "res", ")", "\n", "return", "&", "res", ",", "err", "\n", "}" ]

[ "Create", "creates", "a", "new", "policy" ]

[ "func", "(", "p", "*", "PoliciesClient", ")", "Delete", "(", "ctx", "context", ".", "Context", ",", "policyID", "*", "identity", ".", "ID", ")", "error", "{", "url", ":=", "\"", "\"", "+", "policyID", ".", "String", "(", ")", "\n", "return", "p", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "url", ",", "nil", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "Delete", "destroys", "the", "policy", "for", "the", "given", "ID" ]

[ "func", "(", "p", "*", "PoliciesClient", ")", "Attach", "(", "ctx", "context", ".", "Context", ",", "org", ",", "policy", ",", "team", "*", "identity", ".", "ID", ")", "error", "{", "attachment", ":=", "primitive", ".", "PolicyAttachment", "{", "OrgID", ":", "org", ",", "OwnerID", ":", "team", ",", "PolicyID", ":", "policy", ",", "}", "\n\n", "ID", ",", "err", ":=", "identity", ".", "NewMutable", "(", "&", "attachment", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "env", ":=", "envelope", ".", "PolicyAttachment", "{", "ID", ":", "&", "ID", ",", "Version", ":", "1", ",", "Body", ":", "&", "attachment", ",", "}", "\n\n", "return", "p", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "&", "env", ",", "nil", ")", "\n", "}" ]

[ "Attach", "attaches", "a", "policy", "to", "a", "team" ]

[ "func", "(", "p", "*", "PoliciesClient", ")", "Detach", "(", "ctx", "context", ".", "Context", ",", "attachmentID", "*", "identity", ".", "ID", ")", "error", "{", "return", "p", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", "+", "attachmentID", ".", "String", "(", ")", ",", "nil", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "Detach", "deletes", "a", "specific", "attachment" ]

[ "func", "(", "p", "*", "PoliciesClient", ")", "AttachmentsList", "(", "ctx", "context", ".", "Context", ",", "orgID", ",", "ownerID", ",", "policyID", "*", "identity", ".", "ID", ")", "(", "[", "]", "envelope", ".", "PolicyAttachment", ",", "error", ")", "{", "v", ":=", "&", "url", ".", "Values", "{", "}", "\n", "if", "orgID", "!=", "nil", "{", "v", ".", "Set", "(", "\"", "\"", ",", "orgID", ".", "String", "(", ")", ")", "\n", "}", "\n", "if", "ownerID", "!=", "nil", "{", "v", ".", "Set", "(", "\"", "\"", ",", "ownerID", ".", "String", "(", ")", ")", "\n", "}", "\n", "if", "policyID", "!=", "nil", "{", "v", ".", "Set", "(", "\"", "\"", ",", "policyID", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "attachments", ":=", "[", "]", "envelope", ".", "PolicyAttachment", "{", "}", "\n", "err", ":=", "p", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "v", ",", "nil", ",", "&", "attachments", ")", "\n", "return", "attachments", ",", "err", "\n", "}" ]

[ "AttachmentsList", "retrieves", "all", "policy", "attachments", "for", "an", "org" ]

[ "func", "parseRawPath", "(", "rawPath", "string", ")", "(", "*", "pathexp", ".", "PathExp", ",", "*", "string", ",", "error", ")", "{", "idx", ":=", "strings", ".", "LastIndex", "(", "rawPath", ",", "\"", "\"", ")", "\n", "if", "idx", "==", "-", "1", "{", "return", "nil", ",", "nil", ",", "errs", ".", "NewExitError", "(", "\"", "\"", ")", "\n", "}", "\n", "secret", ":=", "rawPath", "[", "idx", "+", "1", ":", "]", "\n", "path", ":=", "rawPath", "[", ":", "idx", "]", "\n\n", "if", "secret", "==", "\"", "\"", "{", "path", "=", "rawPath", "\n", "secret", "=", "\"", "\"", "\n", "}", "\n\n", "// Ensure that the secret name is valid", "if", "!", "pathexp", ".", "ValidSecret", "(", "secret", ")", "{", "return", "nil", ",", "nil", ",", "errs", ".", "NewExitError", "(", "\"", "\"", "+", "secret", ")", "\n", "}", "\n\n", "pe", ",", "err", ":=", "parsePathExp", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errs", ".", "NewErrorExitError", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "pe", ",", "&", "secret", ",", "nil", "\n", "}" ]

[ "parseRawPath", "parses", "and", "validates", "a", "raw", "path", "possibly", "including", "a", "secret", ".", "The", "secret", "portion", "is", "also", "validated", "." ]

[ "func", "(", "k", "*", "KeyPairsClient", ")", "Revoke", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ",", "output", "ProgressFunc", ")", "error", "{", "return", "k", ".", "worker", "(", "ctx", ",", "\"", "\"", ",", "orgID", ",", "output", ")", "\n", "}" ]

[ "Revoke", "revokes", "the", "existing", "keypairs", "for", "the", "user", "in", "the", "given", "org", "." ]

[ "func", "(", "t", "*", "TokensClient", ")", "PostLogin", "(", "ctx", "context", ".", "Context", ",", "creds", "apitypes", ".", "LoginCredential", ")", "(", "*", "base64", ".", "Value", ",", "*", "envelope", ".", "Token", ",", "error", ")", "{", "respBody", ":=", "loginTokenResponse", "{", "}", "\n\n", "var", "body", "interface", "{", "}", "\n", "switch", "creds", ".", "Type", "(", ")", "{", "case", "apitypes", ".", "UserSession", ":", "body", "=", "&", "loginTokenUserRequest", "{", "Type", ":", "primitive", ".", "LoginToken", ",", "Email", ":", "creds", ".", "Identifier", "(", ")", ",", "}", "\n", "case", "apitypes", ".", "MachineSession", ":", "body", "=", "&", "loginTokenMachineRequest", "{", "Type", ":", "primitive", ".", "LoginToken", ",", "TokenID", ":", "creds", ".", "Identifier", "(", ")", ",", "}", "\n", "}", "\n\n", "err", ":=", "tokenRoundTrip", "(", "ctx", ",", "t", ".", "client", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "body", ",", "&", "respBody", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "return", "respBody", ".", "Salt", ",", "respBody", ".", "Token", ",", "nil", "\n", "}" ]

[ "PostLogin", "requests", "a", "login", "token", "from", "the", "registry", "for", "the", "provided", "email", "address", "." ]

[ "func", "(", "t", "*", "TokensClient", ")", "PostEdDSAAuth", "(", "ctx", "context", ".", "Context", ",", "token", "string", ",", "sig", "*", "base64", ".", "Value", ")", "(", "*", "envelope", ".", "Token", ",", "error", ")", "{", "authReq", ":=", "authTokenEdDSARequest", "{", "Type", ":", "primitive", ".", "AuthToken", ",", "TokenSig", ":", "sig", "}", "\n", "return", "t", ".", "postAuthWorker", "(", "ctx", ",", "token", ",", "&", "authReq", ")", "\n", "}" ]

[ "PostEdDSAAuth", "requests", "an", "auth", "token", "from", "the", "registry", "for", "the", "provided", "login", "token", "value", "and", "it", "s", "signature", "." ]

[ "func", "(", "t", "*", "TokensClient", ")", "PostUpgradeEdDSAAuth", "(", "ctx", "context", ".", "Context", ",", "token", ",", "hmac", "string", ",", "sig", ",", "publicKey", "*", "base64", ".", "Value", ")", "(", "*", "envelope", ".", "Token", ",", "error", ")", "{", "authReq", ":=", "authTokenUpgradeEdDSARequest", "{", "Type", ":", "primitive", ".", "AuthToken", ",", "TokenSig", ":", "sig", ",", "PublicKey", ":", "publicKey", ",", "TokenHMAC", ":", "hmac", ",", "}", "\n\n", "return", "t", ".", "postAuthWorker", "(", "ctx", ",", "token", ",", "&", "authReq", ")", "\n", "}" ]

[ "PostUpgradeEdDSAAuth", "requests", "an", "auth", "token", "from", "the", "registry", "while", "upgrading", "the", "user", "from", "HMAC", "based", "authentication", "to", "EdDSA" ]

[ "func", "(", "t", "*", "TokensClient", ")", "Delete", "(", "ctx", "context", ".", "Context", ",", "token", "string", ")", "error", "{", "return", "tokenRoundTrip", "(", "ctx", ",", "t", ".", "client", ",", "token", ",", "\"", "\"", ",", "\"", "\"", "+", "token", ",", "nil", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "Delete", "deletes", "the", "token", "with", "the", "provided", "value", "from", "the", "registry", ".", "This", "effectively", "logs", "a", "user", "out", "." ]

[ "func", "NewDB", "(", "path", "string", ")", "(", "*", "DB", ",", "error", ")", "{", "db", ":=", "&", "DB", "{", "}", "\n\n", "valid", ",", "err", ":=", "db", ".", "initBolt", "(", "path", ")", "\n", "if", "valid", "&&", "err", "==", "nil", "{", "return", "db", ",", "nil", "\n", "}", "\n\n", "if", "!", "valid", "{", "log", ".", "Print", "(", "\"", "\"", ")", "\n", "}", "\n\n", "err", "=", "os", ".", "Remove", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n\n", "valid", ",", "err", "=", "db", ".", "initBolt", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "!", "valid", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "db", ",", "nil", "\n", "}" ]

[ "NewDB", "creates", "a", "new", "db", "or", "opens", "an", "existing", "db", "at", "the", "given", "path", ".", "If", "the", "db", "already", "exists", "but", "has", "a", "mismatched", "version", "it", "will", "be", "cleared", "before", "being", "returned", "." ]

[ "func", "(", "db", "*", "DB", ")", "initBolt", "(", "path", "string", ")", "(", "bool", ",", "error", ")", "{", "var", "err", "error", "\n", "db", ".", "db", ",", "err", "=", "bolt", ".", "Open", "(", "path", ",", "0600", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "db", ".", "checkMeta", "(", ")", "\n", "}" ]

[ "initBolt", "initializes", "the", "backing", "bolt", "db", "checking", "that", "the", "metadata", "schema", "version", "matches", "what", "we", "expect" ]

[ "func", "(", "db", "*", "DB", ")", "checkMeta", "(", ")", "(", "bool", ",", "error", ")", "{", "var", "version", "[", "]", "byte", "\n", "err", ":=", "db", ".", "db", ".", "Update", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "meta", ",", "err", ":=", "tx", ".", "CreateBucketIfNotExists", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "version", "=", "meta", ".", "Get", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "if", "version", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "err", "=", "meta", ".", "Put", "(", "[", "]", "byte", "(", "\"", "\"", ")", ",", "schemaVersion", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "version", "=", "schemaVersion", "\n", "return", "nil", "\n", "}", ")", "\n\n", "return", "bytes", ".", "Equal", "(", "version", ",", "schemaVersion", ")", ",", "err", "\n", "}" ]

[ "checkMeta", "check", "s", "the", "db", "s", "metadata", "ensuring", "the", "version", "of", "the", "db", "is", "correct", "or", "setting", "it", "if", "it", "does", "not", "exist", "." ]

[ "func", "(", "db", "*", "DB", ")", "Set", "(", "envs", "...", "envelope", ".", "Envelope", ")", "error", "{", "return", "db", ".", "db", ".", "Update", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "for", "_", ",", "env", ":=", "range", "envs", "{", "id", ":=", "env", ".", "GetID", "(", ")", "\n\n", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "env", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "bucket", ",", "err", ":=", "tx", ".", "CreateBucketIfNotExists", "(", "[", "]", "byte", "{", "id", ".", "Type", "(", ")", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "bucket", ".", "Put", "(", "id", "[", ":", "]", ",", "b", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "Set", "stores", "the", "serialized", "value", "of", "env", "into", "the", "db", "under", "key", "id", ".", "Stored", "values", "are", "grouped", "by", "their", "type", "." ]

[ "func", "(", "db", "*", "DB", ")", "Get", "(", "id", "*", "identity", ".", "ID", ",", "env", "envelope", ".", "Envelope", ")", "error", "{", "return", "db", ".", "db", ".", "View", "(", "func", "(", "tx", "*", "bolt", ".", "Tx", ")", "error", "{", "bucket", ":=", "tx", ".", "Bucket", "(", "[", "]", "byte", "{", "id", ".", "Type", "(", ")", "}", ")", "\n", "if", "bucket", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "b", ":=", "bucket", ".", "Get", "(", "id", "[", ":", "]", ")", "\n", "if", "b", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "json", ".", "Unmarshal", "(", "b", ",", "env", ")", "\n", "}", ")", "\n", "}" ]

[ "Get", "returns", "the", "value", "of", "id", "in", "env", ".", "It", "returns", "an", "error", "if", "id", "does", "not", "exist", "." ]

[ "func", "NewClaim", "(", "orgID", ",", "ownerID", ",", "previous", ",", "pubKeyID", "*", "identity", ".", "ID", ",", "claimType", "ClaimType", ")", "*", "Claim", "{", "return", "&", "Claim", "{", "OrgID", ":", "orgID", ",", "OwnerID", ":", "ownerID", ",", "Previous", ":", "previous", ",", "PublicKeyID", ":", "pubKeyID", ",", "ClaimType", ":", "claimType", ",", "Created", ":", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ",", "}", "\n", "}" ]

[ "NewClaim", "returns", "a", "new", "Claim", "with", "the", "created", "time", "set", "to", "now" ]

[ "func", "NewKeyring", "(", "orgID", ",", "projectID", "*", "identity", ".", "ID", ",", "pathExp", "*", "pathexp", ".", "PathExp", ")", "*", "Keyring", "{", "return", "&", "Keyring", "{", "BaseKeyring", ":", "BaseKeyring", "{", "Created", ":", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ",", "OrgID", ":", "orgID", ",", "PathExp", ":", "pathExp", ",", "ProjectID", ":", "projectID", ",", "// This is the first instance of the keyring, so version is 1,", "// and there is no previous instance.", "Previous", ":", "nil", ",", "KeyringVersion", ":", "1", ",", "}", ",", "}", "\n", "}" ]

[ "NewKeyring", "returns", "a", "new", "v2", "Keyring", "with", "the", "created", "time", "set", "to", "now" ]

[ "func", "(", "pe", "*", "PolicyEffect", ")", "MarshalText", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "*", "pe", "{", "return", "[", "]", "byte", "(", "\"", "\"", ")", ",", "nil", "\n", "}", "\n", "return", "[", "]", "byte", "(", "\"", "\"", ")", ",", "nil", "\n", "}" ]

[ "MarshalText", "implements", "the", "encoding", ".", "TextMarshaler", "interface", "used", "for", "JSON", "marshaling", "." ]

[ "func", "(", "pa", "*", "PolicyAction", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "out", ":=", "[", "]", "string", "{", "}", "\n\n", "for", "i", ",", "v", ":=", "range", "policyActionStrings", "{", "if", "(", "1", "<<", "uint", "(", "i", ")", ")", "&", "byte", "(", "*", "pa", ")", ">", "0", "{", "out", "=", "append", "(", "out", ",", "v", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "out", ")", "==", "1", "{", "return", "json", ".", "Marshal", "(", "out", "[", "0", "]", ")", "\n", "}", "\n\n", "return", "json", ".", "Marshal", "(", "out", ")", "\n", "}" ]

[ "MarshalJSON", "implements", "the", "json", ".", "Marshaler", "interface", ".", "A", "PolicyAction", "is", "encoded", "in", "JSON", "either", "the", "string", "representations", "of", "its", "actions", "in", "a", "list", "or", "a", "single", "string", "when", "there", "is", "only", "one", "action", "." ]

[ "func", "(", "pa", "*", "PolicyAction", ")", "ShortString", "(", ")", "string", "{", "out", ":=", "[", "]", "byte", "{", "}", "\n\n", "for", "i", ",", "v", ":=", "range", "policyActionStrings", "{", "if", "(", "1", "<<", "uint", "(", "i", ")", ")", "&", "byte", "(", "*", "pa", ")", ">", "0", "{", "out", "=", "append", "(", "out", ",", "v", "[", "0", "]", ")", "\n", "}", "else", "{", "out", "=", "append", "(", "out", ",", "'-'", ")", "\n", "}", "\n", "}", "\n\n", "return", "string", "(", "out", ")", "\n", "}" ]

[ "ShortString", "displays", "a", "single", "character", "representation", "of", "each", "of", "the", "policy", "s", "actions", "." ]

[ "func", "(", "i", "*", "OrgInvitesClient", ")", "Approve", "(", "ctx", "context", ".", "Context", ",", "inviteID", "identity", ".", "ID", ",", "output", "ProgressFunc", ")", "error", "{", "return", "i", ".", "client", ".", "DaemonRoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", "+", "inviteID", ".", "String", "(", ")", "+", "\"", "\"", ",", "nil", ",", "nil", ",", "nil", ",", "output", ")", "\n", "}" ]

[ "Approve", "executes", "the", "approve", "invite", "request" ]

[ "func", "(", "w", "*", "Worklog", ")", "List", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ",", "itemType", "apitypes", ".", "WorklogType", ")", "(", "[", "]", "apitypes", ".", "WorklogItem", ",", "error", ")", "{", "org", ",", "err", ":=", "w", ".", "engine", ".", "client", ".", "Orgs", ".", "Get", "(", "ctx", ",", "orgID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "items", "[", "]", "apitypes", ".", "WorklogItem", "\n", "for", "t", ",", "h", ":=", "range", "w", ".", "handlers", "{", "if", "t", "&", "itemType", "==", "0", "{", "continue", "\n", "}", "\n\n", "hItems", ",", "err", ":=", "h", ".", "list", "(", "ctx", ",", "org", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "items", "=", "append", "(", "items", ",", "hItems", "...", ")", "\n", "}", "\n\n", "return", "items", ",", "nil", "\n", "}" ]

[ "List", "returns", "the", "list", "of", "all", "outstanding", "worklog", "items", "for", "the", "given", "org" ]

[ "func", "(", "w", "*", "Worklog", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ",", "ident", "*", "apitypes", ".", "WorklogID", ")", "(", "*", "apitypes", ".", "WorklogItem", ",", "error", ")", "{", "items", ",", "err", ":=", "w", ".", "List", "(", "ctx", ",", "orgID", ",", "ident", ".", "Type", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "item", ":=", "range", "items", "{", "if", "*", "item", ".", "ID", "==", "*", "ident", "{", "return", "&", "item", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Get", "returns", "a", "single", "worklog", "item", "for", "the", "given", "org", "with", "the", "given", "ident", "." ]

[ "func", "(", "w", "*", "Worklog", ")", "Resolve", "(", "ctx", "context", ".", "Context", ",", "n", "*", "observer", ".", "Notifier", ",", "orgID", "*", "identity", ".", "ID", ",", "ident", "*", "apitypes", ".", "WorklogID", ")", "error", "{", "item", ",", "err", ":=", "w", ".", "Get", "(", "ctx", ",", "orgID", ",", "ident", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "item", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "for", "t", ",", "h", ":=", "range", "w", ".", "handlers", "{", "if", "t", "&", "item", ".", "Type", "(", ")", "==", "0", "{", "continue", "\n", "}", "\n\n", "return", "h", ".", "resolve", "(", "ctx", ",", "n", ",", "orgID", ",", "item", ")", "\n", "}", "\n\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "Resolve", "attempts", "to", "resolve", "the", "worklog", "item", "in", "the", "given", "org", "with", "the", "given", "ident", "." ]

[ "func", "(", "u", "*", "UsersClient", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "userObj", "*", "envelope", ".", "User", ",", "signup", "apitypes", ".", "Signup", ")", "(", "envelope", ".", "UserInf", ",", "error", ")", "{", "v", ":=", "&", "url", ".", "Values", "{", "}", "\n", "if", "signup", ".", "InviteCode", "!=", "\"", "\"", "{", "v", ".", "Set", "(", "\"", "\"", ",", "signup", ".", "InviteCode", ")", "\n", "}", "\n", "if", "signup", ".", "OrgInvite", "&&", "signup", ".", "OrgName", "!=", "\"", "\"", "{", "v", ".", "Set", "(", "\"", "\"", ",", "signup", ".", "OrgName", ")", "\n", "}", "\n", "if", "signup", ".", "Email", "!=", "\"", "\"", "{", "v", ".", "Set", "(", "\"", "\"", ",", "signup", ".", "Email", ")", "\n", "}", "\n\n", "e", ":=", "envelope", ".", "Unsigned", "{", "}", "\n", "err", ":=", "u", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "v", ",", "&", "userObj", ",", "&", "e", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "envelope", ".", "ConvertUser", "(", "&", "e", ")", "\n", "}" ]

[ "Create", "attempts", "to", "register", "a", "new", "user" ]

[ "func", "(", "u", "*", "UsersClient", ")", "VerifyEmail", "(", "ctx", "context", ".", "Context", ",", "verifyCode", "string", ")", "error", "{", "verify", ":=", "apitypes", ".", "VerifyEmail", "{", "Code", ":", "verifyCode", ",", "}", "\n", "return", "u", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "&", "verify", ",", "nil", ")", "\n", "}" ]

[ "VerifyEmail", "will", "confirm", "the", "user", "s", "email", "with", "the", "registry" ]

[ "func", "(", "u", "*", "UsersClient", ")", "Update", "(", "ctx", "context", ".", "Context", ",", "userObj", "interface", "{", "}", ")", "(", "envelope", ".", "UserInf", ",", "error", ")", "{", "e", ":=", "envelope", ".", "Unsigned", "{", "}", "\n", "err", ":=", "u", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "userObj", ",", "&", "e", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "envelope", ".", "ConvertUser", "(", "&", "e", ")", "\n", "}" ]

[ "Update", "patches", "the", "user", "object", "with", "whitelisted", "fields" ]

[ "func", "(", "e", "*", "Engine", ")", "ApproveInvite", "(", "ctx", "context", ".", "Context", ",", "notifier", "*", "observer", ".", "Notifier", ",", "InviteID", "*", "identity", ".", "ID", ")", "(", "*", "envelope", ".", "OrgInvite", ",", "error", ")", "{", "n", ":=", "notifier", ".", "Notifier", "(", "3", ")", "\n\n", "invite", ",", "err", ":=", "e", ".", "client", ".", "OrgInvites", ".", "Get", "(", "ctx", ",", "InviteID", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "invite", ".", "Body", ".", "State", "!=", "primitive", ".", "OrgInviteAcceptedState", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "invite", ".", "Body", ".", "State", ")", "\n", "return", "nil", ",", "&", "apitypes", ".", "Error", "{", "Type", ":", "apitypes", ".", "BadRequestError", ",", "Err", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", "\n", "}", "\n\n", "n", ".", "Notify", "(", "observer", ".", "Progress", ",", "\"", "\"", ",", "true", ")", "\n\n", "v1members", ",", "v2members", ",", "err", ":=", "createKeyringMemberships", "(", "ctx", ",", "e", ".", "crypto", ",", "e", ".", "client", ",", "e", ".", "session", ",", "invite", ".", "Body", ".", "OrgID", ",", "invite", ".", "Body", ".", "InviteeID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "n", ".", "Notify", "(", "observer", ".", "Progress", ",", "\"", "\"", ",", "true", ")", "\n\n", "invite", ",", "err", "=", "e", ".", "client", ".", "OrgInvites", ".", "Approve", "(", "ctx", ",", "InviteID", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "n", ".", "Notify", "(", "observer", ".", "Progress", ",", "\"", "\"", ",", "true", ")", "\n\n", "if", "len", "(", "v1members", ")", "!=", "0", "{", "_", ",", "err", "=", "e", ".", "client", ".", "KeyringMember", ".", "Post", "(", "ctx", ",", "v1members", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "member", ":=", "range", "v2members", "{", "err", "=", "e", ".", "client", ".", "Keyring", ".", "Members", ".", "Post", "(", "ctx", ",", "member", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "invite", ",", "nil", "\n", "}" ]

[ "ApproveInvite", "approves", "an", "invitation", "of", "a", "user", "into", "an", "organzation", "by", "encoding", "them", "into", "a", "Keyring", "." ]

[ "func", "(", "v", "*", "VersionClient", ")", "Get", "(", "ctx", "context", ".", "Context", ")", "(", "*", "apitypes", ".", "Version", ",", "error", ")", "{", "version", ":=", "apitypes", ".", "Version", "{", "}", "\n", "err", ":=", "v", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", "&", "version", ")", "\n", "return", "&", "version", ",", "err", "\n", "}" ]

[ "Get", "returns", "the", "registry", "s", "release", "version", "." ]

[ "func", "(", "p", "*", "ProjectsClient", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "org", "*", "identity", ".", "ID", ",", "name", "string", ")", "(", "*", "envelope", ".", "Project", ",", "error", ")", "{", "project", ":=", "projectCreateRequest", "{", "}", "\n", "project", ".", "Body", ".", "OrgID", "=", "org", "\n", "project", ".", "Body", ".", "Name", "=", "name", "\n\n", "res", ":=", "envelope", ".", "Project", "{", "}", "\n", "err", ":=", "p", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "&", "project", ",", "&", "res", ")", "\n", "return", "&", "res", ",", "err", "\n", "}" ]

[ "Create", "creates", "a", "new", "project", "with", "the", "given", "name", "within", "the", "given", "org" ]

[ "func", "(", "p", "*", "ProjectsClient", ")", "List", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ")", "(", "[", "]", "envelope", ".", "Project", ",", "error", ")", "{", "orgs", ":=", "[", "]", "identity", ".", "ID", "{", "*", "orgID", "}", "\n", "return", "p", ".", "Search", "(", "ctx", ",", "orgs", ",", "nil", ")", "\n", "}" ]

[ "List", "returns", "a", "list", "of", "all", "Projects", "within", "the", "given", "org", "." ]

[ "func", "(", "p", "*", "ProjectsClient", ")", "GetTree", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ")", "(", "[", "]", "ProjectTreeSegment", ",", "error", ")", "{", "v", ":=", "&", "url", ".", "Values", "{", "}", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "orgID", ".", "String", "(", ")", ")", "\n\n", "var", "segments", "[", "]", "ProjectTreeSegment", "\n", "err", ":=", "p", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "v", ",", "nil", ",", "&", "segments", ")", "\n", "return", "segments", ",", "err", "\n", "}" ]

[ "GetTree", "returns", "a", "project", "tree" ]

[ "func", "SelectAcceptAction", "(", ")", "(", "int", ",", "string", ",", "error", ")", "{", "label", ":=", "\"", "\"", "\n", "v", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n", "p", ":=", "selectPrompt", "(", "label", ",", "\"", "\"", ",", "validate", ".", "OneOf", "(", "v", ")", ")", "\n\n", "return", "p", "(", "v", ",", "\"", "\"", ")", "\n", "}" ]

[ "SelectAcceptAction", "prompts", "the", "user", "to", "select", "whether", "they", "want", "to", "log", "into", "an", "existing", "account", "or", "to", "create", "a", "new", "one", "when", "they", "re", "accepting", "an", "org", "invitation", "." ]

[ "func", "(", "pp", "*", "primitiveParser", ")", "Parse", "(", ")", "map", "[", "string", "]", "*", "data", "{", "pp", ".", "loadTypeComments", "(", ")", "\n", "pp", ".", "loadStructs", "(", ")", "\n\n", "visible", ":=", "make", "(", "map", "[", "string", "]", "*", "data", ")", "\n", "for", "k", ":=", "range", "pp", ".", "structmap", "{", "if", "strings", ".", "ToUpper", "(", "string", "(", "k", "[", "0", "]", ")", ")", "!=", "string", "(", "k", "[", "0", "]", ")", "{", "// not exported", "continue", "\n", "}", "\n", "pp", ".", "visitStruct", "(", "visible", ",", "k", ",", "false", ")", "\n", "}", "\n\n", "return", "visible", "\n", "}" ]

[ "Parse", "performs", "the", "actual", "work", "of", "walking", "over", "all", "defined", "structs", "and", "building", "data", "representations", "of", "them", "for", "use", "in", "template", "rendering", "." ]

[ "func", "(", "pp", "*", "primitiveParser", ")", "visitStruct", "(", "reachable", "map", "[", "string", "]", "*", "data", ",", "k", "string", ",", "visible", "bool", ")", "{", "if", "_", ",", "ok", ":=", "reachable", "[", "k", "]", ";", "ok", "{", "// already included", "return", "\n", "}", "\n\n", "s", ":=", "pp", ".", "structmap", "[", "k", "]", "\n\n", "d", ":=", "data", "{", "Name", ":", "k", ",", "Byte", ":", "pp", ".", "typedecls", "[", "pp", ".", "fset", ".", "Position", "(", "s", ".", "Pos", "(", ")", ")", ".", "Line", "]", ",", "}", "\n", "d", ".", "Immutable", ",", "d", ".", "Version", ",", "d", ".", "Fields", "=", "pp", ".", "gatherFields", "(", "reachable", ",", "s", ",", "visible", ")", "\n", "d", ".", "Visible", "=", "visible", "||", "d", ".", "Immutable", "\n\n", "sort", ".", "Sort", "(", "sortFields", "(", "d", ".", "Fields", ")", ")", "\n", "reachable", "[", "k", "]", "=", "&", "d", "\n", "}" ]

[ "visitStruct", "inspects", "the", "struct", "with", "the", "given", "name", "parsing", "out", "its", "field", "definitions", "and", "mutability", "state", "." ]

[ "func", "(", "pp", "*", "primitiveParser", ")", "gatherFields", "(", "reachable", "map", "[", "string", "]", "*", "data", ",", "s", "*", "ast", ".", "StructType", ",", "visible", "bool", ")", "(", "bool", ",", "uint8", ",", "[", "]", "field", ")", "{", "fields", ":=", "[", "]", "field", "{", "}", "\n\n", "immutable", ":=", "false", "\n", "var", "version", "uint8", "\n", "if", "s", "==", "nil", "{", "return", "immutable", ",", "version", ",", "fields", "\n", "}", "\n\n", "for", "_", ",", "f", ":=", "range", "s", ".", "Fields", ".", "List", "{", "var", "typeName", "string", "\n", "switch", "t", ":=", "f", ".", "Type", ".", "(", "type", ")", "{", "case", "*", "ast", ".", "Ident", ":", "typeName", "=", "t", ".", "Name", "\n", "case", "*", "ast", ".", "StarExpr", ":", "if", "i", ",", "ok", ":=", "t", ".", "X", ".", "(", "*", "ast", ".", "Ident", ")", ";", "ok", "{", "typeName", "=", "i", ".", "Name", "\n", "}", "\n", "}", "\n", "if", "len", "(", "f", ".", "Names", ")", "==", "0", "{", "switch", "typeName", "{", "case", "\"", "\"", ":", "immutable", "=", "true", "\n", "case", "\"", "\"", ":", "version", "=", "1", "\n", "case", "\"", "\"", ":", "version", "=", "2", "\n", "}", "\n", "embedded", ":=", "pp", ".", "structmap", "[", "typeName", "]", "\n", "embImmutable", ",", "embVersion", ",", "embeddedFields", ":=", "pp", ".", "gatherFields", "(", "reachable", ",", "embedded", ",", "visible", "||", "immutable", ")", "\n", "immutable", "=", "immutable", "||", "embImmutable", "\n", "visible", "=", "visible", "||", "immutable", "\n", "if", "version", "==", "0", "{", "version", "=", "embVersion", "\n", "}", "\n", "fields", "=", "append", "(", "fields", ",", "embeddedFields", "...", ")", "\n", "continue", "\n", "}", "\n\n", "// This isn't an embedded struct, but it might be our own struct", "// that is now reachable. we need to create a MarshalJSON func for", "// it if so.", "if", "_", ",", "ok", ":=", "pp", ".", "structmap", "[", "typeName", "]", ";", "ok", "{", "pp", ".", "visitStruct", "(", "reachable", ",", "typeName", ",", "visible", ")", "\n", "}", "\n\n", "for", "_", ",", "n", ":=", "range", "f", ".", "Names", "{", "name", ":=", "n", ".", "Name", "\n", "if", "f", ".", "Tag", "!=", "nil", "{", "tname", ":=", "parseJSONTag", "(", "f", ".", "Tag", ".", "Value", ")", "\n", "if", "tname", "!=", "\"", "\"", "{", "name", "=", "tname", "\n", "}", "\n", "}", "\n", "fields", "=", "append", "(", "fields", ",", "field", "{", "Name", ":", "name", ",", "Field", ":", "n", ".", "Name", ",", "}", ")", "\n", "}", "\n", "}", "\n\n", "return", "immutable", ",", "version", ",", "fields", "\n", "}" ]

[ "gatherFields", "is", "used", "by", "visitStruct", "to", "gather", "the", "fields", "for", "a", "struct", ".", "embedded", "struct", "fields", "are", "hoisted", "up", "to", "the", "enclosing", "struct", "for", "JSON", "representation", ".", "referenced", "structs", "will", "in", "turn", "be", "visited", ".", "gatherFields", "transfers", "visibility", "from", "immutable", "structs", "or", "any", "already", "known", "visible", "structs", "to", "structs", "that", "they", "reference", ".", "visibility", "determines", "if", "we", "should", "create", "a", "MarshalJSON", "func", "for", "the", "struct", "." ]

[ "func", "(", "pp", "*", "primitiveParser", ")", "loadTypeComments", "(", ")", "{", "pp", ".", "typedecls", "=", "make", "(", "map", "[", "int", "]", "string", ")", "\n", "for", "_", ",", "c", ":=", "range", "pp", ".", "p", ".", "Comments", "{", "cmt", ":=", "strings", ".", "Trim", "(", "c", ".", "List", "[", "0", "]", ".", "Text", ",", "\"", "\\t", "\"", ")", "\n", "parts", ":=", "strings", ".", "Split", "(", "cmt", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "==", "2", "&&", "parts", "[", "0", "]", "==", "\"", "\"", "{", "pp", ".", "typedecls", "[", "pp", ".", "fset", ".", "Position", "(", "c", ".", "List", "[", "0", "]", ".", "Pos", "(", ")", ")", ".", "Line", "]", "=", "parts", "[", "1", "]", "\n", "}", "\n", "}", "\n", "}" ]

[ "loadTypeComments", "loads", "our", "annotation", "comments", "on", "structs", "indicating", "their", "enumerated", "byte", "type", "allowing", "us", "to", "look", "it", "up", "later", "by", "line", "." ]

[ "func", "(", "pp", "*", "primitiveParser", ")", "loadStructs", "(", ")", "{", "pp", ".", "structmap", "=", "make", "(", "map", "[", "string", "]", "*", "ast", ".", "StructType", ")", "\n\n", "for", "k", ",", "o", ":=", "range", "pp", ".", "p", ".", "Scope", ".", "Objects", "{", "// We only care about types", "if", "o", ".", "Kind", "!=", "ast", ".", "Typ", "{", "continue", "\n", "}", "\n", "ts", ",", "ok", ":=", "o", ".", "Decl", ".", "(", "*", "ast", ".", "TypeSpec", ")", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n\n", "// and to be more exact, only struct types", "s", ",", "ok", ":=", "ts", ".", "Type", ".", "(", "*", "ast", ".", "StructType", ")", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n\n", "// Empty struct? We don't need to generate and json for it. skip.", "if", "len", "(", "s", ".", "Fields", ".", "List", ")", "==", "0", "{", "continue", "\n", "}", "\n\n", "pp", ".", "structmap", "[", "k", "]", "=", "s", "\n", "}", "\n", "}" ]

[ "loadStructs", "creates", "a", "map", "of", "name", "to", "ast", "node", "for", "struct", "types", "from", "the", "parsed", "file", "filtering", "out", "other", "types", "." ]

[ "func", "parseJSONTag", "(", "tag", "string", ")", "string", "{", "if", "len", "(", "tag", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n\n", "if", "tag", "[", ":", "7", "]", "!=", "\"", "\\\"", "\"", "{", "return", "\"", "\"", "\n", "}", "\n\n", "parts", ":=", "strings", ".", "Split", "(", "tag", "[", "7", ":", "len", "(", "tag", ")", "-", "2", "]", ",", "\"", "\"", ")", "\n\n", "return", "parts", "[", "0", "]", "\n", "}" ]

[ "parseJSONTag", "parses", "the", "given", "JSON", "struct", "field", "tag", "to", "get", "its", "name", ".", "omitting", "fields", "via", "tags", "is", "not", "supported", "." ]

[ "func", "writeTemplate", "(", "fileName", "string", ",", "tmpl", "*", "template", ".", "Template", ",", "data", "interface", "{", "}", ")", "{", "buf", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "err", ":=", "tmpl", ".", "Execute", "(", "buf", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "formatted", ",", "err", ":=", "format", ".", "Source", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "fd", ",", "err", ":=", "os", ".", "Create", "(", "fileName", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "defer", "fd", ".", "Close", "(", ")", "\n\n", "fd", ".", "Write", "(", "formatted", ")", "\n", "}" ]

[ "writeTemplate", "writes", "the", "given", "template", "to", "the", "given", "file", "with", "the", "given", "data", ".", "Templates", "are", "assumed", "to", "be", "generating", "go", "source", "files", "so", "they", "are", "formatted", "as", "well", "." ]

[ "func", "(", "c", "*", "CredentialValue", ")", "String", "(", ")", "string", "{", "if", "c", ".", "cvtype", "==", "unsetCV", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "c", ".", "cvtype", "==", "undecryptedCV", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "c", ".", "value", "\n", "}" ]

[ "String", "returns", "the", "string", "representation", "of", "this", "credential", ".", "It", "panics", "if", "the", "credential", "was", "deleted", "." ]

[ "func", "(", "c", "*", "CredentialValue", ")", "Raw", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "c", ".", "IsUnset", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "c", ".", "raw", ",", "nil", "\n", "}" ]

[ "Raw", "returns", "the", "underlying", "typed", "value", "for", "this", "Credential", "." ]

[ "func", "NewStringCredentialValue", "(", "s", "string", ")", "*", "CredentialValue", "{", "return", "&", "CredentialValue", "{", "cvtype", ":", "stringCV", ",", "value", ":", "s", ",", "raw", ":", "s", ",", "}", "\n", "}" ]

[ "NewStringCredentialValue", "creates", "a", "CredentialValue", "with", "a", "string", "value", "." ]

[ "func", "NewIntCredentialValue", "(", "i", "int", ")", "*", "CredentialValue", "{", "return", "&", "CredentialValue", "{", "cvtype", ":", "intCV", ",", "value", ":", "strconv", ".", "Itoa", "(", "i", ")", ",", "raw", ":", "i", ",", "}", "\n", "}" ]

[ "NewIntCredentialValue", "creates", "a", "CredentialValue", "with", "an", "int", "value", "." ]

[ "func", "NewFloatCredentialValue", "(", "f", "float64", ")", "*", "CredentialValue", "{", "return", "&", "CredentialValue", "{", "cvtype", ":", "floatCV", ",", "value", ":", "strconv", ".", "FormatFloat", "(", "f", ",", "'g'", ",", "-", "1", ",", "64", ")", ",", "raw", ":", "f", ",", "}", "\n", "}" ]

[ "NewFloatCredentialValue", "creates", "a", "CredentialValue", "with", "a", "float", "value", "." ]

[ "func", "(", "s", "*", "ServicesClient", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "orgID", ",", "projectID", "*", "identity", ".", "ID", ",", "name", "string", ")", "error", "{", "if", "orgID", "==", "nil", "||", "projectID", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "serviceBody", ":=", "primitive", ".", "Service", "{", "Name", ":", "name", ",", "OrgID", ":", "orgID", ",", "ProjectID", ":", "projectID", ",", "}", "\n\n", "ID", ",", "err", ":=", "identity", ".", "NewMutable", "(", "&", "serviceBody", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "service", ":=", "envelope", ".", "Service", "{", "ID", ":", "&", "ID", ",", "Version", ":", "1", ",", "Body", ":", "&", "serviceBody", ",", "}", "\n\n", "return", "s", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "service", ",", "nil", ")", "\n", "}" ]

[ "Create", "performs", "a", "request", "to", "create", "a", "new", "service", "object" ]

[ "func", "(", "ct", "*", "ClaimTree", ")", "Find", "(", "id", "*", "identity", ".", "ID", ",", "mustActive", "bool", ")", "(", "*", "apitypes", ".", "PublicKeySegment", ",", "error", ")", "{", "for", "_", ",", "pks", ":=", "range", "ct", ".", "PublicKeys", "{", "if", "*", "pks", ".", "PublicKey", ".", "ID", "==", "*", "id", "{", "if", "mustActive", "&&", "pks", ".", "Revoked", "(", ")", "{", "continue", "\n", "}", "\n\n", "return", "&", "pks", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "ErrKeyNotFound", "\n", "}" ]

[ "Find", "returns", "the", "PublicKeySegment", "for", "the", "given", "PublicKeyID", ".", "Accepts", "a", "boolean", "for", "indicating", "whether", "or", "not", "to", "enforce", "that", "the", "key", "must", "be", "active", ".", "If", "a", "key", "segment", "could", "not", "be", "found", "an", "error", "is", "returned", "." ]

[ "func", "(", "ct", "*", "ClaimTree", ")", "FindActive", "(", "ownerID", "*", "identity", ".", "ID", ",", "t", "primitive", ".", "KeyType", ")", "(", "*", "apitypes", ".", "PublicKeySegment", ",", "error", ")", "{", "for", "_", ",", "pks", ":=", "range", "ct", ".", "PublicKeys", "{", "if", "*", "pks", ".", "PublicKey", ".", "Body", ".", "OwnerID", "!=", "*", "ownerID", "{", "continue", "\n", "}", "\n\n", "if", "pks", ".", "PublicKey", ".", "Body", ".", "KeyType", "!=", "t", "{", "continue", "\n", "}", "\n\n", "if", "pks", ".", "Revoked", "(", ")", "{", "continue", "\n", "}", "\n\n", "return", "&", "pks", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "ErrMissingKeyForOwner", "\n", "}" ]

[ "FindActive", "returns", "the", "PublicKeySegment", "for", "a", "non", "-", "revoked", "Public", "Key", "for", "the", "given", "owner", "id", ".", "If", "an", "active", "key", "cannot", "be", "found", "an", "error", "is", "returned" ]

[ "func", "(", "c", "*", "ClaimTreeClient", ")", "List", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ",", "ownerID", "*", "identity", ".", "ID", ")", "(", "[", "]", "ClaimTree", ",", "error", ")", "{", "query", ":=", "&", "url", ".", "Values", "{", "}", "\n", "if", "orgID", "!=", "nil", "{", "query", ".", "Set", "(", "\"", "\"", ",", "orgID", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "if", "ownerID", "!=", "nil", "{", "query", ".", "Set", "(", "\"", "\"", ",", "ownerID", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "var", "resp", "[", "]", "ClaimTree", "\n", "err", ":=", "c", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "query", ",", "nil", ",", "&", "resp", ")", "\n", "return", "resp", ",", "err", "\n", "}" ]

[ "List", "returns", "a", "list", "of", "all", "claimtrees", "for", "a", "given", "orgID", ".", "If", "no", "orgID", "is", "provided", "then", "it", "returns", "all", "claimtrees", "for", "every", "organization", "the", "user", "belongs", "too", ".", "If", "an", "ownerID", "is", "provided", "then", "only", "public", "keys", "and", "claims", "related", "to", "that", "user", "or", "machine", "will", "be", "returned", "." ]

[ "func", "(", "c", "*", "ClaimTreeClient", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ",", "ownerID", "*", "identity", ".", "ID", ")", "(", "*", "ClaimTree", ",", "error", ")", "{", "if", "orgID", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cts", ",", "err", ":=", "c", ".", "List", "(", "ctx", ",", "orgID", ",", "ownerID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "cts", ")", "!=", "1", "{", "return", "nil", ",", "ErrClaimTreeNotFound", "\n", "}", "\n\n", "return", "&", "cts", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "Get", "returns", "a", "claimtree", "for", "a", "specific", "organization", "by", "the", "given", "orgID", ".", "If", "an", "ownerID", "is", "provided", "then", "only", "public", "keys", "and", "claims", "related", "to", "that", "user", "or", "machine", "will", "be", "returned", "." ]

[ "func", "Password", "(", "confirm", "bool", ",", "override", "*", "string", ")", "(", "string", ",", "error", ")", "{", "preferences", ",", "err", ":=", "prefs", ".", "NewPreferences", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "label", ":=", "\"", "\"", "\n", "if", "override", "!=", "nil", "{", "label", "=", "*", "override", "\n", "}", "\n\n", "if", "!", "ui", ".", "Attached", "(", ")", "{", "return", "\"", "\"", ",", "errs", ".", "ErrTerminalRequired", "\n", "}", "\n\n", "prompt", ":=", "&", "promptui", ".", "Prompt", "{", "Label", ":", "label", ",", "Mask", ":", "pwMask", ",", "Validate", ":", "promptui", ".", "ValidateFunc", "(", "validate", ".", "Password", ")", ",", "IsVimMode", ":", "preferences", ".", "Core", ".", "Vim", ",", "}", "\n\n", "password", ",", "err", ":=", "prompt", ".", "Run", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "!", "confirm", "{", "return", "password", ",", "err", "\n", "}", "\n\n", "prompt", "=", "&", "promptui", ".", "Prompt", "{", "Label", ":", "\"", "\"", "+", "label", ",", "Mask", ":", "pwMask", ",", "Validate", ":", "promptui", ".", "ValidateFunc", "(", "validate", ".", "ConfirmPassword", "(", "password", ")", ")", ",", "IsVimMode", ":", "preferences", ".", "Core", ".", "Vim", ",", "}", "\n\n", "_", ",", "err", "=", "prompt", ".", "Run", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "convertErr", "(", "err", ")", "\n", "}", "\n\n", "return", "password", ",", "nil", "\n", "}" ]

[ "Password", "prompts", "the", "user", "to", "provide", "a", "password", ".", "The", "value", "provided", "by", "the", "user", "is", "masked", ".", "If", "confirm", "is", "true", "the", "user", "will", "be", "prompted", "to", "supply", "the", "password", "again", "." ]

[ "func", "(", "u", "*", "UsersClient", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "signup", "*", "apitypes", ".", "Signup", ",", "output", "*", "ProgressFunc", ")", "(", "envelope", ".", "UserInf", ",", "error", ")", "{", "e", ":=", "envelope", ".", "Unsigned", "{", "}", "\n", "err", ":=", "u", ".", "client", ".", "DaemonRoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "&", "signup", ",", "&", "e", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "envelope", ".", "ConvertUser", "(", "&", "e", ")", "\n", "}" ]

[ "Create", "will", "have", "the", "daemon", "create", "a", "new", "user", "request" ]

[ "func", "(", "u", "*", "UsersClient", ")", "Update", "(", "ctx", "context", ".", "Context", ",", "delta", "apitypes", ".", "ProfileUpdate", ")", "(", "envelope", ".", "UserInf", ",", "error", ")", "{", "e", ":=", "envelope", ".", "Unsigned", "{", "}", "\n", "err", ":=", "u", ".", "client", ".", "DaemonRoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "&", "delta", ",", "&", "e", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "envelope", ".", "ConvertUser", "(", "&", "e", ")", "\n", "}" ]

[ "Update", "performs", "a", "profile", "update", "to", "the", "user", "object" ]

[ "func", "(", "u", "*", "UsersClient", ")", "Verify", "(", "ctx", "context", ".", "Context", ",", "code", "string", ")", "error", "{", "verifyEmail", ":=", "apitypes", ".", "VerifyEmail", "{", "Code", ":", "code", ",", "}", "\n\n", "return", "u", ".", "client", ".", "DaemonRoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "&", "verifyEmail", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "Verify", "verifies", "the", "users", "account", "using", "the", "given", "code" ]

[ "func", "Load", "(", "recurse", "bool", ")", "(", "*", "DirPreferences", ",", "error", ")", "{", "path", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "prefs", ":=", "&", "DirPreferences", "{", "}", "\n\n", "var", "f", "*", "os", ".", "File", "\n", "for", "{", "f", ",", "err", "=", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "path", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "isSystemRoot", "(", "path", ")", "||", "!", "recurse", "{", "return", "prefs", ",", "nil", "\n", "}", "\n\n", "path", "=", "filepath", ".", "Dir", "(", "path", ")", "\n", "continue", "\n", "}", "\n\n", "break", "\n", "}", "\n\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "dec", ":=", "json", ".", "NewDecoder", "(", "f", ")", "\n", "err", "=", "dec", ".", "Decode", "(", "prefs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "prefs", ".", "Path", "=", "f", ".", "Name", "(", ")", "\n", "return", "prefs", ",", "nil", "\n", "}" ]

[ "Load", "loads", "DirPreferences", ".", "It", "starts", "in", "the", "current", "working", "directory", "looking", "for", "a", "readable", ".", "torus", ".", "json", "file", "and", "walks", "up", "the", "directory", "hierarchy", "until", "it", "finds", "one", "or", "reaches", "the", "root", "of", "the", "fs", ".", "It", "returns", "an", "empty", "DirPreferences", "is", "no", ".", "torus", ".", "json", "files", "are", "found", ".", "It", "returns", "an", "error", "if", "a", "malformed", "file", "is", "found", "or", "if", "any", "errors", "occur", "during", "file", "system", "access", "." ]

[ "func", "(", "d", "*", "DirPreferences", ")", "Save", "(", ")", "error", "{", "f", ",", "err", ":=", "os", ".", "Create", "(", "d", ".", "Path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "enc", ":=", "json", ".", "NewEncoder", "(", "f", ")", "\n", "return", "enc", ".", "Encode", "(", "d", ")", "\n", "}" ]

[ "Save", "writes", "the", "DirPreferences", "values", "to", "the", "file", "in", "the", "struct", "s", "Path", "field" ]

[ "func", "isSystemRoot", "(", "path", "string", ")", "bool", "{", "if", "len", "(", "path", ")", "!=", "rootPathLength", "{", "return", "false", "\n", "}", "\n\n", "return", "os", ".", "PathSeparator", "==", "path", "[", "rootPathLength", "-", "1", "]", "\n", "}" ]

[ "isSystemRoot", "validates", "if", "the", "given", "path", "is", "the", "root", "of", "the", "system", "for", "the", "OS", "the", "application", "is", "running", "on", "." ]

[ "func", "ToError", "(", "err", "error", ")", "error", "{", "switch", "e", ":=", "err", ".", "(", "type", ")", "{", "case", "*", "cli", ".", "ExitError", ":", "return", "e", "\n", "case", "nil", ":", "return", "nil", "\n", "default", ":", "return", "cli", ".", "NewExitError", "(", "err", ".", "Error", "(", ")", ",", "-", "1", ")", "\n", "}", "\n", "}" ]

[ "ToError", "converts", "the", "given", "error", "into", "a", "cli", ".", "ExitError" ]

[ "func", "NewUsageExitError", "(", "message", "string", ",", "ctx", "*", "cli", ".", "Context", ")", "error", "{", "if", "wordRegex", ".", "MatchString", "(", "message", "[", "len", "(", "message", ")", "-", "1", ":", "]", ")", "{", "message", "+=", "\"", "\"", "\n", "}", "\n", "return", "cli", ".", "NewExitError", "(", "message", "+", "\"", "\\n", "\"", "+", "usageString", "(", "ctx", ")", ",", "-", "1", ")", "\n", "}" ]

[ "NewUsageExitError", "creates", "an", "ExitError", "with", "appended", "usage", "text" ]

[ "func", "NewErrorExitError", "(", "message", "string", ",", "err", "error", ")", "error", "{", "if", "wordRegex", ".", "MatchString", "(", "message", "[", "len", "(", "message", ")", "-", "1", ":", "]", ")", "{", "message", "+=", "\"", "\"", "\n", "}", "\n", "return", "cli", ".", "NewExitError", "(", "message", "+", "\"", "\\n", "\"", "+", "err", ".", "Error", "(", ")", ",", "-", "1", ")", "\n", "}" ]

[ "NewErrorExitError", "creates", "an", "ExitError", "with", "an", "appended", "error", "message" ]

[ "func", "NewExitError", "(", "message", "string", ")", "error", "{", "if", "wordRegex", ".", "MatchString", "(", "message", "[", "len", "(", "message", ")", "-", "1", ":", "]", ")", "{", "message", "+=", "\"", "\"", "\n", "}", "\n", "return", "cli", ".", "NewExitError", "(", "message", ",", "-", "1", ")", "\n", "}" ]

[ "NewExitError", "creates", "an", "ExitError", "with", "-", "1" ]

[ "func", "MultiError", "(", "errors", "...", "error", ")", "cli", ".", "MultiError", "{", "nonNilErrs", ":=", "[", "]", "error", "{", "}", "\n", "for", "_", ",", "e", ":=", "range", "errors", "{", "if", "e", "!=", "nil", "{", "nonNilErrs", "=", "append", "(", "nonNilErrs", ",", "e", ")", "\n", "}", "\n", "}", "\n\n", "return", "cli", ".", "NewMultiError", "(", "nonNilErrs", "...", ")", "\n", "}" ]

[ "MultiError", "loops", "over", "all", "given", "errors", "unpacks", "them", "and", "then", "creates", "a", "new", "MultiError", "for", "non", "-", "nil", "entries", "." ]

[ "func", "(", "v", "*", "VersionClient", ")", "GetDaemon", "(", "ctx", "context", ".", "Context", ")", "(", "*", "apitypes", ".", "Version", ",", "error", ")", "{", "version", ":=", "&", "apitypes", ".", "Version", "{", "}", "\n", "err", ":=", "v", ".", "client", ".", "DaemonRoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", "version", ",", "nil", ")", "\n", "return", "version", ",", "err", "\n", "}" ]

[ "GetDaemon", "returns", "the", "daemon", "s", "release", "version", "." ]

[ "func", "NewGatekeeper", "(", "org", ",", "team", ",", "certpath", ",", "keypath", "string", ",", "cfg", "*", "config", ".", "Config", ",", "api", "*", "api", ".", "Client", ")", "(", "*", "Gatekeeper", ",", "error", ")", "{", "server", ":=", "&", "http", ".", "Server", "{", "Addr", ":", "cfg", ".", "GatekeeperAddress", ",", "}", "\n\n", "keypair", ",", "err", ":=", "tlsKeypair", "(", "certpath", ",", "keypath", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "tlsConfig", ":=", "&", "tls", ".", "Config", "{", "MinVersion", ":", "tls", ".", "VersionTLS12", ",", "Certificates", ":", "[", "]", "tls", ".", "Certificate", "{", "*", "keypair", "}", ",", "}", "\n\n", "server", ".", "TLSConfig", "=", "tlsConfig", "\n", "}", "\n\n", "g", ":=", "&", "Gatekeeper", "{", "defaults", ":", "gatekeeperDefaults", "{", "Org", ":", "org", ",", "Team", ":", "team", ",", "}", ",", "s", ":", "server", ",", "c", ":", "cfg", ",", "api", ":", "api", ",", "}", "\n\n", "return", "g", ",", "nil", "\n", "}" ]

[ "NewGatekeeper", "returns", "a", "new", "Gatekeeper", "." ]

[ "func", "(", "g", "*", "Gatekeeper", ")", "Listen", "(", ")", "error", "{", "mux", ":=", "bone", ".", "New", "(", ")", "\n\n", "mux", ".", "Post", "(", "\"", "\"", ",", "routes", ".", "AWSBootstrapRoute", "(", "g", ".", "defaults", ".", "Org", ",", "g", ".", "defaults", ".", "Team", ",", "g", ".", "api", ")", ")", "\n\n", "g", ".", "s", ".", "Handler", "=", "loggingHandler", "(", "mux", ")", "\n", "h", ":=", "httpdown", ".", "HTTP", "{", "}", "\n\n", "var", "err", "error", "\n", "g", ".", "hd", ",", "err", "=", "h", ".", "ListenAndServe", "(", "g", ".", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "g", ".", "hd", ".", "Wait", "(", ")", "\n", "}" ]

[ "Listen", "listens", "on", "a", "TCP", "port", "for", "HTTP", "machine", "requests" ]

[ "func", "startGatekeeperCmd", "(", "ctx", "*", "cli", ".", "Context", ")", "error", "{", "log", ".", "SetOutput", "(", "os", ".", "Stdout", ")", "\n\n", "cfg", ",", "err", ":=", "config", ".", "LoadConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errs", ".", "NewErrorExitError", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "gatekeeper", ",", "err", ":=", "gatekeeper", ".", "New", "(", "ctx", ".", "String", "(", "\"", "\"", ")", ",", "ctx", ".", "String", "(", "\"", "\"", ")", ",", "ctx", ".", "String", "(", "\"", "\"", ")", ",", "ctx", ".", "String", "(", "\"", "\"", ")", ",", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "log", ".", "Printf", "(", "\"", "\"", ",", "cfg", ".", "Version", ",", "gatekeeper", ".", "Addr", "(", ")", ")", "\n", "err", "=", "gatekeeper", ".", "Listen", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "startGatekeeper", "starts", "the", "machine", "Gatekeeper" ]

[ "func", "(", "o", "*", "OrgsClient", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "*", "envelope", ".", "Org", ",", "error", ")", "{", "org", ":=", "orgCreateRequest", "{", "}", "\n", "org", ".", "Body", ".", "Name", "=", "name", "\n\n", "res", ":=", "envelope", ".", "Org", "{", "}", "\n", "err", ":=", "o", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "&", "org", ",", "&", "res", ")", "\n", "return", "&", "res", ",", "err", "\n", "}" ]

[ "Create", "creates", "a", "new", "org", "with", "the", "given", "name", ".", "It", "returns", "the", "newly", "-", "created", "org", "." ]

[ "func", "(", "o", "*", "OrgsClient", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "orgID", "*", "identity", ".", "ID", ")", "(", "*", "envelope", ".", "Org", ",", "error", ")", "{", "org", ":=", "envelope", ".", "Org", "{", "}", "\n", "err", ":=", "o", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", "+", "orgID", ".", "String", "(", ")", ",", "nil", ",", "nil", ",", "&", "org", ")", "\n", "return", "&", "org", ",", "err", "\n", "}" ]

[ "Get", "returns", "the", "organization", "with", "the", "given", "ID", "." ]

[ "func", "(", "o", "*", "OrgsClient", ")", "List", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "envelope", ".", "Org", ",", "error", ")", "{", "var", "orgs", "[", "]", "envelope", ".", "Org", "\n", "err", ":=", "o", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ",", "&", "orgs", ")", "\n", "return", "orgs", ",", "err", "\n", "}" ]

[ "List", "returns", "all", "organizations", "that", "the", "signed", "-", "in", "user", "has", "access", "to" ]

[ "func", "(", "o", "*", "OrgsClient", ")", "RemoveMember", "(", "ctx", "context", ".", "Context", ",", "orgID", "identity", ".", "ID", ",", "userID", "identity", ".", "ID", ")", "error", "{", "path", ":=", "\"", "\"", "+", "orgID", ".", "String", "(", ")", "+", "\"", "\"", "+", "userID", ".", "String", "(", ")", "\n", "return", "o", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "path", ",", "nil", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "RemoveMember", "removes", "a", "user", "from", "an", "org" ]

[ "func", "(", "o", "*", "OrgsClient", ")", "GetTree", "(", "ctx", "context", ".", "Context", ",", "orgID", "identity", ".", "ID", ")", "(", "[", "]", "OrgTreeSegment", ",", "error", ")", "{", "v", ":=", "&", "url", ".", "Values", "{", "}", "\n", "v", ".", "Set", "(", "\"", "\"", ",", "orgID", ".", "String", "(", ")", ")", "\n\n", "var", "segments", "[", "]", "OrgTreeSegment", "\n", "err", ":=", "o", ".", "client", ".", "RoundTrip", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "v", ",", "nil", ",", "&", "segments", ")", "\n", "return", "segments", ",", "err", "\n", "}" ]

[ "GetTree", "returns", "an", "org", "tree" ]

[ "func", "(", "m", "*", "Machine", ")", "CreateToken", "(", "ctx", "context", ".", "Context", ",", "notifier", "*", "observer", ".", "Notifier", ",", "machine", "*", "envelope", ".", "Machine", ",", "secret", "*", "base64", ".", "Value", ")", "(", "*", "registry", ".", "MachineTokenCreationSegment", ",", "error", ")", "{", "n", ":=", "notifier", ".", "Notifier", "(", "2", ")", "\n\n", "n", ".", "Notify", "(", "observer", ".", "Progress", ",", "\"", "\"", ",", "true", ")", "\n", "salt", ",", "err", ":=", "crypto", ".", "GenerateSalt", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "keypair", ",", "err", ":=", "crypto", ".", "DeriveLoginKeypair", "(", "ctx", ",", "*", "secret", ",", "salt", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "orgID", ":=", "machine", ".", "Body", ".", "OrgID", "\n\n", "masterKey", ",", "err", ":=", "crypto", ".", "CreateMasterKeyObject", "(", "ctx", ",", "*", "secret", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "tokenBody", ":=", "&", "primitive", ".", "MachineToken", "{", "OrgID", ":", "orgID", ",", "MachineID", ":", "machine", ".", "ID", ",", "PublicKey", ":", "&", "primitive", ".", "LoginPublicKey", "{", "Salt", ":", "keypair", ".", "Salt", "(", ")", ",", "Value", ":", "keypair", ".", "PublicKey", "(", ")", ",", "Alg", ":", "crypto", ".", "EdDSA", ",", "}", ",", "Master", ":", "masterKey", ",", "CreatedBy", ":", "m", ".", "engine", ".", "session", ".", "ID", "(", ")", ",", "Created", ":", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ",", "DestroyedBy", ":", "nil", ",", "Destroyed", ":", "nil", ",", "State", ":", "primitive", ".", "MachineTokenActiveState", ",", "}", "\n", "tokenID", ",", "err", ":=", "identity", ".", "NewMutable", "(", "tokenBody", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "token", ":=", "&", "envelope", ".", "MachineToken", "{", "ID", ":", "&", "tokenID", ",", "Version", ":", "1", ",", "Body", ":", "tokenBody", ",", "}", "\n\n", "// Create an \"empty\" machine session in order to create a Crypto engine on", "// behalf of the machine for deriving and uploading these keys.", "sess", ":=", "session", ".", "NewSession", "(", "m", ".", "engine", ".", "guard", ")", "\n", "err", "=", "sess", ".", "Set", "(", "apitypes", ".", "MachineSession", ",", "machine", ",", "token", ",", "*", "secret", ",", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ":=", "crypto", ".", "NewEngine", "(", "sess", ",", "m", ".", "engine", ".", "guard", ")", "\n\n", "n", ".", "Notify", "(", "observer", ".", "Progress", ",", "\"", "\"", ",", "true", ")", "\n", "kp", ",", "err", ":=", "c", ".", "GenerateKeyPairs", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "authID", ":=", "sess", ".", "AuthID", "(", ")", "\n", "keypairs", ",", "err", ":=", "generateKeypairs", "(", "ctx", ",", "c", ",", "orgID", ",", "authID", ",", "kp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "registry", ".", "MachineTokenCreationSegment", "{", "Token", ":", "token", ",", "Keypairs", ":", "keypairs", ",", "}", ",", "nil", "\n", "}" ]

[ "CreateToken", "generates", "a", "new", "machine", "token", "given", "a", "machine", "and", "a", "secret", "value", "." ]

[ "func", "(", "m", "*", "Machine", ")", "EncodeToken", "(", "ctx", "context", ".", "Context", ",", "notifier", "*", "observer", ".", "Notifier", ",", "token", "*", "envelope", ".", "MachineToken", ")", "error", "{", "n", ":=", "notifier", ".", "Notifier", "(", "2", ")", "\n\n", "n", ".", "Notify", "(", "observer", ".", "Progress", ",", "\"", "\"", ",", "true", ")", "\n\n", "v1members", ",", "v2members", ",", "err", ":=", "createKeyringMemberships", "(", "ctx", ",", "m", ".", "engine", ".", "crypto", ",", "m", ".", "engine", ".", "client", ",", "m", ".", "engine", ".", "session", ",", "token", ".", "Body", ".", "OrgID", ",", "token", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "n", ".", "Notify", "(", "observer", ".", "Progress", ",", "\"", "\"", ",", "true", ")", "\n\n", "if", "len", "(", "v1members", ")", "!=", "0", "{", "_", ",", "err", "=", "m", ".", "engine", ".", "client", ".", "KeyringMember", ".", "Post", "(", "ctx", ",", "v1members", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "member", ":=", "range", "v2members", "{", "err", "=", "m", ".", "engine", ".", "client", ".", "Keyring", ".", "Members", ".", "Post", "(", "ctx", ",", "member", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "EncodeToken", "creates", "KeyringMemberships", "for", "the", "provided", "Machine", "Token", ".", "Used", "during", "the", "machine", "creation", "process" ]

[ "func", "(", "cgs", "*", "credentialGraphSet", ")", "Active", "(", ")", "(", "[", "]", "registry", ".", "CredentialGraph", ",", "error", ")", "{", "active", ":=", "make", "(", "[", "]", "registry", ".", "CredentialGraph", ",", "0", ",", "len", "(", "cgs", ".", "graphs", ")", ")", "\n\n", "for", "_", ",", "graphs", ":=", "range", "cgs", ".", "graphs", "{", "// parents is the slice of IDs already seen in Previous fields.", "// they cannot be active as they have been overwritten.", "var", "parents", "[", "]", "identity", ".", "ID", "\n\n", "sort", ".", "Sort", "(", "graphSorter", "(", "graphs", ")", ")", "\n", "for", "headOffset", ",", "graph", ":=", "range", "graphs", "{", "var", "activeCreds", "[", "]", "envelope", ".", "CredentialInf", "\n", "var", "err", "error", "\n", "activeCreds", ",", "parents", ",", "err", "=", "cgs", ".", "activeCreds", "(", "parents", ",", "graph", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// the most recent version of a keyring is always active", "// (it could be filled entirely with unset values)", "if", "len", "(", "activeCreds", ")", ">", "0", "||", "headOffset", "==", "0", "{", "active", "=", "append", "(", "active", ",", "graph", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "active", ",", "nil", "\n", "}" ]

[ "Active", "returns", "a", "slice", "of", "CredentialGraphs", "that", "contain", "credentials", "that", "are", "still", "reachable", ".", "A", "credential", "is", "reachable", "if", "a", "newer", "version", "of", "the", "CredentialGraph", "has", "not", "replaced", "its", "value", "and", "it", "is", "not", "an", "unset", "Credential", "." ]

[ "func", "(", "cgs", "*", "credentialGraphSet", ")", "NeedRotation", "(", ")", "(", "[", "]", "RotationReason", ",", "error", ")", "{", "var", "needRotation", "[", "]", "RotationReason", "\n\n", "typ", ":=", "(", "&", "primitive", ".", "User", "{", "}", ")", ".", "Type", "(", ")", "\n", "for", "_", ",", "graphs", ":=", "range", "cgs", ".", "graphs", "{", "var", "parents", "[", "]", "identity", ".", "ID", "\n\n", "sort", ".", "Sort", "(", "graphSorter", "(", "graphs", ")", ")", "\n", "for", "_", ",", "graph", ":=", "range", "graphs", "{", "var", "activeCreds", "[", "]", "envelope", ".", "CredentialInf", "\n", "var", "err", "error", "\n", "activeCreds", ",", "parents", ",", "err", "=", "cgs", ".", "activeCreds", "(", "parents", ",", "graph", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "reasons", "[", "]", "primitive", ".", "KeyringMemberClaim", "\n", "for", "_", ",", "c", ":=", "range", "graph", ".", "GetClaims", "(", ")", "{", "if", "c", ".", "Body", ".", "ClaimType", "==", "primitive", ".", "RevocationClaimType", "{", "// Ignore machines", "if", "c", ".", "Body", ".", "OwnerID", ".", "Type", "(", ")", "==", "typ", "{", "reasons", "=", "append", "(", "reasons", ",", "*", "c", ".", "Body", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "reasons", ")", ">", "0", "{", "for", "_", ",", "c", ":=", "range", "activeCreds", "{", "needRotation", "=", "append", "(", "needRotation", ",", "RotationReason", "{", "Credential", ":", "c", ",", "Reasons", ":", "reasons", ",", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "needRotation", ",", "nil", "\n", "}" ]

[ "NeedRotation", "returns", "a", "slice", "of", "Credentials", "that", "need", "to", "be", "rotated", ".", "A", "Credential", "needs", "to", "be", "rotated", "if", "its", "most", "recent", "set", "version", "is", "in", "a", "CredentialGraph", "version", "that", "contains", "a", "revocation", "of", "a", "user", "s", "share", "to", "that", "Keyring", "." ]

[ "func", "(", "cgs", "*", "credentialGraphSet", ")", "Head", "(", "pe", "*", "pathexp", ".", "PathExp", ")", "(", "registry", ".", "CredentialGraph", ",", "error", ")", "{", "gpe", ",", "err", ":=", "pe", ".", "WithInstance", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "graphs", ",", "ok", ":=", "cgs", ".", "graphs", "[", "gpe", ".", "String", "(", ")", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "sort", ".", "Sort", "(", "graphSorter", "(", "graphs", ")", ")", "\n", "return", "graphs", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "Head", "returns", "the", "most", "recent", "version", "of", "a", "CredentialGraph", "that", "would", "contain", "the", "given", "PathExp", "." ]

[ "func", "(", "cgs", "*", "credentialGraphSet", ")", "HeadCredential", "(", "pe", "*", "pathexp", ".", "PathExp", ",", "name", "string", ")", "(", "envelope", ".", "CredentialInf", ",", "error", ")", "{", "var", "head", "envelope", ".", "CredentialInf", "\n", "version", ":=", "-", "1", "\n\n", "gpe", ",", "err", ":=", "pe", ".", "WithInstance", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "graphs", ",", "ok", ":=", "cgs", ".", "graphs", "[", "gpe", ".", "String", "(", ")", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "sort", ".", "Sort", "(", "graphSorter", "(", "graphs", ")", ")", "\n", "for", "_", ",", "graph", ":=", "range", "graphs", "{", "creds", ":=", "graph", ".", "GetCredentials", "(", ")", "\n", "for", "_", ",", "cred", ":=", "range", "creds", "{", "if", "cred", ".", "PathExp", "(", ")", ".", "Equal", "(", "pe", ")", "&&", "cred", ".", "Name", "(", ")", "==", "name", "&&", "cred", ".", "CredentialVersion", "(", ")", ">", "version", "{", "env", ":=", "cred", "\n", "head", "=", "env", "\n", "version", "=", "cred", ".", "CredentialVersion", "(", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "head", ",", "nil", "\n", "}" ]

[ "HeadCredential", "returns", "the", "most", "recent", "version", "of", "a", "Credential", "that", "shares", "the", "provided", "PathExp", "and", "Name", "A", "Head", "Credential", "need", "not", "be", "in", "the", "Head", "of", "the", "CredentialGraph", "." ]

[ "func", "(", "rt", "*", "apiRoundTripper", ")", "NewDaemonRequest", "(", "method", ",", "path", "string", ",", "query", "*", "url", ".", "Values", ",", "body", "interface", "{", "}", ")", "(", "*", "http", ".", "Request", ",", "string", ",", "error", ")", "{", "return", "rt", ".", "newRequest", "(", "method", ",", "daemonAPIVersion", ",", "path", ",", "query", ",", "body", ")", "\n", "}" ]

[ "NewDaemonRequest", "constructs", "a", "new", "http", ".", "Request", "with", "a", "body", "containing", "the", "json", "representation", "of", "body", "if", "provided", ".", "Daemon", "requests", "are", "handled", "directly", "by", "the", "torus", "daemon", "." ]

[ "func", "(", "rt", "*", "apiRoundTripper", ")", "newRequest", "(", "method", ",", "prefix", ",", "path", "string", ",", "query", "*", "url", ".", "Values", ",", "body", "interface", "{", "}", ")", "(", "*", "http", ".", "Request", ",", "string", ",", "error", ")", "{", "requestID", ":=", "uuid", ".", "NewV4", "(", ")", ".", "String", "(", ")", "\n\n", "prefixed", ":=", "\"", "\"", "+", "prefix", "+", "path", "\n", "req", ",", "err", ":=", "rt", ".", "DefaultRequestDoer", ".", "NewRequest", "(", "method", ",", "prefixed", ",", "query", ",", "body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "requestID", ",", "err", "\n", "}", "\n\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "requestID", ")", "\n\n", "return", "req", ",", "requestID", ",", "nil", "\n", "}" ]

[ "newRequest", "augments", "the", "default", "to", "set", "a", "unique", "request", "id" ]

[ "func", "(", "rt", "*", "apiRoundTripper", ")", "DoWithProgress", "(", "ctx", "context", ".", "Context", ",", "r", "*", "http", ".", "Request", ",", "v", "interface", "{", "}", ",", "reqID", "string", ",", "progress", "ProgressFunc", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "done", ":=", "make", "(", "chan", "bool", ")", "\n", "req", ",", "_", ",", "err", ":=", "rt", ".", "newRequest", "(", "\"", "\"", ",", "daemonAPIVersion", ",", "\"", "\"", ",", "nil", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "stream", ",", "err", ":=", "eventsource", ".", "SubscribeWith", "(", "\"", "\"", ",", "rt", ".", "Client", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "<-", "done", ":", "return", "\n", "case", "ev", ":=", "<-", "stream", ".", "Events", ":", "data", ":=", "ev", ".", "Data", "(", ")", "\n", "raw", ":=", "[", "]", "byte", "(", "data", ")", "\n\n", "event", ":=", "Event", "{", "}", "\n", "event", ".", "MessageType", "=", "\"", "\"", "\n", "err", "=", "json", ".", "Unmarshal", "(", "raw", ",", "&", "event", ")", "\n", "if", "err", "!=", "nil", "{", "progress", "(", "nil", ",", "err", ")", "\n", "go", "func", "(", ")", "{", "<-", "done", "\n", "}", "(", ")", "\n", "return", "\n", "}", "\n", "if", "event", ".", "ID", "==", "reqID", "{", "progress", "(", "&", "event", ",", "nil", ")", "\n", "}", "\n", "case", "err", ":=", "<-", "stream", ".", "Errors", ":", "progress", "(", "nil", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "defer", "func", "(", ")", "{", "done", "<-", "true", "}", "(", ")", "\n\n", "return", "rt", ".", "Do", "(", "ctx", ",", "r", ",", "v", ")", "\n", "}" ]

[ "DoWithProgress", "executes", "the", "HTTP", "request", "like", "Do", "in", "addition", "to", "connecting", "the", "provided", "ProgressFunc", "to", "any", "server", "-", "sent", "event", "progress", "messages", "." ]

[ "func", "NewEngine", "(", "cfg", "*", "config", ".", "Config", ",", "t", "*", "http", ".", "Transport", ",", "options", "...", "func", "(", "*", "Engine", ")", ")", "*", "Engine", "{", "engine", ":=", "&", "Engine", "{", "config", ":", "cfg", ",", "stop", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "targetVersion", ":", "\"", "\"", ",", "client", ":", "&", "http", ".", "Client", "{", "Transport", ":", "t", "}", ",", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "options", "{", "opt", "(", "engine", ")", "\n", "}", "\n\n", "if", "engine", ".", "timeManager", "==", "nil", "{", "engine", ".", "timeManager", "=", "defaultTimeManager", "{", "}", "\n", "}", "\n\n", "return", "engine", "\n", "}" ]

[ "NewEngine", "creates", "a", "new", "Engine", "based", "on", "the", "provided", "config", "structure", ".", "It", "can", "be", "extended", "by", "passing", "specific", "options", "which", "alter", "the", "initialization", "of", "the", "Engine", "itself", "." ]

[ "func", "(", "e", "*", "Engine", ")", "SetTimeManager", "(", "manager", "TimeManager", ")", "func", "(", "*", "Engine", ")", "{", "return", "func", "(", "engine", "*", "Engine", ")", "{", "engine", ".", "timeManager", "=", "manager", "\n", "}", "\n", "}" ]

[ "SetTimeManager", "is", "a", "configuration", "function", "for", "NewEngine", "which", "sets", "the", "Engine", "s", "TimeManager", "instance", "to", "the", "manager", "argument", "." ]