Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13k

[ "func", "NewTeamLoaderAndInstall", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "*", "TeamLoader", "{", "world", ":=", "NewLoaderContextFromG", "(", "g", ")", "\n", "st", ":=", "NewStorage", "(", "g", ")", "\n", "l", ":=", "NewTeamLoader", "(", "g", ",", "world", ",", "st", ")", "\n", "g", ".", "SetTeamLoader", "(", "l", ")", "\n", "g", ".", "AddLogoutHook", "(", "l", ",", "\"", "\"", ")", "\n", "g", ".", "AddDbNukeHook", "(", "l", ",", "\"", "\"", ")", "\n", "return", "l", "\n", "}" ]

[ "NewTeamLoaderAndInstall", "creates", "a", "new", "loader", "and", "installs", "it", "into", "G", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "ResolveNameToIDUntrusted", "(", "ctx", "context", ".", "Context", ",", "teamName", "keybase1", ".", "TeamName", ",", "public", "bool", ",", "allowCache", "bool", ")", "(", "id", "keybase1", ".", "TeamID", ",", "err", "error", ")", "{", "defer", "l", ".", "G", "(", ")", ".", "CVTrace", "(", "ctx", ",", "libkb", ".", "VLog0", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "teamName", ".", "String", "(", ")", ",", "public", ",", "allowCache", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// For root team names, just hash.", "if", "teamName", ".", "IsRootTeam", "(", ")", "{", "return", "teamName", ".", "ToTeamID", "(", "public", ")", ",", "nil", "\n", "}", "\n\n", "if", "!", "allowCache", "{", "return", "resolveNameToIDUntrustedAPICall", "(", "ctx", ",", "l", ".", "G", "(", ")", ",", "teamName", ",", "public", ")", "\n", "}", "\n\n", "var", "idVoidPointer", "interface", "{", "}", "\n", "key", ":=", "nameLookupBurstCacheKey", "{", "teamName", ",", "public", "}", "\n", "idVoidPointer", ",", "err", "=", "l", ".", "nameLookupBurstCache", ".", "Load", "(", "ctx", ",", "key", ",", "l", ".", "makeNameLookupBurstCacheLoader", "(", "ctx", ",", "l", ".", "G", "(", ")", ",", "key", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "TeamID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n", "if", "idPointer", ",", "ok", ":=", "idVoidPointer", ".", "(", "*", "keybase1", ".", "TeamID", ")", ";", "ok", "&&", "idPointer", "!=", "nil", "{", "id", "=", "*", "idPointer", "\n", "}", "else", "{", "return", "keybase1", ".", "TeamID", "(", "\"", "\"", ")", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "id", ",", "nil", "\n", "}" ]

[ "Resolve", "a", "team", "name", "to", "a", "team", "ID", ".", "Will", "always", "hit", "the", "server", "for", "subteams", ".", "The", "server", "can", "lie", "in", "this", "return", "value", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "load2", "(", "ctx", "context", ".", "Context", ",", "arg", "load2ArgT", ")", "(", "ret", "*", "load2ResT", ",", "err", "error", ")", "{", "ctx", "=", "libkb", ".", "WithLogTag", "(", "ctx", ",", "\"", "\"", ")", "// Load team", "\n", "if", "arg", ".", "reason", "!=", "\"", "\"", "{", "ctx", "=", "libkb", ".", "WithLogTag", "(", "ctx", ",", "\"", "\"", ")", "// Load team recursive", "\n", "}", "\n", "traceLabel", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "arg", ".", "teamID", ",", "arg", ".", "public", ")", "\n", "if", "len", "(", "arg", ".", "reason", ")", ">", "0", "{", "traceLabel", "=", "traceLabel", "+", "\"", "\"", "+", "arg", ".", "reason", "+", "\"", "\"", "\n", "}", "\n\n", "defer", "l", ".", "G", "(", ")", ".", "CTraceTimed", "(", "ctx", ",", "traceLabel", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "ret", ",", "err", "=", "l", ".", "load2Inner", "(", "ctx", ",", "arg", ")", "\n", "return", "ret", ",", "err", "\n", "}" ]

[ "Load2", "does", "the", "rest", "of", "the", "work", "loading", "a", "team", ".", "It", "is", "playchain", "described", "in", "the", "pseudocode", "in", "teamplayer", ".", "txt" ]

[ "func", "(", "l", "*", "TeamLoader", ")", "userPreload", "(", "ctx", "context", ".", "Context", ",", "links", "[", "]", "*", "ChainLinkUnpacked", ",", "fullVerifyCutoff", "keybase1", ".", "Seqno", ")", "(", "cancel", "func", "(", ")", ")", "{", "ctx", ",", "cancel", "=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "if", "teamEnv", ".", "UserPreloadEnable", "{", "uidSet", ":=", "make", "(", "map", "[", "keybase1", ".", "UID", "]", "struct", "{", "}", ")", "\n", "for", "_", ",", "link", ":=", "range", "links", "{", "// fullVerify definition copied from verifyLink", "fullVerify", ":=", "(", "link", ".", "LinkType", "(", ")", "!=", "libkb", ".", "SigchainV2TypeTeamLeave", ")", "||", "(", "link", ".", "Seqno", "(", ")", ">=", "fullVerifyCutoff", ")", "||", "(", "link", ".", "source", ".", "EldestSeqno", "==", "0", ")", "\n", "if", "!", "link", ".", "isStubbed", "(", ")", "&&", "fullVerify", "{", "uidSet", "[", "link", ".", "inner", ".", "Body", ".", "Key", ".", "UID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "l", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "uidSet", ")", ")", "\n", "if", "teamEnv", ".", "UserPreloadParallel", "{", "// Note this is full-parallel. Probably want pipelining if this is to be turned on by default.", "var", "wg", "sync", ".", "WaitGroup", "\n", "for", "uid", ":=", "range", "uidSet", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "uid", "keybase1", ".", "UID", ")", "{", "_", ",", "_", ",", "err", ":=", "l", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ".", "LoadV2", "(", "libkb", ".", "NewLoadUserArg", "(", "l", ".", "G", "(", ")", ")", ".", "WithUID", "(", "uid", ")", ".", "WithPublicKeyOptional", "(", ")", ".", "WithNetContext", "(", "ctx", ")", ")", "\n", "if", "err", "!=", "nil", "{", "l", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "uid", ")", "\n", "}", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", "uid", ")", "\n", "}", "\n", "if", "teamEnv", ".", "UserPreloadWait", "{", "wg", ".", "Wait", "(", ")", "\n", "}", "\n", "}", "else", "{", "for", "uid", ":=", "range", "uidSet", "{", "_", ",", "_", ",", "err", ":=", "l", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ".", "LoadV2", "(", "libkb", ".", "NewLoadUserArg", "(", "l", ".", "G", "(", ")", ")", ".", "WithUID", "(", "uid", ")", ".", "WithPublicKeyOptional", "(", ")", ".", "WithNetContext", "(", "ctx", ")", ")", "\n", "if", "err", "!=", "nil", "{", "l", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "uid", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "cancel", "\n", "}" ]

[ "userPreload", "warms", "the", "upak", "cache", "with", "users", "who", "will", "probably", "need", "to", "be", "loaded", "to", "verify", "the", "chain", ".", "Uses", "teamEnv", "and", "may", "be", "disabled", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "satisfiesNeedAdmin", "(", "ctx", "context", ".", "Context", ",", "me", "keybase1", ".", "UserVersion", ",", "teamData", "*", "keybase1", ".", "TeamData", ")", "bool", "{", "if", "teamData", "==", "nil", "{", "return", "false", "\n", "}", "\n", "if", "(", "TeamSigChainState", "{", "inner", ":", "teamData", ".", "Chain", "}", ".", "HasAnyStubbedLinks", "(", ")", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "l", ".", "hasSyncedSecrets", "(", "teamData", ")", "{", "return", "false", "\n", "}", "\n", "state", ":=", "TeamSigChainState", "{", "inner", ":", "teamData", ".", "Chain", "}", "\n", "role", ",", "err", ":=", "state", ".", "GetUserRole", "(", "me", ")", "\n", "if", "err", "!=", "nil", "{", "l", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "if", "!", "role", ".", "IsAdminOrAbove", "(", ")", "{", "if", "!", "state", ".", "IsSubteam", "(", ")", "{", "return", "false", "\n", "}", "\n", "yes", ",", "err", ":=", "l", ".", "isImplicitAdminOf", "(", "ctx", ",", "state", ".", "GetID", "(", ")", ",", "state", ".", "GetParentID", "(", ")", ",", "me", ",", "me", ")", "\n", "if", "err", "!=", "nil", "{", "l", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "if", "!", "yes", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Whether", "the", "user", "is", "an", "admin", "at", "the", "snapshot", "and", "there", "are", "no", "stubbed", "links", "and", "keys", "are", "up", "to", "date", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "isImplicitAdminOf", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "ancestorID", "*", "keybase1", ".", "TeamID", ",", "me", "keybase1", ".", "UserVersion", ",", "uv", "keybase1", ".", "UserVersion", ")", "(", "bool", ",", "error", ")", "{", "// IDs of ancestors that were not freshly polled.", "// Check them again with forceRepoll if the affirmative is not found cached.", "checkAgain", ":=", "make", "(", "map", "[", "keybase1", ".", "TeamID", "]", "bool", ")", "\n\n", "check1", ":=", "func", "(", "chain", "*", "TeamSigChainState", ")", "bool", "{", "role", ",", "err", ":=", "chain", ".", "GetUserRole", "(", "uv", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "role", ".", "IsAdminOrAbove", "(", ")", "\n", "}", "\n\n", "i", ":=", "0", "\n", "for", "{", "i", "++", "\n", "if", "i", ">=", "100", "{", "// Break in case there's a bug in this loop.", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ancestorID", ")", "\n", "}", "\n\n", "// Use load2 so that we can use subteam-reader and get secretless teams.", "ancestor", ",", "err", ":=", "l", ".", "load2", "(", "ctx", ",", "load2ArgT", "{", "teamID", ":", "*", "ancestorID", ",", "reason", ":", "\"", "\"", ",", "me", ":", "me", ",", "readSubteamID", ":", "&", "teamID", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "// Be wary, `ancestor` could be, and is likely, a secretless team.", "// Do not let it out of sight.", "ancestorChain", ":=", "TeamSigChainState", "{", "inner", ":", "ancestor", ".", "team", ".", "Chain", "}", "\n\n", "if", "!", "ancestor", ".", "didRepoll", "{", "checkAgain", "[", "ancestorChain", ".", "GetID", "(", ")", "]", "=", "true", "\n", "}", "\n\n", "if", "check1", "(", "&", "ancestorChain", ")", "{", "return", "true", ",", "nil", "\n", "}", "\n\n", "if", "!", "ancestorChain", ".", "IsSubteam", "(", ")", "{", "break", "\n", "}", "\n", "// Get the next level up.", "ancestorID", "=", "ancestorChain", ".", "GetParentID", "(", ")", "\n", "}", "\n\n", "// The answer was not found to be yes in the cache.", "// Try again with the teams that were not polled as they might have unseen updates.", "for", "ancestorID", ":=", "range", "checkAgain", "{", "ancestor", ",", "err", ":=", "l", ".", "load2", "(", "ctx", ",", "load2ArgT", "{", "teamID", ":", "ancestorID", ",", "reason", ":", "\"", "\"", ",", "me", ":", "me", ",", "forceRepoll", ":", "true", ",", "// Get the latest info.", "readSubteamID", ":", "&", "teamID", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "// Be wary, `ancestor` could be, and is likely, a secretless team.", "// Do not let it out of sight.", "ancestorChain", ":=", "TeamSigChainState", "{", "inner", ":", "ancestor", ".", "team", ".", "Chain", "}", "\n", "if", "check1", "(", "&", "ancestorChain", ")", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "Check", "whether", "a", "user", "is", "an", "implicit", "admin", "of", "a", "team", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "satisfiesNeedKeyGeneration", "(", "ctx", "context", ".", "Context", ",", "needKeyGeneration", "keybase1", ".", "PerTeamKeyGeneration", ",", "state", "*", "keybase1", ".", "TeamData", ")", "error", "{", "if", "needKeyGeneration", "==", "0", "{", "return", "nil", "\n", "}", "\n", "if", "state", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "needKeyGeneration", ")", "\n", "}", "\n", "key", ",", "err", ":=", "TeamSigChainState", "{", "inner", ":", "state", ".", "Chain", "}", ".", "GetLatestPerTeamKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "needKeyGeneration", ">", "key", ".", "Gen", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ".", "Gen", ",", "needKeyGeneration", ")", "\n", "}", "\n", "_", ",", "ok", ":=", "state", ".", "PerTeamKeySeedsUnverified", "[", "needKeyGeneration", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "needKeyGeneration", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Whether", "the", "snapshot", "has", "loaded", "at", "least", "up", "to", "the", "key", "generation", "and", "has", "the", "secret", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "satisfiesNeedApplicationsAtGenerations", "(", "ctx", "context", ".", "Context", ",", "needApplicationsAtGenerations", "map", "[", "keybase1", ".", "PerTeamKeyGeneration", "]", "[", "]", "keybase1", ".", "TeamApplication", ",", "state", "*", "keybase1", ".", "TeamData", ")", "error", "{", "if", "len", "(", "needApplicationsAtGenerations", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "if", "state", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "needApplicationsAtGenerations", ")", "\n", "}", "\n", "for", "ptkGen", ",", "apps", ":=", "range", "needApplicationsAtGenerations", "{", "for", "_", ",", "app", ":=", "range", "apps", "{", "if", "_", ",", "err", ":=", "ApplicationKeyAtGeneration", "(", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "l", ".", "G", "(", ")", ")", ",", "state", ",", "app", ",", "ptkGen", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Whether", "the", "snapshot", "has", "loaded", "the", "reader", "key", "masks", "and", "key", "generations", "we", "need", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "satisfiesWantMembers", "(", "ctx", "context", ".", "Context", ",", "wantMembers", "[", "]", "keybase1", ".", "UserVersion", ",", "wantMembersRole", "keybase1", ".", "TeamRole", ",", "state", "*", "keybase1", ".", "TeamData", ")", "error", "{", "if", "wantMembersRole", "==", "keybase1", ".", "TeamRole_NONE", "{", "// Default to writer.", "wantMembersRole", "=", "keybase1", ".", "TeamRole_WRITER", "\n", "}", "\n", "if", "len", "(", "wantMembers", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "if", "state", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "uv", ":=", "range", "wantMembers", "{", "role", ",", "err", ":=", "TeamSigChainState", "{", "inner", ":", "state", ".", "Chain", "}", ".", "GetUserRole", "(", "uv", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "!", "role", ".", "IsOrAbove", "(", "wantMembersRole", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uv", ",", "role", ",", "wantMembersRole", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Whether", "the", "snapshot", "has", "each", "of", "wantMembers", "as", "a", "member", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "seqnosContains", "(", "xs", "[", "]", "keybase1", ".", "Seqno", ",", "y", "keybase1", ".", "Seqno", ")", "bool", "{", "for", "_", ",", "x", ":=", "range", "xs", "{", "if", "x", ".", "Eq", "(", "y", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Whether", "y", "is", "in", "xs", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "seqnosMax", "(", "seqnos", "[", "]", "keybase1", ".", "Seqno", ")", "(", "ret", "keybase1", ".", "Seqno", ")", "{", "for", "_", ",", "x", ":=", "range", "seqnos", "{", "if", "x", ">", "ret", "{", "ret", "=", "x", "\n", "}", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Return", "the", "max", "in", "a", "list", "of", "positive", "seqnos", ".", "Returns", "0", "if", "the", "list", "is", "empty" ]

[ "func", "(", "l", "*", "TeamLoader", ")", "isFresh", "(", "ctx", "context", ".", "Context", ",", "cachedAt", "keybase1", ".", "Time", ")", "bool", "{", "if", "cachedAt", ".", "IsZero", "(", ")", "{", "// This should never happen.", "l", ".", "G", "(", ")", ".", "Log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "false", "\n", "}", "\n", "diff", ":=", "l", ".", "G", "(", ")", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "Sub", "(", "cachedAt", ".", "Time", "(", ")", ")", "\n", "fresh", ":=", "(", "diff", "<=", "freshnessLimit", ")", "\n", "if", "!", "fresh", "{", "l", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "diff", ")", "\n", "}", "\n", "return", "fresh", "\n", "}" ]

[ "Whether", "a", "TeamData", "from", "the", "cache", "is", "fresh", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "hasSyncedSecrets", "(", "state", "*", "keybase1", ".", "TeamData", ")", "bool", "{", "onChainGen", ":=", "keybase1", ".", "PerTeamKeyGeneration", "(", "len", "(", "state", ".", "Chain", ".", "PerTeamKeys", ")", ")", "\n", "offChainGen", ":=", "keybase1", ".", "PerTeamKeyGeneration", "(", "len", "(", "state", ".", "PerTeamKeySeedsUnverified", ")", ")", "\n", "return", "onChainGen", "==", "offChainGen", "\n", "}" ]

[ "Whether", "the", "teams", "secrets", "are", "synced", "to", "the", "same", "point", "as", "its", "sigchain", "Does", "not", "check", "RKMs", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "ImplicitAdmins", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ")", "(", "impAdmins", "[", "]", "keybase1", ".", "UserVersion", ",", "err", "error", ")", "{", "impAdminsMap", ":=", "make", "(", "map", "[", "string", "]", "keybase1", ".", "UserVersion", ")", "// map to remove dups", "\n", "err", "=", "l", ".", "MapTeamAncestors", "(", "ctx", ",", "func", "(", "t", "keybase1", ".", "TeamSigChainState", ")", "error", "{", "ancestorChain", ":=", "TeamSigChainState", "{", "inner", ":", "t", "}", "\n", "// Gather the admins.", "adminRoles", ":=", "[", "]", "keybase1", ".", "TeamRole", "{", "keybase1", ".", "TeamRole_OWNER", ",", "keybase1", ".", "TeamRole_ADMIN", "}", "\n", "for", "_", ",", "role", ":=", "range", "adminRoles", "{", "uvs", ",", "err", ":=", "ancestorChain", ".", "GetUsersWithRole", "(", "role", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "uv", ":=", "range", "uvs", "{", "impAdminsMap", "[", "uv", ".", "String", "(", ")", "]", "=", "uv", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ",", "teamID", ",", "\"", "\"", ",", "func", "(", "keybase1", ".", "TeamSigChainState", ")", "bool", "{", "return", "true", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "uv", ":=", "range", "impAdminsMap", "{", "impAdmins", "=", "append", "(", "impAdmins", ",", "uv", ")", "\n", "}", "\n", "return", "impAdmins", ",", "nil", "\n", "}" ]

[ "List", "all", "the", "admins", "of", "ancestor", "teams", ".", "Includes", "admins", "of", "the", "specified", "team", "only", "if", "they", "are", "also", "admins", "of", "ancestor", "teams", ".", "The", "specified", "team", "must", "be", "a", "subteam", "or", "an", "error", "is", "returned", ".", "Always", "sends", "a", "flurry", "of", "RPCs", "to", "get", "the", "most", "up", "to", "date", "info", "." ]

[ "func", "(", "l", "*", "TeamLoader", ")", "MapTeamAncestors", "(", "ctx", "context", ".", "Context", ",", "f", "func", "(", "t", "keybase1", ".", "TeamSigChainState", ")", "error", ",", "teamID", "keybase1", ".", "TeamID", ",", "reason", "string", ",", "forceFullReloadOnceToAssert", "func", "(", "t", "keybase1", ".", "TeamSigChainState", ")", "bool", ")", "(", "err", "error", ")", "{", "me", ",", "err", ":=", "l", ".", "world", ".", "getMe", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Load the argument team", "team", ",", "err", ":=", "l", ".", "load1", "(", "ctx", ",", "me", ",", "keybase1", ".", "LoadTeamArg", "{", "ID", ":", "teamID", ",", "Public", ":", "teamID", ".", "IsPublic", "(", ")", ",", "StaleOK", ":", "true", ",", "// We only use immutable fields.", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "teamChain", ":=", "TeamSigChainState", "{", "inner", ":", "team", ".", "Chain", "}", "\n", "if", "!", "teamChain", ".", "IsSubteam", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "teamID", ")", "\n", "}", "\n", "return", "l", ".", "mapTeamAncestorsHelper", "(", "ctx", ",", "f", ",", "teamID", ",", "teamChain", ".", "GetParentID", "(", ")", ",", "reason", ",", "forceFullReloadOnceToAssert", ")", "\n", "}" ]

[ "MapTeamAncestors", "does", "NOT", "map", "over", "the", "team", "itself", "." ]

[ "func", "(", "c", "*", "CtlHandler", ")", "Stop", "(", "ctx", "context", ".", "Context", ",", "args", "keybase1", ".", "StopArg", ")", "error", "{", "c", ".", "G", "(", ")", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "install", ".", "StopAllButService", "(", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "c", ".", "G", "(", ")", ")", ",", "args", ".", "ExitCode", ")", "\n", "c", ".", "G", "(", ")", ".", "Log", ".", "Info", "(", "\"", "\"", ")", "\n", "c", ".", "service", ".", "Stop", "(", "args", ".", "ExitCode", ")", "\n", "return", "nil", "\n", "}" ]

[ "Stop", "is", "called", "on", "the", "rpc", "keybase", ".", "1", ".", "ctl", ".", "stop", "which", "shuts", "down", "the", "service", "." ]

[ "func", "isReadableOrError", "(", "ctx", "context", ".", "Context", ",", "kbpki", "KBPKI", ",", "syncGetter", "syncedTlfGetterSetter", ",", "md", "ReadOnlyRootMetadata", ")", "error", "{", "if", "!", "md", ".", "IsInitialized", "(", ")", "||", "md", ".", "IsReadable", "(", ")", "{", "return", "nil", "\n", "}", "\n", "// this should only be the case if we're a new device not yet", "// added to the set of reader/writer keys.", "session", ",", "err", ":=", "kbpki", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "errors", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "TlfID", "(", ")", ",", "session", ".", "Name", ",", "session", ".", "UID", ")", "\n", "return", "makeRekeyReadError", "(", "ctx", ",", "err", ",", "kbpki", ",", "syncGetter", ",", "md", ",", "session", ".", "UID", ",", "session", ".", "Name", ")", "\n", "}" ]

[ "Helper", "which", "returns", "nil", "if", "the", "md", "block", "is", "uninitialized", "or", "readable", "by", "the", "current", "user", ".", "Otherwise", "an", "appropriate", "read", "access", "error", "is", "returned", "." ]

[ "func", "getSingleMD", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ",", "rev", "kbfsmd", ".", "Revision", ",", "mStatus", "kbfsmd", ".", "MergeStatus", ",", "lockBeforeGet", "*", "keybase1", ".", "LockID", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "rmds", ",", "err", ":=", "getMDRange", "(", "ctx", ",", "config", ",", "id", ",", "bid", ",", "rev", ",", "rev", ",", "mStatus", ",", "lockBeforeGet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "rmds", ")", "!=", "1", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rev", ")", "\n", "}", "\n", "return", "rmds", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "getSingleMD", "returns", "an", "MD", "that", "is", "required", "to", "exist", "." ]

[ "func", "MakeCopyWithDecryptedPrivateData", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ",", "irmdToDecrypt", ",", "irmdWithKeys", "ImmutableRootMetadata", ",", "uid", "keybase1", ".", "UID", ")", "(", "rmdDecrypted", "ImmutableRootMetadata", ",", "err", "error", ")", "{", "pmd", ",", "err", ":=", "decryptMDPrivateData", "(", "ctx", ",", "config", ".", "Codec", "(", ")", ",", "config", ".", "Crypto", "(", ")", ",", "config", ".", "BlockCache", "(", ")", ",", "config", ".", "BlockOps", "(", ")", ",", "config", ".", "KeyManager", "(", ")", ",", "config", ".", "KBPKI", "(", ")", ",", "config", ",", "config", ".", "Mode", "(", ")", ",", "uid", ",", "irmdToDecrypt", ".", "GetSerializedPrivateMetadata", "(", ")", ",", "irmdToDecrypt", ",", "irmdWithKeys", ",", "config", ".", "MakeLogger", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "rmdCopy", ",", "err", ":=", "irmdToDecrypt", ".", "deepCopy", "(", "config", ".", "Codec", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n", "rmdCopy", ".", "data", "=", "pmd", "\n", "return", "MakeImmutableRootMetadata", "(", "rmdCopy", ",", "irmdToDecrypt", ".", "LastModifyingWriterVerifyingKey", "(", ")", ",", "irmdToDecrypt", ".", "MdID", "(", ")", ",", "irmdToDecrypt", ".", "LocalTimestamp", "(", ")", ",", "irmdToDecrypt", ".", "putToServer", ")", ",", "nil", "\n", "}" ]

[ "MakeCopyWithDecryptedPrivateData", "makes", "a", "copy", "of", "the", "given", "IRMD", "decrypting", "it", "with", "the", "given", "IRMD", "with", "keys", "." ]

[ "func", "GetMDRevisionByTime", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ",", "handle", "*", "tlfhandle", ".", "Handle", ",", "serverTime", "time", ".", "Time", ")", "(", "kbfsmd", ".", "Revision", ",", "error", ")", "{", "id", ":=", "handle", ".", "TlfID", "(", ")", "\n", "if", "id", "==", "tlf", ".", "NullID", "{", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "handle", ".", "GetCanonicalPath", "(", ")", ")", "\n", "}", "\n\n", "md", ",", "err", ":=", "config", ".", "MDOps", "(", ")", ".", "GetForTLFByTime", "(", "ctx", ",", "id", ",", "serverTime", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "err", "\n", "}", "\n\n", "return", "md", ".", "Revision", "(", ")", ",", "nil", "\n", "}" ]

[ "GetMDRevisionByTime", "returns", "the", "revision", "number", "of", "the", "earliest", "merged", "MD", "of", "handle", "with", "a", "server", "timestamp", "greater", "or", "equal", "to", "serverTime", "." ]

[ "func", "decryptMDPrivateData", "(", "ctx", "context", ".", "Context", ",", "codec", "kbfscodec", ".", "Codec", ",", "crypto", "Crypto", ",", "bcache", "data", ".", "BlockCache", ",", "bops", "BlockOps", ",", "keyGetter", "mdDecryptionKeyGetter", ",", "teamChecker", "kbfsmd", ".", "TeamMembershipChecker", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "mode", "InitMode", ",", "uid", "keybase1", ".", "UID", ",", "serializedPrivateMetadata", "[", "]", "byte", ",", "rmdToDecrypt", ",", "rmdWithKeys", "libkey", ".", "KeyMetadata", ",", "log", "logger", ".", "Logger", ")", "(", "PrivateMetadata", ",", "error", ")", "{", "handle", ":=", "rmdToDecrypt", ".", "GetTlfHandle", "(", ")", "\n\n", "var", "pmd", "PrivateMetadata", "\n", "if", "handle", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "PublicKeying", "{", "if", "err", ":=", "codec", ".", "Decode", "(", "serializedPrivateMetadata", ",", "&", "pmd", ")", ";", "err", "!=", "nil", "{", "return", "PrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n", "}", "else", "{", "// decrypt the root data for non-public directories", "var", "encryptedPrivateMetadata", "kbfscrypto", ".", "EncryptedPrivateMetadata", "\n", "if", "err", ":=", "codec", ".", "Decode", "(", "serializedPrivateMetadata", ",", "&", "encryptedPrivateMetadata", ")", ";", "err", "!=", "nil", "{", "return", "PrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "k", ",", "err", ":=", "keyGetter", ".", "GetTLFCryptKeyForMDDecryption", "(", "ctx", ",", "rmdToDecrypt", ",", "rmdWithKeys", ")", "\n\n", "if", "err", "!=", "nil", "{", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "handle", ".", "GetCanonicalPath", "(", ")", ",", "rmdToDecrypt", ".", "TlfID", "(", ")", ",", "err", ")", "\n", "isReader", ",", "readerErr", ":=", "isReaderFromHandle", "(", "ctx", ",", "handle", ",", "teamChecker", ",", "osg", ",", "uid", ")", "\n", "if", "readerErr", "!=", "nil", "{", "return", "PrivateMetadata", "{", "}", ",", "readerErr", "\n", "}", "\n", "_", ",", "isSelfRekeyError", ":=", "err", ".", "(", "NeedSelfRekeyError", ")", "\n", "_", ",", "isOtherRekeyError", ":=", "err", ".", "(", "NeedOtherRekeyError", ")", "\n", "if", "isReader", "&&", "(", "isOtherRekeyError", "||", "isSelfRekeyError", ")", "{", "// Rekey errors are expected if this client is a", "// valid folder participant but doesn't have the", "// shared crypt key.", "}", "else", "{", "return", "PrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n", "}", "else", "{", "pmd", ",", "err", "=", "crypto", ".", "DecryptPrivateMetadata", "(", "encryptedPrivateMetadata", ",", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Re-embed the block changes if it's needed.", "err", ":=", "reembedBlockChanges", "(", "ctx", ",", "codec", ",", "bcache", ",", "bops", ",", "mode", ",", "rmdWithKeys", ".", "TlfID", "(", ")", ",", "&", "pmd", ",", "rmdWithKeys", ",", "log", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "pmd", ",", "nil", "\n", "}" ]

[ "decryptMDPrivateData", "does", "not", "use", "uid", "if", "the", "handle", "is", "a", "public", "one", "." ]

[ "func", "NewCmdSimpleFS", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "Subcommands", ":", "append", "(", "[", "]", "cli", ".", "Command", "{", "NewCmdSimpleFSList", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSCopy", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSMove", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSSymlink", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSRead", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSRemove", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSMkdir", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSStat", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSGetStatus", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSKill", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSPs", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSWrite", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSDebug", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSSetDebugLevel", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSHistory", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSQuota", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSRecover", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSReset", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSClearConflicts", "(", "cl", ",", "g", ")", ",", "NewCmdSimpleFSSync", "(", "cl", ",", "g", ")", ",", "}", ",", "getBuildSpecificFSCommands", "(", "cl", ",", "g", ")", "...", ")", ",", "}", "\n", "}" ]

[ "NewCmdSimpleFS", "creates", "the", "device", "command", "which", "is", "just", "a", "holder", "for", "subcommands", "." ]

[ "func", "checkPathIsDir", "(", "ctx", "context", ".", "Context", ",", "cli", "keybase1", ".", "SimpleFSInterface", ",", "path", "keybase1", ".", "Path", ")", "(", "bool", ",", "string", ",", "error", ")", "{", "var", "isDir", "bool", "\n", "var", "pathString", "string", "\n", "var", "err", "error", "\n\n", "pathType", ",", "_", ":=", "path", ".", "PathType", "(", ")", "\n", "switch", "pathType", "{", "case", "keybase1", ".", "PathType_KBFS", ",", "keybase1", ".", "PathType_KBFS_ARCHIVED", ":", "if", "pathType", "==", "keybase1", ".", "PathType_KBFS", "{", "pathString", "=", "path", ".", "Kbfs", "(", ")", "\n", "}", "else", "{", "pathString", "=", "path", ".", "KbfsArchived", "(", ")", ".", "Path", "\n", "}", "\n", "// See if the dest is a path or file", "destEnt", ",", "err", ":=", "cli", ".", "SimpleFSStat", "(", "ctx", ",", "keybase1", ".", "SimpleFSStatArg", "{", "Path", ":", "path", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "destEnt", ".", "DirentType", "==", "keybase1", ".", "DirentType_DIR", "{", "isDir", "=", "true", "\n", "}", "\n", "case", "keybase1", ".", "PathType_LOCAL", ":", "pathString", "=", "path", ".", "Local", "(", ")", "\n", "// An error is OK, could be a target filename", "// that does not exist yet", "fileInfo", ",", "err", ":=", "os", ".", "Stat", "(", "pathString", ")", "\n", "if", "err", "==", "nil", "{", "if", "fileInfo", ".", "IsDir", "(", ")", "{", "isDir", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "isDir", ",", "pathString", ",", "err", "\n", "}" ]

[ "Check", "whether", "the", "given", "path", "is", "a", "directory", "and", "return", "its", "string" ]

[ "func", "makeDestPath", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "cli", "keybase1", ".", "SimpleFSInterface", ",", "src", "keybase1", ".", "Path", ",", "dest", "keybase1", ".", "Path", ",", "isDestPath", "bool", ",", "destPathString", "string", ")", "(", "keybase1", ".", "Path", ",", "error", ")", "{", "isSrcDir", ",", "srcPathString", ",", "err", ":=", "checkPathIsDir", "(", "ctx", ",", "cli", ",", "src", ")", "\n", "// TODO: this error should really be checked, but when I added", "// code to check it, tests broke and it wasn't clear how to fix.", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "src", ",", "isSrcDir", ")", "\n\n", "if", "isDestPath", "{", "// Source file and dest dir is an append case", "appendDest", ":=", "!", "isSrcDir", "\n", "if", "isSrcDir", "{", "// Here, we have both source and dest as paths, so", "// we have to check whether dest exists. If so, append.", "err2", ":=", "checkElementExists", "(", "ctx", ",", "cli", ",", "dest", ")", "\n", "if", "err2", "==", "ErrTargetFileExists", "{", "appendDest", "=", "true", "\n", "}", "\n", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "appendDest", ")", "\n", "}", "\n", "if", "appendDest", "{", "destType", ",", "_", ":=", "dest", ".", "PathType", "(", ")", "\n", "// In this case, we must append the destination filename", "dest", "=", "joinSimpleFSPaths", "(", "destType", ",", "destPathString", ",", "srcPathString", ")", "\n", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "dest", ")", "\n", "}", "\n", "}", "\n\n", "err", "=", "checkElementExists", "(", "ctx", ",", "cli", ",", "dest", ")", "\n\n", "return", "dest", ",", "err", "\n", "}" ]

[ "Make", "sure", "the", "destination", "ends", "with", "the", "same", "filename", "as", "the", "source", "if", "any", "unless", "the", "destination", "is", "not", "a", "directory" ]

[ "func", "parseSrcDestArgs", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "ctx", "*", "cli", ".", "Context", ",", "name", "string", ")", "(", "[", "]", "keybase1", ".", "Path", ",", "keybase1", ".", "Path", ",", "error", ")", "{", "nargs", ":=", "len", "(", "ctx", ".", "Args", "(", ")", ")", "\n\n", "var", "srcType", ",", "destType", "keybase1", ".", "PathType", "\n", "var", "srcPaths", "[", "]", "keybase1", ".", "Path", "\n", "var", "destPath", "keybase1", ".", "Path", "\n\n", "if", "nargs", "<", "2", "{", "return", "srcPaths", ",", "destPath", ",", "errors", ".", "New", "(", "name", "+", "\"", "\"", ")", "\n", "}", "\n", "for", "i", ",", "src", ":=", "range", "ctx", ".", "Args", "(", ")", "{", "rev", ":=", "int64", "(", "0", ")", "\n", "timeString", ":=", "\"", "\"", "\n", "relTimeString", ":=", "\"", "\"", "\n", "if", "i", "!=", "nargs", "-", "1", "{", "// All source paths use the same revision.", "rev", "=", "int64", "(", "ctx", ".", "Int", "(", "\"", "\"", ")", ")", "\n", "timeString", "=", "ctx", ".", "String", "(", "\"", "\"", ")", "\n", "relTimeString", "=", "getRelTime", "(", "ctx", ")", "\n", "}", "\n", "argPath", ",", "err", ":=", "makeSimpleFSPathWithArchiveParams", "(", "src", ",", "rev", ",", "timeString", ",", "relTimeString", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "keybase1", ".", "Path", "{", "}", ",", "err", "\n", "}", "\n", "tempPathType", ",", "err", ":=", "argPath", ".", "PathType", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "srcPaths", ",", "destPath", ",", "err", "\n", "}", "\n", "// Make sure all source paths are the same type", "if", "i", "==", "0", "{", "srcType", "=", "tempPathType", "\n", "}", "else", "if", "i", "==", "nargs", "-", "1", "{", "destPath", "=", "argPath", "\n", "destType", "=", "tempPathType", "\n", "break", "\n", "}", "else", "if", "tempPathType", "!=", "srcType", "{", "return", "srcPaths", ",", "destPath", ",", "errors", ".", "New", "(", "name", "+", "\"", "\"", ")", "\n", "}", "\n", "srcPaths", "=", "append", "(", "srcPaths", ",", "argPath", ")", "\n", "}", "\n\n", "if", "srcType", "==", "keybase1", ".", "PathType_LOCAL", "&&", "destType", "==", "keybase1", ".", "PathType_LOCAL", "{", "return", "srcPaths", ",", "destPath", ",", "errors", ".", "New", "(", "name", "+", "\"", "\"", ")", "\n", "}", "\n", "return", "srcPaths", ",", "destPath", ",", "nil", "\n", "}" ]

[ "Make", "a", "list", "of", "source", "paths", "and", "one", "destination", "path", "from", "the", "given", "command", "line", "args" ]

[ "func", "(", "s", "*", "Slot", ")", "Use", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "s", ".", "cancel", ",", "cancel", "=", "cancel", ",", "s", ".", "cancel", "\n", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "cancel", "!=", "nil", "{", "cancel", "(", ")", "\n", "}", "\n", "return", "ctx", "\n", "}" ]

[ "Use", "derives", "a", "context", "bound", "to", "the", "slot", ".", "Cancels", "any", "context", "previously", "bound", "to", "the", "slot", "." ]

[ "func", "(", "s", "*", "PrioritySlot", ")", "Use", "(", "ctx", "context", ".", "Context", ",", "priority", "int", ")", "context", ".", "Context", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "s", ".", "shutdown", "{", "// Not accepting new processes.", "cancel", "(", ")", "\n", "return", "ctx", "\n", "}", "\n", "if", "s", ".", "cancel", "==", "nil", "{", "// First use", "s", ".", "cancel", "=", "cancel", "\n", "s", ".", "priority", "=", "priority", "\n", "return", "ctx", "\n", "}", "\n", "if", "s", ".", "priority", "<=", "priority", "{", "// Argument wins", "s", ".", "cancel", "(", ")", "\n", "s", ".", "cancel", "=", "cancel", "\n", "s", ".", "priority", "=", "priority", "\n", "return", "ctx", "\n", "}", "\n", "// Incumbent wins", "cancel", "(", ")", "\n", "return", "ctx", "\n", "}" ]

[ "Use", "derives", "a", "new", "context", ".", "Whichever", "of", "the", "argument", "and", "the", "incumbent", "are", "lower", "priority", "is", "canceled", ".", "In", "a", "tie", "the", "incumbent", "is", "canceled", "." ]

[ "func", "(", "s", "*", "PrioritySlot", ")", "Shutdown", "(", ")", "{", "s", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "s", ".", "cancel", "!=", "nil", "{", "s", ".", "cancel", "(", ")", "\n", "s", ".", "cancel", "=", "nil", "\n", "s", ".", "priority", "=", "0", "\n", "}", "\n", "s", ".", "shutdown", "=", "true", "\n", "}" ]

[ "Shutdown", "disables", "the", "slot", "forever", "." ]

[ "func", "NewFakeS3Context", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "fakeS3Key", ",", "true", ")", "\n", "}" ]

[ "NewFakeS3Context", "returns", "a", "context", "with", "the", "fakeS3Key", "flag", "set", "." ]

[ "func", "(", "r", "Bundle", ")", "CheckInvariants", "(", ")", "error", "{", "accountIDs", ":=", "make", "(", "map", "[", "AccountID", "]", "bool", ")", "\n", "var", "foundPrimary", "bool", "\n", "for", "_", ",", "entry", ":=", "range", "r", ".", "Accounts", "{", "_", ",", "found", ":=", "accountIDs", "[", "entry", ".", "AccountID", "]", "\n", "if", "found", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "entry", ".", "AccountID", ")", "\n", "}", "\n", "accountIDs", "[", "entry", ".", "AccountID", "]", "=", "true", "\n", "if", "entry", ".", "IsPrimary", "{", "if", "foundPrimary", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "foundPrimary", "=", "true", "\n", "}", "\n", "if", "entry", ".", "Mode", "==", "AccountMode_NONE", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "entry", ".", "AcctBundleRevision", "<", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "entry", ".", "AcctBundleRevision", ",", "entry", ".", "AccountID", ")", "\n", "}", "\n", "}", "\n", "if", "!", "foundPrimary", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "r", ".", "Revision", "<", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ".", "Revision", ")", "\n", "}", "\n", "for", "accID", ",", "accBundle", ":=", "range", "r", ".", "AccountBundles", "{", "if", "accID", "!=", "accBundle", ".", "AccountID", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "accID", ")", "\n", "}", "\n", "var", "AccountBundleInAccounts", "bool", "\n", "for", "_", ",", "accountListAccount", ":=", "range", "r", ".", "Accounts", "{", "if", "accountListAccount", ".", "AccountID", "==", "accID", "{", "AccountBundleInAccounts", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "AccountBundleInAccounts", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "accID", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckInvariants", "checks", "that", "the", "Bundle", "satisfies", "1", ".", "No", "duplicate", "account", "IDs", "2", ".", "Exactly", "one", "primary", "account", "3", ".", "Non", "-", "negative", "revision", "numbers", "4", ".", "Account", "Bundle", "accountIDs", "are", "consistent", "5", ".", "every", "account", "in", "AccountBundles", "is", "also", "in", "Accounts" ]

[ "func", "NewProveCheck", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "sigID", "keybase1", ".", "SigID", ")", "*", "ProveCheck", "{", "return", "&", "ProveCheck", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "sigID", ":", "sigID", ",", "}", "\n", "}" ]

[ "NewProveCheck", "creates", "a", "ProveCheck", "engine", "." ]

[ "func", "(", "r", "*", "ResolverImpl", ")", "putToMemCache", "(", "m", "MetaContext", ",", "key", "string", ",", "res", "ResolveResult", ")", "{", "if", "r", ".", "cache", "==", "nil", "{", "return", "\n", "}", "\n", "// Don't cache errors or deleted users", "if", "res", ".", "err", "!=", "nil", "||", "res", ".", "deleted", "{", "return", "\n", "}", "\n", "if", "!", "res", ".", "HasPrimaryKey", "(", ")", "{", "m", ".", "Warning", "(", "\"", "\"", ")", "\n", "if", "m", ".", "G", "(", ")", ".", "Env", ".", "GetDebug", "(", ")", "{", "debug", ".", "PrintStack", "(", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "res", ".", "cachedAt", "=", "m", ".", "G", "(", ")", ".", "Clock", "(", ")", ".", "Now", "(", ")", "\n", "res", ".", "body", "=", "nil", "// Don't cache body", "\n", "r", ".", "cache", ".", "Set", "(", "key", ",", "&", "res", ")", "\n", "}" ]

[ "Put", "receives", "a", "copy", "of", "a", "ResolveResult", "clears", "out", "the", "body", "to", "avoid", "caching", "data", "that", "can", "go", "stale", "and", "stores", "the", "result", "." ]

[ "func", "NewLoginProvisionedDevice", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "username", "string", ")", "*", "LoginProvisionedDevice", "{", "return", "&", "LoginProvisionedDevice", "{", "username", ":", "libkb", ".", "NewNormalizedUsername", "(", "username", ")", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "newLoginCurrentDevice", "creates", "a", "loginProvisionedDevice", "engine", "." ]

[ "func", "(", "o", "*", "Outbox", ")", "PullAllConversations", "(", "ctx", "context", ".", "Context", ",", "includeErrors", "bool", ",", "remove", "bool", ")", "(", "[", "]", "chat1", ".", "OutboxRecord", ",", "error", ")", "{", "locks", ".", "Outbox", ".", "Lock", "(", ")", "\n", "defer", "locks", ".", "Outbox", ".", "Unlock", "(", ")", "\n\n", "// Read outbox for the user", "obox", ",", "err", ":=", "o", ".", "readStorage", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "res", ",", "errors", "[", "]", "chat1", ".", "OutboxRecord", "\n", "for", "_", ",", "obr", ":=", "range", "obox", ".", "Records", "{", "state", ",", "err", ":=", "obr", ".", "State", ".", "State", "(", ")", "\n", "if", "err", "!=", "nil", "{", "o", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "if", "state", "==", "chat1", ".", "OutboxStateType_ERROR", "{", "if", "includeErrors", "{", "res", "=", "append", "(", "res", ",", "obr", ")", "\n", "}", "else", "{", "errors", "=", "append", "(", "errors", ",", "obr", ")", "\n", "}", "\n", "}", "else", "{", "res", "=", "append", "(", "res", ",", "obr", ")", "\n", "}", "\n", "}", "\n", "if", "remove", "{", "// Write out diskbox", "obox", ".", "Records", "=", "errors", "\n", "obox", ".", "Version", "=", "outboxVersion", "\n", "if", "err", ":=", "o", ".", "writeStorage", "(", "ctx", ",", "obox", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PullAllConversations", "grabs", "all", "outbox", "entries", "for", "the", "current", "outbox", "and", "optionally", "deletes", "them", "from", "storage" ]

[ "func", "(", "o", "*", "Outbox", ")", "MarkAsError", "(", "ctx", "context", ".", "Context", ",", "obr", "chat1", ".", "OutboxRecord", ",", "errRec", "chat1", ".", "OutboxStateError", ")", "(", "res", "chat1", ".", "OutboxRecord", ",", "err", "error", ")", "{", "locks", ".", "Outbox", ".", "Lock", "(", ")", "\n", "defer", "locks", ".", "Outbox", ".", "Unlock", "(", ")", "\n\n", "// Read outbox for the user", "obox", ",", "err", ":=", "o", ".", "readStorage", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// Loop through and find record", "var", "recs", "[", "]", "chat1", ".", "OutboxRecord", "\n", "added", ":=", "false", "\n", "for", "_", ",", "iobr", ":=", "range", "obox", ".", "Records", "{", "if", "iobr", ".", "OutboxID", ".", "Eq", "(", "&", "obr", ".", "OutboxID", ")", "{", "iobr", ".", "State", "=", "chat1", ".", "NewOutboxStateWithError", "(", "errRec", ")", "\n", "added", "=", "true", "\n", "res", "=", "iobr", "\n", "}", "\n", "recs", "=", "append", "(", "recs", ",", "iobr", ")", "\n", "}", "\n", "if", "!", "added", "{", "obr", ".", "State", "=", "chat1", ".", "NewOutboxStateWithError", "(", "errRec", ")", "\n", "res", "=", "obr", "\n", "recs", "=", "append", "(", "recs", ",", "obr", ")", "\n", "sort", ".", "Sort", "(", "ByCtimeOrder", "(", "recs", ")", ")", "\n", "}", "\n\n", "// Write out diskbox", "obox", ".", "Records", "=", "recs", "\n", "if", "err", ":=", "o", ".", "writeStorage", "(", "ctx", ",", "obox", ")", ";", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "MarkAsError", "will", "either", "mark", "an", "existing", "record", "as", "an", "error", "or", "it", "will", "add", "the", "passed", "record", "as", "an", "error", "with", "the", "specified", "error", "state" ]

[ "func", "NewPGPPurge", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "keybase1", ".", "PGPPurgeArg", ")", "*", "PGPPurge", "{", "return", "&", "PGPPurge", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "arg", ":", "arg", ",", "}", "\n", "}" ]

[ "NewPGPPurge", "creates", "a", "PGPPurge", "engine", "." ]

[ "func", "GetEncodedMetrics", "(", "config", "libkbfs", ".", "Config", ")", "func", "(", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "return", "func", "(", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "if", "registry", ":=", "config", ".", "MetricsRegistry", "(", ")", ";", "registry", "!=", "nil", "{", "b", ":=", "bytes", ".", "NewBuffer", "(", "nil", ")", "\n", "metricsutil", ".", "WriteMetrics", "(", "registry", ",", "b", ")", "\n", "return", "b", ".", "Bytes", "(", ")", ",", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", "\n", "return", "[", "]", "byte", "(", "\"", "\\n", "\"", ")", ",", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "GetEncodedMetrics", "returns", "metrics", "encoded", "as", "bytes", "for", "metrics", "file", "." ]

[ "func", "NewDealer", "(", "dh", "DealersHelper", ")", "*", "Dealer", "{", "return", "&", "Dealer", "{", "dh", ":", "dh", ",", "games", ":", "make", "(", "map", "[", "GameKey", "]", "(", "chan", "<-", "*", "GameMessageWrapped", ")", ")", ",", "gameIDs", ":", "make", "(", "map", "[", "GameIDKey", "]", "GameMetadata", ")", ",", "chatInputCh", ":", "make", "(", "chan", "*", "GameMessageWrapped", ")", ",", "gameUpdateCh", ":", "make", "(", "chan", "GameStateUpdateMessage", ",", "500", ")", ",", "previousGames", ":", "make", "(", "map", "[", "GameIDKey", "]", "bool", ")", ",", "}", "\n", "}" ]

[ "NewDealer", "makes", "a", "new", "Dealer", "with", "a", "given", "DealersHelper" ]

[ "func", "(", "d", "*", "Dealer", ")", "Run", "(", "ctx", "context", ".", "Context", ")", "error", "{", "d", ".", "shutdownMu", ".", "Lock", "(", ")", "\n", "shutdownCh", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "d", ".", "shutdownCh", "=", "shutdownCh", "\n", "d", ".", "shutdownMu", ".", "Unlock", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n\n", "// This channel never closes", "case", "msg", ":=", "<-", "d", ".", "chatInputCh", ":", "err", ":=", "d", ".", "handleMessage", "(", "ctx", ",", "msg", ")", "\n", "if", "err", "!=", "nil", "{", "d", ".", "dh", ".", "CLogf", "(", "ctx", ",", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "// exit the loop if we've shutdown", "case", "<-", "shutdownCh", ":", "return", "io", ".", "EOF", "\n\n", "}", "\n", "}", "\n", "}" ]

[ "Run", "a", "dealer", "in", "a", "given", "context", ".", "It", "will", "run", "as", "long", "as", "it", "isn", "t", "shutdown", "." ]

[ "func", "(", "d", "*", "Dealer", ")", "Stop", "(", ")", "{", "d", ".", "shutdownMu", ".", "Lock", "(", ")", "\n", "if", "d", ".", "shutdownCh", "!=", "nil", "{", "close", "(", "d", ".", "shutdownCh", ")", "\n", "d", ".", "shutdownCh", "=", "nil", "\n", "}", "\n", "d", ".", "shutdownMu", ".", "Unlock", "(", ")", "\n", "d", ".", "stopGames", "(", ")", "\n", "}" ]

[ "Stop", "a", "dealer", "on", "process", "shutdown", "." ]

[ "func", "(", "d", "*", "Dealer", ")", "StartFlip", "(", "ctx", "context", ".", "Context", ",", "start", "Start", ",", "conversationID", "chat1", ".", "ConversationID", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "d", ".", "startFlip", "(", "ctx", ",", "start", ",", "conversationID", ")", "\n", "return", "err", "\n", "}" ]

[ "StartFlip", "starts", "a", "new", "flip", ".", "Pass", "it", "some", "start", "parameters", "as", "well", "as", "a", "chat", "conversationID", "that", "it", "will", "take", "place", "in", "." ]

[ "func", "(", "d", "*", "Dealer", ")", "StartFlipWithGameID", "(", "ctx", "context", ".", "Context", ",", "start", "Start", ",", "conversationID", "chat1", ".", "ConversationID", ",", "gameID", "chat1", ".", "FlipGameID", ")", "(", "err", "error", ")", "{", "_", ",", "err", "=", "d", ".", "startFlipWithGameID", "(", "ctx", ",", "start", ",", "conversationID", ",", "gameID", ")", "\n", "return", "err", "\n", "}" ]

[ "StartFlipWithGameID", "starts", "a", "new", "flip", ".", "Pass", "it", "some", "start", "parameters", "as", "well", "as", "a", "chat", "conversationID", "that", "it", "will", "take", "place", "in", ".", "Also", "takes", "a", "GameID" ]

[ "func", "(", "d", "*", "Dealer", ")", "InjectIncomingChat", "(", "ctx", "context", ".", "Context", ",", "sender", "UserDevice", ",", "conversationID", "chat1", ".", "ConversationID", ",", "gameID", "chat1", ".", "FlipGameID", ",", "body", "GameMessageEncoded", ",", "firstInConversation", "bool", ")", "error", "{", "gmwe", ":=", "GameMessageWrappedEncoded", "{", "Sender", ":", "sender", ",", "GameID", ":", "gameID", ",", "Body", ":", "body", ",", "FirstInConversation", ":", "firstInConversation", ",", "}", "\n", "msg", ",", "err", ":=", "gmwe", ".", "Decode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "msg", ".", "Msg", ".", "Md", ".", "ConversationID", ".", "Eq", "(", "conversationID", ")", "{", "return", "BadChannelError", "{", "G", ":", "msg", ".", "Msg", ".", "Md", ",", "C", ":", "conversationID", "}", "\n", "}", "\n", "if", "!", "msg", ".", "isForwardable", "(", ")", "{", "return", "UnforwardableMessageError", "{", "G", ":", "msg", ".", "Msg", ".", "Md", "}", "\n", "}", "\n", "if", "!", "msg", ".", "Msg", ".", "Md", ".", "GameID", ".", "Eq", "(", "gameID", ")", "{", "return", "BadGameIDError", "{", "G", ":", "msg", ".", "Msg", ".", "Md", ",", "I", ":", "gameID", "}", "\n", "}", "\n", "d", ".", "chatInputCh", "<-", "msg", "\n", "return", "nil", "\n", "}" ]

[ "InjectIncomingChat", "should", "be", "called", "whenever", "a", "new", "flip", "game", "comes", "in", "that", "s", "relevant", "for", "flips", ".", "Call", "this", "with", "the", "sender", "s", "information", "the", "channel", "information", "and", "the", "body", "data", "that", "came", "in", ".", "The", "last", "bool", "is", "true", "only", "if", "this", "is", "the", "first", "message", "in", "the", "channel", ".", "The", "current", "model", "is", "that", "only", "one", "game", "is", "allowed", "for", "each", "chat", "channel", ".", "So", "any", "prior", "messages", "in", "the", "channel", "mean", "it", "might", "be", "replay", ".", "This", "is", "significantly", "less", "general", "than", "an", "earlier", "model", "which", "is", "why", "we", "introduced", "the", "concept", "of", "a", "gameID", "so", "it", "might", "be", "changed", "in", "the", "future", "." ]

[ "func", "NewStartWithBool", "(", "now", "time", ".", "Time", ",", "nPlayers", "int", ")", "Start", "{", "ret", ":=", "newStart", "(", "now", ",", "nPlayers", ")", "\n", "ret", ".", "Params", "=", "NewFlipParametersWithBool", "(", ")", "\n", "return", "ret", "\n", "}" ]

[ "NewStartWithBool", "makes", "new", "start", "parameters", "that", "yield", "a", "coinflip", "game", "." ]

[ "func", "NewStartWithInt", "(", "now", "time", ".", "Time", ",", "mod", "int64", ",", "nPlayers", "int", ")", "Start", "{", "ret", ":=", "newStart", "(", "now", ",", "nPlayers", ")", "\n", "ret", ".", "Params", "=", "NewFlipParametersWithInt", "(", "mod", ")", "\n", "return", "ret", "\n", "}" ]

[ "NewStartWithInt", "makes", "new", "start", "parameters", "that", "yield", "a", "coinflip", "game", "that", "picks", "an", "int", "between", "0", "and", "mod", "." ]

[ "func", "NewStartWithBigInt", "(", "now", "time", ".", "Time", ",", "mod", "*", "big", ".", "Int", ",", "nPlayers", "int", ")", "Start", "{", "ret", ":=", "newStart", "(", "now", ",", "nPlayers", ")", "\n", "ret", ".", "Params", "=", "NewFlipParametersWithBig", "(", "mod", ".", "Bytes", "(", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "NewStartWithBigInt", "makes", "new", "start", "parameters", "that", "yield", "a", "coinflip", "game", "that", "picks", "big", "int", "between", "0", "and", "mod", "." ]

[ "func", "NewStartWithShuffle", "(", "now", "time", ".", "Time", ",", "n", "int64", ",", "nPlayers", "int", ")", "Start", "{", "ret", ":=", "newStart", "(", "now", ",", "nPlayers", ")", "\n", "ret", ".", "Params", "=", "NewFlipParametersWithShuffle", "(", "n", ")", "\n", "return", "ret", "\n", "}" ]

[ "NewStartWithShuffle", "makes", "new", "start", "parameters", "for", "a", "coinflip", "that", "randomly", "permutes", "the", "numbers", "between", "0", "and", "n", "exclusive", ".", "This", "can", "be", "used", "to", "shuffle", "an", "array", "of", "names", "." ]

[ "func", "(", "th", "*", "TlfHistory", ")", "AddNotifications", "(", "writerName", "string", ",", "messages", "[", "]", "string", ")", "(", "maxRev", "kbfsmd", ".", "Revision", ",", "err", "error", ")", "{", "newEdits", ":=", "make", "(", "notificationsByRevision", ",", "0", ",", "len", "(", "messages", ")", ")", "\n\n", "// Unmarshal and sort the new messages.", "for", "_", ",", "msg", ":=", "range", "messages", "{", "var", "revList", "[", "]", "NotificationMessage", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "msg", ")", ",", "&", "revList", ")", "\n", "if", "err", "!=", "nil", "{", "// The messages might be from a new version we don't", "// understand, so swallow the error.", "continue", "\n", "}", "\n\n", "for", "j", ":=", "len", "(", "revList", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", "{", "revMsg", ":=", "revList", "[", "j", "]", "\n", "if", "revMsg", ".", "Version", "!=", "NotificationV2", "{", "// Ignore messages that are too new for us to understand.", "continue", "\n", "}", "\n", "revMsg", ".", "numWithinRevision", "=", "j", "\n", "newEdits", "=", "append", "(", "newEdits", ",", "revMsg", ")", "\n", "}", "\n", "}", "\n\n", "th", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "th", ".", "lock", ".", "Unlock", "(", ")", "\n", "wn", ",", "existed", ":=", "th", ".", "byWriter", "[", "writerName", "]", "\n", "if", "!", "existed", "{", "wn", "=", "&", "writerNotifications", "{", "writerName", ",", "nil", ",", "nil", "}", "\n", "}", "\n", "oldLen", ":=", "len", "(", "wn", ".", "notifications", ")", "\n", "newEdits", "=", "append", "(", "newEdits", ",", "wn", ".", "notifications", "...", ")", "\n", "sort", ".", "Sort", "(", "newEdits", ")", "\n", "if", "len", "(", "newEdits", ")", ">", "0", "{", "maxRev", "=", "newEdits", "[", "0", "]", ".", "Revision", "\n", "}", "\n\n", "wn", ".", "notifications", "=", "newEdits", ".", "uniquify", "(", ")", "\n", "if", "len", "(", "wn", ".", "notifications", ")", "==", "oldLen", "{", "// No new messages.", "return", "maxRev", ",", "nil", "\n", "}", "\n", "if", "!", "existed", "{", "th", ".", "byWriter", "[", "writerName", "]", "=", "wn", "\n", "}", "\n", "// Invalidate the cached results.", "th", ".", "computed", "=", "false", "\n", "th", ".", "cachedLoggedInUser", "=", "\"", "\"", "\n", "return", "maxRev", ",", "nil", "\n", "}" ]

[ "AddNotifications", "takes", "in", "a", "set", "of", "messages", "in", "this", "TLF", "by", "writer", "and", "adds", "them", "to", "the", "history", ".", "Once", "done", "adding", "messages", "the", "caller", "should", "call", "Recompute", "to", "find", "out", "if", "more", "messages", "should", "be", "added", "for", "any", "particular", "writer", ".", "It", "returns", "the", "maximum", "known", "revision", "including", "an", "update", "from", "this", "writer", "." ]

[ "func", "(", "th", "*", "TlfHistory", ")", "AddUnflushedNotifications", "(", "loggedInUser", "string", ",", "msgs", "[", "]", "NotificationMessage", ")", "{", "th", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "th", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "th", ".", "unflushed", "==", "nil", "{", "th", ".", "unflushed", "=", "&", "writerNotifications", "{", "loggedInUser", ",", "nil", ",", "nil", "}", "\n", "}", "\n", "if", "th", ".", "unflushed", ".", "writerName", "!=", "loggedInUser", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "loggedInUser", ",", "th", ".", "unflushed", ".", "writerName", ")", ")", "\n", "}", "\n", "newEdits", ":=", "append", "(", "notificationsByRevision", "(", "msgs", ")", ",", "th", ".", "unflushed", ".", "notifications", "...", ")", "\n", "sort", ".", "Sort", "(", "newEdits", ")", "\n", "th", ".", "unflushed", ".", "notifications", "=", "newEdits", ".", "uniquify", "(", ")", "\n", "// Invalidate the cached results.", "th", ".", "computed", "=", "false", "\n", "th", ".", "cachedLoggedInUser", "=", "\"", "\"", "\n", "}" ]

[ "AddUnflushedNotifications", "adds", "notifications", "to", "a", "special", "unflushed", "list", "that", "takes", "precedences", "over", "the", "regular", "notifications", "with", "revision", "numbers", "equal", "or", "greater", "to", "the", "minimum", "unflushed", "revision", "." ]

[ "func", "(", "th", "*", "TlfHistory", ")", "FlushRevision", "(", "rev", "kbfsmd", ".", "Revision", ")", "{", "th", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "th", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "th", ".", "unflushed", "==", "nil", "{", "return", "\n", "}", "\n", "lastToKeep", ":=", "len", "(", "th", ".", "unflushed", ".", "notifications", ")", "-", "1", "\n", "for", ";", "lastToKeep", ">=", "0", ";", "lastToKeep", "--", "{", "if", "th", ".", "unflushed", ".", "notifications", "[", "lastToKeep", "]", ".", "Revision", ">", "rev", "{", "break", "\n", "}", "\n", "}", "\n", "if", "lastToKeep", "<", "len", "(", "th", ".", "unflushed", ".", "notifications", ")", "-", "1", "{", "th", ".", "unflushed", ".", "notifications", "=", "th", ".", "unflushed", ".", "notifications", "[", ":", "lastToKeep", "+", "1", "]", "\n", "// Invalidate the cached results.", "th", ".", "computed", "=", "false", "\n", "th", ".", "cachedLoggedInUser", "=", "\"", "\"", "\n", "}", "\n", "}" ]

[ "FlushRevision", "clears", "all", "any", "unflushed", "notifications", "with", "a", "revision", "equal", "or", "less", "than", "rev", "." ]

[ "func", "(", "th", "*", "TlfHistory", ")", "ClearAllUnflushed", "(", ")", "{", "th", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "th", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "th", ".", "unflushed", "!=", "nil", "{", "// Invalidate the cached results.", "th", ".", "computed", "=", "false", "\n", "th", ".", "cachedLoggedInUser", "=", "\"", "\"", "\n", "}", "\n", "th", ".", "unflushed", "=", "nil", "\n", "}" ]

[ "ClearAllUnflushed", "clears", "all", "unflushed", "notifications", "." ]

[ "func", "(", "e", "ServerErrorUnauthorized", ")", "ToStatus", "(", ")", "(", "s", "keybase1", ".", "Status", ")", "{", "s", ".", "Code", "=", "StatusCodeServerErrorUnauthorized", "\n", "s", ".", "Name", "=", "\"", "\"", "\n", "s", ".", "Desc", "=", "e", ".", "Msg", "\n", "return", "\n", "}" ]

[ "ToStatus", "implements", "the", "ExportableError", "interface", "for", "ServerErrorUnauthorized", "." ]

[ "func", "(", "e", "ServerErrorOverQuota", ")", "ToStatus", "(", ")", "(", "s", "keybase1", ".", "Status", ")", "{", "s", ".", "Code", "=", "StatusCodeServerErrorOverQuota", "\n", "s", ".", "Name", "=", "\"", "\"", "\n", "s", ".", "Desc", "=", "e", ".", "Msg", "\n", "s", ".", "Fields", "=", "append", "(", "s", ".", "Fields", ",", "keybase1", ".", "StringKVPair", "{", "Key", ":", "\"", "\"", ",", "Value", ":", "strconv", ".", "FormatInt", "(", "e", ".", "Usage", ",", "10", ")", ",", "}", ")", "\n", "s", ".", "Fields", "=", "append", "(", "s", ".", "Fields", ",", "keybase1", ".", "StringKVPair", "{", "Key", ":", "\"", "\"", ",", "Value", ":", "strconv", ".", "FormatInt", "(", "e", ".", "Limit", ",", "10", ")", ",", "}", ")", "\n", "s", ".", "Fields", "=", "append", "(", "s", ".", "Fields", ",", "keybase1", ".", "StringKVPair", "{", "Key", ":", "\"", "\"", ",", "Value", ":", "strconv", ".", "FormatBool", "(", "e", ".", "Throttled", ")", ",", "}", ")", "\n", "return", "\n", "}" ]

[ "ToStatus", "implements", "the", "ExportableError", "interface", "for", "ServerErrorOverQuota", "." ]

[ "func", "(", "e", "ServerErrorOverQuota", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "Msg", ",", "e", ".", "Usage", ",", "e", ".", "Limit", ",", "e", ".", "Throttled", ")", "\n", "}" ]

[ "Error", "implements", "the", "Error", "interface", "for", "ServerErrorOverQuota", "." ]

[ "func", "(", "e", "ServerErrorBlockNonExistent", ")", "ToStatus", "(", ")", "(", "s", "keybase1", ".", "Status", ")", "{", "s", ".", "Code", "=", "StatusCodeServerErrorBlockNonExistent", "\n", "s", ".", "Name", "=", "\"", "\"", "\n", "s", ".", "Desc", "=", "e", ".", "Msg", "\n", "return", "\n", "}" ]

[ "ToStatus", "implements", "the", "ExportableError", "interface", "for", "ServerErrorBlockNonExistent" ]

[ "func", "(", "e", "ServerErrorBlockDeleted", ")", "ToStatus", "(", ")", "(", "s", "keybase1", ".", "Status", ")", "{", "s", ".", "Code", "=", "StatusCodeServerErrorBlockDeleted", "\n", "s", ".", "Name", "=", "\"", "\"", "\n", "s", ".", "Desc", "=", "e", ".", "Msg", "\n", "return", "\n", "}" ]

[ "ToStatus", "implements", "the", "ExportableError", "interface", "for", "ServerErrorBlockDeleted" ]

[ "func", "(", "e", "ServerErrorNonceNonExistent", ")", "ToStatus", "(", ")", "(", "s", "keybase1", ".", "Status", ")", "{", "s", ".", "Code", "=", "StatusCodeServerErrorNonceNonExistent", "\n", "s", ".", "Name", "=", "\"", "\"", "\n", "s", ".", "Desc", "=", "e", ".", "Msg", "\n", "return", "\n", "}" ]

[ "ToStatus", "implements", "the", "ExportableError", "interface", "for", "ServerErrorNonceNonExistent" ]

[ "func", "(", "e", "ServerErrorMaxRefExceeded", ")", "ToStatus", "(", ")", "(", "s", "keybase1", ".", "Status", ")", "{", "s", ".", "Code", "=", "StatusCodeServerErrorMaxRefExceeded", "\n", "s", ".", "Name", "=", "\"", "\"", "\n", "s", ".", "Desc", "=", "e", ".", "Msg", "\n", "return", "\n", "}" ]

[ "ToStatus", "implements", "the", "ExportableError", "interface", "for", "ServerErrorMaxRefExceeded" ]

[ "func", "IsThrottleError", "(", "err", "error", ")", "bool", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "ServerErrorThrottle", ")", ";", "ok", "{", "return", "true", "\n", "}", "\n", "if", "quotaErr", ",", "ok", ":=", "err", ".", "(", "ServerErrorOverQuota", ")", ";", "ok", "&&", "quotaErr", ".", "Throttled", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsThrottleError", "returns", "whether", "or", "not", "the", "given", "error", "signals", "throttling", "." ]

[ "func", "NewSelfProvisionEngine", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "deviceName", "string", ")", "*", "SelfProvisionEngine", "{", "return", "&", "SelfProvisionEngine", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "DeviceName", ":", "deviceName", ",", "}", "\n", "}" ]

[ "If", "a", "device", "is", "cloned", "we", "can", "provision", "a", "new", "device", "from", "the", "current", "device", "to", "get", "out", "of", "the", "cloned", "state", "." ]

[ "func", "(", "e", "*", "SelfProvisionEngine", ")", "makeDeviceKeysWithSigner", "(", "m", "libkb", ".", "MetaContext", ",", "signer", "libkb", ".", "GenericKey", ")", "error", "{", "if", "err", ":=", "e", ".", "ensureLKSec", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "_", ",", "deviceType", ",", "err", ":=", "m", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ".", "LookupUsernameAndDevice", "(", "m", ".", "Ctx", "(", ")", ",", "e", ".", "User", ".", "GetUID", "(", ")", ",", "e", ".", "G", "(", ")", ".", "ActiveDevice", ".", "DeviceID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "args", ":=", "&", "DeviceWrapArgs", "{", "Me", ":", "e", ".", "User", ",", "DeviceName", ":", "e", ".", "DeviceName", ",", "DeviceType", ":", "deviceType", ",", "Lks", ":", "e", ".", "lks", ",", "IsEldest", ":", "false", ",", "// just to be explicit", "IsSelfProvision", ":", "true", ",", "PerUserKeyring", ":", "e", ".", "perUserKeyring", ",", "EldestKID", ":", "e", ".", "User", ".", "GetEldestKID", "(", ")", ",", "Signer", ":", "signer", ",", "EkReboxer", ":", "e", ".", "ekReboxer", ",", "}", "\n\n", "e", ".", "deviceWrapEng", "=", "NewDeviceWrap", "(", "m", ".", "G", "(", ")", ",", "args", ")", "\n", "return", "RunEngine2", "(", "m", ",", "e", ".", "deviceWrapEng", ")", "\n", "}" ]

[ "makeDeviceKeysWithSigner", "creates", "device", "keys", "given", "a", "signing", "key", "." ]

[ "func", "(", "e", "*", "SelfProvisionEngine", ")", "ppStream", "(", "m", "libkb", ".", "MetaContext", ")", "(", "*", "libkb", ".", "PassphraseStream", ",", "error", ")", "{", "if", "m", ".", "LoginContext", "(", ")", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "cached", ":=", "m", ".", "LoginContext", "(", ")", ".", "PassphraseStreamCache", "(", ")", "\n", "if", "cached", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "cached", ".", "PassphraseStream", "(", ")", ",", "nil", "\n", "}" ]

[ "copied", "from", "loginProvision", "ppStream", "gets", "the", "passphrase", "stream", "from", "the", "cache" ]

[ "func", "isLoggedInWithUIDAndError", "(", "m", "libkb", ".", "MetaContext", ")", "(", "ret", "bool", ",", "uid", "keybase1", ".", "UID", ",", "err", "error", ")", "{", "ret", ",", "uid", ",", "err", "=", "libkb", ".", "BootstrapActiveDeviceWithMetaContext", "(", "m", ")", "\n", "return", "ret", ",", "uid", ",", "err", "\n", "}" ]

[ "isLoggedInWithUIDAndError", "conveys", "if", "the", "user", "is", "in", "a", "logged", "-", "in", "state", "or", "not", ".", "If", "this", "function", "returns", "true", "it", "s", "because", "the", "user", "is", "logged", "in", "is", "on", "a", "provisioned", "device", "and", "has", "an", "unlocked", "device", "key", "If", "this", "function", "returns", "false", "it", "s", "because", "either", "no", "one", "has", "ever", "logged", "onto", "this", "device", "or", "someone", "has", "and", "then", "clicked", "logout", ".", "If", "the", "return", "value", "is", "false", "and", "err", "is", "nil", "then", "the", "service", "is", "in", "one", "of", "those", "expected", "logged", "out", "states", ".", "If", "the", "return", "value", "is", "false", "and", "err", "is", "non", "-", "nil", "then", "something", "went", "wrong", "and", "the", "app", "is", "in", "some", "sort", "of", "unexpected", "state", ".", "If", "ret", "is", "true", "then", "uid", "will", "convey", "which", "user", "is", "logged", "in", ".", "Under", "the", "hood", "IsLoggedIn", "is", "going", "through", "the", "BootstrapActiveDevice", "flow", "and", "therefore", "will", "try", "its", "best", "to", "unlocked", "locked", "keys", "if", "it", "can", "without", "user", "interaction", "." ]

[ "func", "genClientConfigForInternalAPI", "(", "g", "*", "GlobalContext", ")", "(", "*", "ClientConfig", ",", "error", ")", "{", "e", ":=", "g", ".", "Env", "\n", "serverURI", ":=", "e", ".", "GetServerURI", "(", ")", "\n\n", "if", "e", ".", "GetTorMode", "(", ")", ".", "Enabled", "(", ")", "{", "serverURI", "=", "e", ".", "GetTorHiddenAddress", "(", ")", "\n", "}", "\n\n", "if", "serverURI", "==", "\"", "\"", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "url", ",", "err", ":=", "url", ".", "Parse", "(", "serverURI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "url", ".", "Scheme", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "url", ".", "Host", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "useTLS", ":=", "(", "url", ".", "Scheme", "==", "\"", "\"", ")", "\n", "host", ",", "port", ",", "e2", ":=", "SplitHost", "(", "url", ".", "Host", ")", "\n", "if", "e2", "!=", "nil", "{", "return", "nil", ",", "e2", "\n", "}", "\n", "var", "rootCAs", "*", "x509", ".", "CertPool", "\n", "if", "rawCA", ":=", "e", ".", "GetBundledCA", "(", "host", ")", ";", "len", "(", "rawCA", ")", ">", "0", "{", "rootCAs", ",", "err", "=", "ParseCA", "(", "rawCA", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "host", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "g", ".", "Log", ".", "Debug", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "host", ",", "ShortCA", "(", "rawCA", ")", ")", ")", "\n", "}", "\n\n", "// If we're using proxies, they might have their own CAs.", "if", "rootCAs", ",", "err", "=", "GetProxyCAs", "(", "rootCAs", ",", "e", ".", "config", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ret", ":=", "&", "ClientConfig", "{", "host", ",", "port", ",", "useTLS", ",", "url", ",", "rootCAs", ",", "url", ".", "Path", ",", "true", ",", "e", ".", "GetAPITimeout", "(", ")", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "GenClientConfigForInternalAPI", "pulls", "the", "information", "out", "of", "the", "environment", "configuration", "and", "build", "a", "Client", "config", "that", "will", "be", "used", "in", "all", "API", "server", "requests" ]

[ "func", "(", "s", "*", "Server", ")", "allowDomain", "(", "ctx", "context", ".", "Context", ",", "host", "string", ")", "(", "err", "error", ")", "{", "host", "=", "strings", ".", "ToLower", "(", "strings", ".", "TrimSpace", "(", "host", ")", ")", "\n", "if", "err", "=", "s", ".", "config", ".", "checkDomainLists", "(", "host", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// DoS protection: look up kbp TXT record before attempting ACME cert", "// issuance, and only allow those that have DNS records configured. This is", "// in case someone keeps sending us TLS handshakes with random SNIs,", "// causing us to be rate-limited by the ACME server.", "//", "// TODO: cache the parsed root somewhere so we don't end up doing it twice", "// for each connection.", "if", "_", ",", "err", "=", "s", ".", "rootLoader", ".", "LoadRoot", "(", "host", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "allowDomain", "is", "used", "to", "determine", "whether", "a", "given", "domain", "should", "be", "served", ".", "It", "s", "also", "used", "as", "a", "HostPolicy", "in", "autocert", "package", "." ]

[ "func", "ListenAndServe", "(", "ctx", "context", ".", "Context", ",", "config", "*", "ServerConfig", ",", "kbfsConfig", "libkbfs", ".", "Config", ")", "(", "err", "error", ")", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "libmime", ".", "Patch", "(", "additionalMimeTypes", ")", "\n\n", "server", ":=", "&", "Server", "{", "config", ":", "config", ",", "kbfsConfig", ":", "kbfsConfig", ",", "rootLoader", ":", "DNSRootLoader", "{", "log", ":", "config", ".", "Logger", "}", ",", "}", "\n", "server", ".", "siteCache", ",", "err", "=", "lru", ".", "NewWithEvict", "(", "fsCacheSize", ",", "server", ".", "siteCacheEvict", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "manager", ",", "err", ":=", "makeACMEManager", "(", "config", ".", "UseStaging", ",", "config", ".", "UseDiskCertCache", ",", "server", ".", "allowDomain", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "httpsServer", ":=", "http", ".", "Server", "{", "Handler", ":", "server", ",", "ReadHeaderTimeout", ":", "httpReadHeaderTimeout", ",", "IdleTimeout", ":", "httpIdleTimeout", ",", "}", "\n\n", "httpServer", ":=", "http", ".", "Server", "{", "Addr", ":", "\"", "\"", ",", "// Enable http-01 by calling the HTTPHandler method, and set the", "// fallback HTTP handler to nil. As described in the autocert doc", "// (https://github.com/golang/crypto/blob/13931e22f9e72ea58bb73048bc752b48c6d4d4ac/acme/autocert/autocert.go#L248-L251),", "// this means for requests not for ACME domain verification, a default", "// fallback handler is used, which redirects all HTTP traffic using GET", "// and HEAD to HTTPS using 302 Found, and responds with 400 Bad Request", "// for requests with other methods.", "Handler", ":", "manager", ".", "HTTPHandler", "(", "nil", ")", ",", "ReadHeaderTimeout", ":", "httpReadHeaderTimeout", ",", "IdleTimeout", ":", "httpIdleTimeout", ",", "}", "\n\n", "go", "func", "(", ")", "{", "<-", "ctx", ".", "Done", "(", ")", "\n", "shutdownCtx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "context", ".", "Background", "(", ")", ",", "gracefulShutdownTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "httpsServer", ".", "Shutdown", "(", "shutdownCtx", ")", "\n", "httpServer", ".", "Shutdown", "(", "shutdownCtx", ")", "\n", "}", "(", ")", "\n\n", "go", "func", "(", ")", "{", "err", ":=", "httpServer", ".", "ListenAndServe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "config", ".", "Logger", ".", "Error", "(", "\"", "\"", ",", "zap", ".", "Error", "(", "err", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "httpsServer", ".", "Serve", "(", "manager", ".", "Listener", "(", ")", ")", "\n", "}" ]

[ "ListenAndServe", "listens", "on", "443", "and", "80", "ports", "of", "all", "addresses", "and", "serve", "Keybase", "Pages", "based", "on", "config", "and", "kbfsConfig", ".", "HTTPs", "setup", "is", "handled", "with", "ACME", "." ]

[ "func", "(", "m", "multiStatReporter", ")", "ReportServedRequest", "(", "r", "*", "ServedRequestInfo", ")", "{", "for", "_", ",", "reporter", ":=", "range", "m", "{", "reporter", ".", "ReportServedRequest", "(", "r", ")", "\n", "}", "\n", "}" ]

[ "ReportServedRequest", "implements", "the", "StatsReporter", "interface", "." ]

[ "func", "NewFileBasedActivityStatsStorer", "(", "rootPath", "string", ",", "logger", "*", "zap", ".", "Logger", ")", "(", "ActivityStatsStorer", ",", "error", ")", "{", "err", ":=", "os", ".", "MkdirAll", "(", "filepath", ".", "Join", "(", "rootPath", ",", "dirnameTlfStamps", ")", ",", "os", ".", "ModeDir", "|", "0700", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "err", "=", "os", ".", "MkdirAll", "(", "filepath", ".", "Join", "(", "rootPath", ",", "dirnameHostStamps", ")", ",", "os", ".", "ModeDir", "|", "0700", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "s", ":=", "&", "fileBasedActivityStatsStorer", "{", "root", ":", "rootPath", ",", "logger", ":", "logger", ",", "ch", ":", "make", "(", "chan", "activity", ",", "fbassChSize", ")", ",", "}", "\n", "go", "s", ".", "processLoop", "(", ")", "\n", "return", "s", ",", "nil", "\n", "}" ]

[ "NewFileBasedActivityStatsStorer", "creates", "an", "ActivityStatsStorer", "that", "stores", "activities", "on", "a", "local", "filesystem", ".", "NOTE", "that", "this", "is", "meant", "to", "be", "for", "development", "and", "testing", "only", "and", "does", "not", "scale", "well", "." ]

[ "func", "(", "s", "*", "fileBasedActivityStatsStorer", ")", "RecordActives", "(", "tlf", "tlf", ".", "ID", ",", "host", "string", ")", "{", "s", ".", "ch", "<-", "activity", "{", "tlfID", ":", "tlf", ",", "host", ":", "host", "}", "\n", "}" ]

[ "RecordActives", "implement", "the", "ActivityStatsStorer", "interface", "." ]

[ "func", "(", "s", "*", "fileBasedActivityStatsStorer", ")", "GetActivesGetter", "(", ")", "(", "getter", "ActivesGetter", ",", "err", "error", ")", "{", "tlfStamps", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "filepath", ".", "Join", "(", "s", ".", "root", ",", "dirnameTlfStamps", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "hostStamps", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "filepath", ".", "Join", "(", "s", ".", "root", ",", "dirnameHostStamps", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "fileinfoActivesGetter", "{", "tlfs", ":", "tlfStamps", ",", "hosts", ":", "hostStamps", ",", "}", ",", "nil", "\n", "}" ]

[ "GetActiveTlfs", "implement", "the", "ActivityStatsStorer", "interface", "." ]

[ "func", "TimeEqual", "(", "a", ",", "b", "time", ".", "Time", ")", "bool", "{", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "a", "=", "a", ".", "Truncate", "(", "1", "*", "time", ".", "Second", ")", "\n", "b", "=", "b", ".", "Truncate", "(", "1", "*", "time", ".", "Second", ")", "\n", "}", "\n", "return", "a", ".", "Equal", "(", "b", ")", "\n", "}" ]

[ "TimeEqual", "compares", "two", "filesystem", "-", "related", "timestamps", ".", "On", "platforms", "that", "don", "t", "use", "nanosecond", "-", "accurate", "timestamps", "in", "their", "filesystem", "APIs", "it", "truncates", "the", "timestamps", "to", "make", "them", "comparable", "." ]

[ "func", "(", "p", "*", "proofSetT", ")", "AddNeededHappensBeforeProof", "(", "ctx", "context", ".", "Context", ",", "a", "proofTerm", ",", "b", "proofTerm", ",", "reason", "string", ")", "{", "var", "action", "string", "\n", "defer", "func", "(", ")", "{", "if", "action", "!=", "\"", "\"", "&&", "!", "ShouldSuppressLogging", "(", "ctx", ")", "{", "p", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "a", ".", "shortForm", "(", ")", ",", "b", ".", "shortForm", "(", ")", ",", "action", ",", "reason", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "idx", ":=", "newProofIndex", "(", "a", ".", "leafID", ",", "b", ".", "leafID", ")", "\n\n", "if", "idx", ".", "a", ".", "Equal", "(", "idx", ".", "b", ")", "{", "// If both terms are on the same chain", "if", "a", ".", "lessThanOrEqual", "(", "b", ")", "{", "// The proof is self-evident.", "// Discard it.", "action", "=", "\"", "\"", "\n", "return", "\n", "}", "\n", "// The proof is self-evident FALSE.", "// Add it and return immediately so the rest of this function doesn't have to trip over it.", "// It should be failed later by the checker.", "action", "=", "\"", "\"", "\n", "p", ".", "proofs", "[", "idx", "]", "=", "append", "(", "p", ".", "proofs", "[", "idx", "]", ",", "proof", "{", "a", ",", "b", ",", "reason", "}", ")", "\n", "return", "\n", "}", "\n\n", "set", ":=", "p", ".", "proofs", "[", "idx", "]", "\n", "for", "i", ":=", "len", "(", "set", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "existing", ":=", "set", "[", "i", "]", "\n", "if", "existing", ".", "a", ".", "lessThanOrEqual", "(", "a", ")", "&&", "b", ".", "lessThanOrEqual", "(", "existing", ".", "b", ")", "{", "// If the new proof is surrounded by the old proof.", "existing", ".", "a", "=", "existing", ".", "a", ".", "max", "(", "a", ")", "\n", "existing", ".", "b", "=", "existing", ".", "b", ".", "min", "(", "b", ")", "\n", "set", "[", "i", "]", "=", "existing", "\n", "action", "=", "\"", "\"", "\n", "return", "\n", "}", "\n", "if", "existing", ".", "a", ".", "equal", "(", "a", ")", "&&", "existing", ".", "b", ".", "lessThanOrEqual", "(", "b", ")", "{", "// If the new proof is the same on the left and weaker on the right.", "// Discard the new proof, as it is implied by the existing one.", "action", "=", "\"", "\"", "\n", "return", "\n", "}", "\n", "}", "\n", "action", "=", "\"", "\"", "\n", "p", ".", "proofs", "[", "idx", "]", "=", "append", "(", "p", ".", "proofs", "[", "idx", "]", ",", "proof", "{", "a", ",", "b", ",", "reason", "}", ")", "\n", "return", "\n", "}" ]

[ "AddNeededHappensBeforeProof", "adds", "a", "new", "needed", "proof", "to", "the", "proof", "set", ".", "The", "proof", "is", "that", "a", "happened", "before", "b", ".", "If", "there", "are", "other", "proofs", "in", "the", "proof", "set", "that", "prove", "the", "same", "thing", "then", "we", "can", "tighten", "those", "proofs", "with", "a", "and", "b", "if", "it", "makes", "sense", ".", "For", "instance", "if", "there", "is", "an", "existing", "proof", "that", "c<d", "but", "we", "know", "that", "c<a", "and", "b<d", "then", "it", "suffices", "to", "replace", "c<d", "with", "a<b", "as", "the", "needed", "proof", ".", "Each", "proof", "in", "the", "proof", "set", "in", "the", "end", "will", "correspond", "to", "a", "merkle", "tree", "lookup", "so", "it", "makes", "sense", "to", "be", "stingy", ".", "Return", "the", "modified", "proof", "set", "with", "the", "new", "proofs", "needed", "but", "the", "original", "argument", "p", "will", "be", "mutated", "." ]

[ "func", "(", "p", "*", "proofSetT", ")", "SetTeamLinkMap", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "linkMap", "linkMapT", ")", "{", "p", ".", "teamLinkMaps", "[", "teamID", "]", "=", "linkMap", "\n", "}" ]

[ "Set", "the", "latest", "link", "map", "for", "the", "team" ]

[ "func", "(", "p", "proof", ")", "lookupMerkleTreeChain", "(", "ctx", "context", ".", "Context", ",", "world", "LoaderContext", ")", "(", "ret", "*", "libkb", ".", "MerkleTriple", ",", "err", "error", ")", "{", "return", "world", ".", "merkleLookupTripleAtHashMeta", "(", "ctx", ",", "p", ".", "a", ".", "isPublic", "(", ")", ",", "p", ".", "a", ".", "leafID", ",", "p", ".", "b", ".", "sigMeta", ".", "PrevMerkleRootSigned", ".", "HashMeta", ")", "\n", "}" ]

[ "lookupMerkleTreeChain", "loads", "the", "path", "up", "to", "the", "merkle", "tree", "and", "back", "down", "that", "corresponds", "to", "this", "proof", ".", "It", "will", "contact", "the", "API", "server", ".", "Returns", "the", "sigchain", "tail", "on", "success", "." ]

[ "func", "(", "p", "proof", ")", "check", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "world", "LoaderContext", ",", "proofSet", "*", "proofSetT", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "p", ".", "shortForm", "(", ")", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "triple", ",", "err", ":=", "p", ".", "lookupMerkleTreeChain", "(", "ctx", ",", "world", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// laterSeqno is the tail of chain A at the time when B was signed", "// earlierSeqno is the tail of chain A at the time when A was signed", "laterSeqno", ":=", "triple", ".", "Seqno", "\n", "earlierSeqno", ":=", "p", ".", "a", ".", "sigMeta", ".", "SigChainLocation", ".", "Seqno", "\n", "if", "earlierSeqno", ">", "laterSeqno", "{", "return", "NewProofError", "(", "p", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "earlierSeqno", ",", "laterSeqno", ")", ")", "\n", "}", "\n\n", "linkID", ",", "err", ":=", "p", ".", "findLink", "(", "ctx", ",", "g", ",", "world", ",", "p", ".", "a", ".", "leafID", ",", "laterSeqno", ",", "p", ".", "a", ".", "linkMap", ",", "proofSet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "!", "triple", ".", "LinkID", ".", "Export", "(", ")", ".", "Eq", "(", "linkID", ")", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "spew", ".", "Sdump", "(", "p", ")", ")", "\n", "return", "NewProofError", "(", "p", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "triple", ".", "LinkID", ",", "linkID", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "check", "a", "single", "proof", ".", "Call", "to", "the", "merkle", "API", "endpoint", "and", "then", "ensure", "that", "the", "data", "that", "comes", "back", "fits", "the", "proof", "and", "previously", "checked", "sigchain", "links", "." ]

[ "func", "(", "p", "proof", ")", "findLink", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "world", "LoaderContext", ",", "leafID", "keybase1", ".", "UserOrTeamID", ",", "seqno", "keybase1", ".", "Seqno", ",", "firstLinkMap", "linkMapT", ",", "proofSet", "*", "proofSetT", ")", "(", "linkID", "keybase1", ".", "LinkID", ",", "err", "error", ")", "{", "lm", ":=", "firstLinkMap", "\n\n", "if", "leafID", ".", "IsTeamOrSubteam", "(", ")", "{", "// Pull in the latest link map, instead of the one from the proof object.", "tid", ":=", "leafID", ".", "AsTeamOrBust", "(", ")", "\n", "lm2", ",", "ok", ":=", "proofSet", ".", "teamLinkMaps", "[", "tid", "]", "\n", "if", "ok", "{", "lm", "=", "lm2", "\n", "}", "\n", "}", "\n", "if", "lm", "==", "nil", "{", "return", "linkID", ",", "NewProofError", "(", "p", ",", "\"", "\"", ")", "\n", "}", "\n\n", "linkID", ",", "ok", ":=", "lm", "[", "seqno", "]", "\n", "if", "ok", "{", "return", "linkID", ",", "nil", "\n", "}", "\n\n", "// We loaded this user originally to get a sigchain as fresh as a certain key provisioning.", "// In this scenario, we might need a fresher version, so force a poll all the way through", "// the server, and then try again. If we fail the second time, we a force repoll, then", "// we're toast.", "if", "leafID", ".", "IsUser", "(", ")", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "leafID", ".", "String", "(", ")", ",", "seqno", ")", "\n", "lm", ",", "err", ":=", "world", ".", "forceLinkMapRefreshForUser", "(", "ctx", ",", "leafID", ".", "AsUserOrBust", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "linkID", ",", "err", "\n", "}", "\n", "linkID", ",", "ok", "=", "lm", "[", "seqno", "]", "\n", "}", "\n\n", "if", "!", "ok", "{", "return", "linkID", ",", "NewProofError", "(", "p", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "seqno", ")", ")", "\n", "}", "\n", "return", "linkID", ",", "nil", "\n", "}" ]

[ "Find", "the", "LinkID", "for", "the", "leaf", "at", "the", "seqno", "." ]

[ "func", "(", "p", "*", "proofSetT", ")", "check", "(", "ctx", "context", ".", "Context", ",", "world", "LoaderContext", ",", "parallel", "bool", ")", "(", "err", "error", ")", "{", "defer", "p", ".", "G", "(", ")", ".", "CTrace", "(", "ctx", ",", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "if", "parallel", "{", "return", "p", ".", "checkParallel", "(", "ctx", ",", "world", ")", "\n", "}", "\n\n", "var", "total", "int", "\n", "for", "_", ",", "v", ":=", "range", "p", ".", "proofs", "{", "total", "+=", "len", "(", "v", ")", "\n", "}", "\n\n", "var", "i", "int", "\n", "for", "_", ",", "v", ":=", "range", "p", ".", "proofs", "{", "for", "_", ",", "proof", ":=", "range", "v", "{", "p", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "i", ",", "total", ")", "\n", "err", "=", "proof", ".", "check", "(", "ctx", ",", "p", ".", "G", "(", ")", ",", "world", ",", "p", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "i", "++", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "check", "the", "entire", "proof", "set", "failing", "if", "any", "one", "proof", "fails", "." ]

[ "func", "NewAuthToken", "(", "signer", "Signer", ",", "tokenType", "string", ",", "expireIn", "int", ",", "submoduleName", ",", "version", "string", ",", "rh", "AuthTokenRefreshHandler", ")", "*", "AuthToken", "{", "clientName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "submoduleName", ",", "libkb", ".", "GetPlatformString", "(", ")", ",", "runtime", ".", "GOARCH", ")", "\n", "authToken", ":=", "&", "AuthToken", "{", "signer", ":", "signer", ",", "tokenType", ":", "tokenType", ",", "expireIn", ":", "expireIn", ",", "clientName", ":", "clientName", ",", "clientVersion", ":", "version", ",", "refreshHandler", ":", "rh", ",", "}", "\n", "return", "authToken", "\n", "}" ]

[ "NewAuthToken", "creates", "a", "new", "authentication", "token", "." ]

[ "func", "(", "a", "*", "AuthToken", ")", "signWithUserAndKeyInfo", "(", "ctx", "context", ".", "Context", ",", "challengeInfo", "keybase1", ".", "ChallengeInfo", ",", "uid", "keybase1", ".", "UID", ",", "username", "kbname", ".", "NormalizedUsername", ",", "key", "VerifyingKey", ")", "(", "string", ",", "error", ")", "{", "// create the token", "token", ":=", "auth", ".", "NewToken", "(", "uid", ",", "username", ",", "key", ".", "KID", "(", ")", ",", "a", ".", "tokenType", ",", "challengeInfo", ".", "Challenge", ",", "challengeInfo", ".", "Now", ",", "a", ".", "expireIn", ",", "a", ".", "clientName", ",", "a", ".", "clientVersion", ")", "\n\n", "// sign the token", "signature", ",", "err", ":=", "a", ".", "signer", ".", "SignToString", "(", "ctx", ",", "token", ".", "Bytes", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// reset the ticker", "refreshSeconds", ":=", "a", ".", "expireIn", "/", "2", "\n", "if", "refreshSeconds", "<", "AuthTokenMinRefreshSeconds", "{", "refreshSeconds", "=", "AuthTokenMinRefreshSeconds", "\n", "}", "\n", "a", ".", "startTicker", "(", "refreshSeconds", ")", "\n\n", "return", "signature", ",", "nil", "\n", "}" ]

[ "Sign", "is", "called", "to", "create", "a", "new", "signed", "authentication", "token", "." ]

[ "func", "(", "a", "*", "AuthToken", ")", "SignUserless", "(", "ctx", "context", ".", "Context", ",", "key", "VerifyingKey", ")", "(", "string", ",", "error", ")", "{", "// Pass in a reserved, meaningless UID.", "return", "a", ".", "signWithUserAndKeyInfo", "(", "ctx", ",", "keybase1", ".", "ChallengeInfo", "{", "Now", ":", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", "}", ",", "keybase1", ".", "PublicUID", ",", "\"", "\"", ",", "key", ")", "\n", "}" ]

[ "SignUserless", "signs", "the", "token", "without", "a", "username", "UID", "or", "challenge", ".", "This", "is", "useful", "for", "server", "-", "to", "-", "server", "communication", "where", "identity", "is", "established", "using", "only", "the", "KID", ".", "Assume", "the", "client", "and", "server", "clocks", "are", "roughly", "synchronized", "." ]

[ "func", "(", "a", "*", "AuthToken", ")", "stopTicker", "(", ")", "{", "a", ".", "tickerMu", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "tickerMu", ".", "Unlock", "(", ")", "\n\n", "if", "a", ".", "tickerCancel", "!=", "nil", "{", "a", ".", "tickerCancel", "(", ")", "\n", "a", ".", "tickerCancel", "=", "nil", "\n", "}", "\n", "}" ]

[ "Helper", "to", "stop", "the", "refresh", "ticker", "." ]

[ "func", "(", "l", "LogOutputWithDepthAdder", ")", "CloneWithAddedDepth", "(", "depth", "int", ")", "rpc", ".", "LogOutputWithDepthAdder", "{", "return", "LogOutputWithDepthAdder", "{", "l", ".", "Logger", ".", "CloneWithAddedDepth", "(", "depth", ")", "}", "\n", "}" ]

[ "CloneWithAddedDepth", "implements", "the", "rpc", ".", "LogOutput", "interface", "." ]

[ "func", "DumpPrivateMetadata", "(", "codec", "kbfscodec", ".", "Codec", ",", "serializedPMDLength", "int", ",", "pmd", "PrivateMetadata", ")", "(", "string", ",", "error", ")", "{", "s", ":=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "serializedPMDLength", ")", "\n\n", "eq", ",", "err", ":=", "kbfscodec", ".", "Equal", "(", "codec", ",", "pmd", ",", "PrivateMetadata", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "eq", "{", "s", "+=", "\"", "\\n", "\"", "\n", "}", "else", "{", "c", ":=", "kbfsmd", ".", "DumpConfig", "(", ")", "\n", "// Hardcode the indent level, which depends on the", "// position of the Ops list.", "indent", ":=", "strings", ".", "Repeat", "(", "c", ".", "Indent", ",", "4", ")", "\n\n", "var", "pmdCopy", "PrivateMetadata", "\n", "kbfscodec", ".", "Update", "(", "codec", ",", "&", "pmdCopy", ",", "pmd", ")", "\n", "ops", ":=", "pmdCopy", ".", "Changes", ".", "Ops", "\n", "for", "i", ",", "op", ":=", "range", "ops", "{", "ops", "[", "i", "]", "=", "verboseOp", "{", "op", ",", "indent", "}", "\n", "}", "\n\n", "s", "+=", "c", ".", "Sdump", "(", "pmdCopy", ")", "\n", "}", "\n", "return", "s", ",", "nil", "\n", "}" ]

[ "DumpPrivateMetadata", "returns", "a", "detailed", "dump", "of", "the", "given", "PrivateMetadata", "s", "contents", "." ]

[ "func", "makeRootMetadata", "(", "bareMd", "kbfsmd", ".", "MutableRootMetadata", ",", "extra", "kbfsmd", ".", "ExtraMetadata", ",", "handle", "*", "tlfhandle", ".", "Handle", ")", "*", "RootMetadata", "{", "if", "bareMd", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "// extra can be nil.", "if", "handle", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "RootMetadata", "{", "bareMd", ":", "bareMd", ",", "extra", ":", "extra", ",", "tlfHandle", ":", "handle", ",", "}", "\n", "}" ]

[ "makeRootMetadata", "makes", "a", "RootMetadata", "object", "from", "the", "given", "parameters", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "IsReadable", "(", ")", "bool", "{", "return", "md", ".", "TlfID", "(", ")", ".", "Type", "(", ")", "==", "tlf", ".", "Public", "||", "md", ".", "data", ".", "Dir", ".", "IsInitialized", "(", ")", "\n", "}" ]

[ "IsReadable", "returns", "true", "if", "the", "private", "metadata", "can", "be", "read", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "GetTlfHandle", "(", ")", "*", "tlfhandle", ".", "Handle", "{", "if", "md", ".", "tlfHandle", "==", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "md", ")", ")", "\n", "}", "\n\n", "return", "md", ".", "tlfHandle", "\n", "}" ]

[ "GetTlfHandle", "returns", "the", "TlfHandle", "for", "this", "RootMetadata", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "MakeBareTlfHandle", "(", ")", "(", "tlf", ".", "Handle", ",", "error", ")", "{", "if", "md", ".", "tlfHandle", "!=", "nil", "{", "panic", "(", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "return", "md", ".", "bareMd", ".", "MakeBareTlfHandle", "(", "md", ".", "extra", ")", "\n", "}" ]

[ "MakeBareTlfHandle", "makes", "a", "BareTlfHandle", "for", "this", "RootMetadata", ".", "Should", "be", "used", "only", "by", "servers", "and", "MDOps", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "IsInitialized", "(", ")", "bool", "{", "keyGen", ":=", "md", ".", "LatestKeyGeneration", "(", ")", "\n", "if", "md", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "PublicKeying", "{", "return", "keyGen", "==", "kbfsmd", ".", "PublicKeyGen", "\n", "}", "\n", "// The data is only initialized once we have at least one set of keys", "return", "keyGen", ">=", "kbfsmd", ".", "FirstValidKeyGen", "\n", "}" ]

[ "IsInitialized", "returns", "whether", "or", "not", "this", "RootMetadata", "has", "been", "initialized" ]

[ "func", "(", "md", "*", "RootMetadata", ")", "AddRefBlock", "(", "info", "data", ".", "BlockInfo", ")", "{", "md", ".", "AddRefBytes", "(", "uint64", "(", "info", ".", "EncodedSize", ")", ")", "\n", "md", ".", "AddDiskUsage", "(", "uint64", "(", "info", ".", "EncodedSize", ")", ")", "\n", "md", ".", "data", ".", "Changes", ".", "AddRefBlock", "(", "info", ".", "BlockPointer", ")", "\n", "}" ]

[ "AddRefBlock", "adds", "the", "newly", "-", "referenced", "block", "to", "the", "add", "block", "change", "list", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "AddUnrefBlock", "(", "info", "data", ".", "BlockInfo", ")", "{", "if", "info", ".", "EncodedSize", ">", "0", "{", "md", ".", "AddUnrefBytes", "(", "uint64", "(", "info", ".", "EncodedSize", ")", ")", "\n", "md", ".", "SetDiskUsage", "(", "md", ".", "DiskUsage", "(", ")", "-", "uint64", "(", "info", ".", "EncodedSize", ")", ")", "\n", "md", ".", "data", ".", "Changes", ".", "AddUnrefBlock", "(", "info", ".", "BlockPointer", ")", "\n", "}", "\n", "}" ]

[ "AddUnrefBlock", "adds", "the", "newly", "-", "unreferenced", "block", "to", "the", "add", "block", "change", "list", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "AddUpdate", "(", "oldInfo", "data", ".", "BlockInfo", ",", "newInfo", "data", ".", "BlockInfo", ")", "{", "md", ".", "AddUnrefBytes", "(", "uint64", "(", "oldInfo", ".", "EncodedSize", ")", ")", "\n", "md", ".", "AddRefBytes", "(", "uint64", "(", "newInfo", ".", "EncodedSize", ")", ")", "\n", "md", ".", "AddDiskUsage", "(", "uint64", "(", "newInfo", ".", "EncodedSize", ")", ")", "\n", "md", ".", "SetDiskUsage", "(", "md", ".", "DiskUsage", "(", ")", "-", "uint64", "(", "oldInfo", ".", "EncodedSize", ")", ")", "\n", "md", ".", "data", ".", "Changes", ".", "AddUpdate", "(", "oldInfo", ".", "BlockPointer", ",", "newInfo", ".", "BlockPointer", ")", "\n", "}" ]

[ "AddUpdate", "adds", "the", "newly", "-", "updated", "block", "to", "the", "add", "block", "change", "list", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "AddOp", "(", "o", "op", ")", "{", "md", ".", "data", ".", "Changes", ".", "AddOp", "(", "o", ")", "\n", "}" ]

[ "AddOp", "starts", "a", "new", "operation", "for", "this", "MD", "update", ".", "Subsequent", "AddRefBlock", "AddUnrefBlock", "and", "AddUpdate", "calls", "will", "be", "applied", "to", "this", "operation", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "ClearBlockChanges", "(", ")", "{", "md", ".", "SetRefBytes", "(", "0", ")", "\n", "md", ".", "SetUnrefBytes", "(", "0", ")", "\n", "md", ".", "SetMDRefBytes", "(", "0", ")", "\n", "md", ".", "data", ".", "Changes", ".", "sizeEstimate", "=", "0", "\n", "md", ".", "data", ".", "Changes", ".", "Info", "=", "data", ".", "BlockInfo", "{", "}", "\n", "md", ".", "data", ".", "Changes", ".", "Ops", "=", "nil", "\n", "}" ]

[ "ClearBlockChanges", "resets", "the", "block", "change", "lists", "to", "empty", "for", "this", "RootMetadata", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetLastGCRevision", "(", "rev", "kbfsmd", ".", "Revision", ")", "{", "md", ".", "data", ".", "LastGCRevision", "=", "rev", "\n", "}" ]

[ "SetLastGCRevision", "sets", "the", "last", "revision", "up", "to", "and", "including", "which", "garbage", "collection", "was", "performed", "on", "this", "TLF", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "GetTLFCryptKeyParams", "(", "keyGen", "kbfsmd", ".", "KeyGen", ",", "user", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ")", "(", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "kbfscrypto", ".", "EncryptedTLFCryptKeyClientHalf", ",", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ",", "bool", ",", "error", ")", "{", "return", "md", ".", "bareMd", ".", "GetTLFCryptKeyParams", "(", "keyGen", ",", "user", ",", "key", ",", "md", ".", "extra", ")", "\n", "}" ]

[ "GetTLFCryptKeyParams", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "KeyGenerationsToUpdate", "(", ")", "(", "kbfsmd", ".", "KeyGen", ",", "kbfsmd", ".", "KeyGen", ")", "{", "return", "md", ".", "bareMd", ".", "KeyGenerationsToUpdate", "(", ")", "\n", "}" ]

[ "KeyGenerationsToUpdate", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "TlfID", "(", ")", "tlf", ".", "ID", "{", "if", "md", "==", "nil", "||", "md", ".", "bareMd", "==", "nil", "{", "return", "tlf", ".", "NullID", "\n", "}", "\n", "return", "md", ".", "bareMd", ".", "TlfID", "(", ")", "\n", "}" ]

[ "TlfID", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetBranchID", "(", "bid", "kbfsmd", ".", "BranchID", ")", "{", "md", ".", "bareMd", ".", "SetBranchID", "(", "bid", ")", "\n", "}" ]

[ "SetBranchID", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetPrevRoot", "(", "mdID", "kbfsmd", ".", "ID", ")", "{", "md", ".", "bareMd", ".", "SetPrevRoot", "(", "mdID", ")", "\n", "}" ]

[ "SetPrevRoot", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "GetSerializedWriterMetadata", "(", "codec", "kbfscodec", ".", "Codec", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "md", ".", "bareMd", ".", "GetSerializedWriterMetadata", "(", "codec", ")", "\n", "}" ]

[ "GetSerializedWriterMetadata", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]