Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "(", "r", "*", "Root", ")", "ReadDirAll", "(", "ctx", "context", ".", "Context", ")", "(", "res", "[", "]", "fuse", ".", "Dirent", ",", "err", "error", ")", "{", "r", ".", "log", "(", ")", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "r", ".", "private", ".", "fs", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "ReadMode", ",", "err", ")", "}", "(", ")", "\n", "res", "=", "[", "]", "fuse", ".", "Dirent", "{", "{", "Type", ":", "fuse", ".", "DT_Dir", ",", "Name", ":", "PrivateName", ",", "}", ",", "{", "Type", ":", "fuse", ".", "DT_Dir", ",", "Name", ":", "PublicName", ",", "}", ",", "fuse", ".", "Dirent", "{", "Type", ":", "fuse", ".", "DT_Dir", ",", "Name", ":", "TeamName", ",", "}", ",", "}", "\n", "if", "r", ".", "private", ".", "fs", ".", "platformParams", ".", "shouldAppendPlatformRootDirs", "(", ")", "{", "res", "=", "append", "(", "res", ",", "platformRootDirs", "...", ")", "\n", "}", "\n\n", "if", "name", ":=", "r", ".", "private", ".", "fs", ".", "remoteStatus", ".", "ExtraFileName", "(", ")", ";", "name", "!=", "\"", "\"", "{", "res", "=", "append", "(", "res", ",", "fuse", ".", "Dirent", "{", "Type", ":", "fuse", ".", "DT_File", ",", "Name", ":", "name", "}", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "ReadDirAll", "implements", "the", "ReadDirAll", "interface", "for", "Root", "." ]

[ "func", "(", "cache", "*", "DiskQuotaCacheLocal", ")", "getQuotaLocked", "(", "id", "keybase1", ".", "UserOrTeamID", ",", "metered", "bool", ")", "(", "info", "kbfsblock", ".", "QuotaInfo", ",", "err", "error", ")", "{", "var", "hitMeter", ",", "missMeter", "*", "CountMeter", "\n", "if", "metered", "{", "hitMeter", "=", "cache", ".", "hitMeter", "\n", "missMeter", "=", "cache", ".", "missMeter", "\n", "}", "\n\n", "quotaBytes", ",", "err", ":=", "cache", ".", "db", ".", "GetWithMeter", "(", "[", "]", "byte", "(", "id", ".", "String", "(", ")", ")", ",", "hitMeter", ",", "missMeter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsblock", ".", "QuotaInfo", "{", "}", ",", "err", "\n", "}", "\n", "err", "=", "cache", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "quotaBytes", ",", "&", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsblock", ".", "QuotaInfo", "{", "}", ",", "err", "\n", "}", "\n", "return", "info", ",", "nil", "\n", "}" ]

[ "getQuotaLocked", "retrieves", "the", "quota", "info", "for", "a", "block", "in", "the", "cache", "or", "returns", "leveldb", ".", "ErrNotFound", "and", "a", "zero", "-", "valued", "metadata", "otherwise", "." ]

[ "func", "(", "cache", "*", "DiskQuotaCacheLocal", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "id", "keybase1", ".", "UserOrTeamID", ")", "(", "info", "kbfsblock", ".", "QuotaInfo", ",", "err", "error", ")", "{", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n", "err", "=", "cache", ".", "checkCacheLocked", "(", "ctx", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsblock", ".", "QuotaInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "cache", ".", "getQuotaLocked", "(", "id", ",", "metered", ")", "\n", "}" ]

[ "Get", "implements", "the", "DiskQuotaCache", "interface", "for", "DiskQuotaCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskQuotaCacheLocal", ")", "Put", "(", "ctx", "context", ".", "Context", ",", "id", "keybase1", ".", "UserOrTeamID", ",", "info", "kbfsblock", ".", "QuotaInfo", ")", "(", "err", "error", ")", "{", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "err", "=", "cache", ".", "checkCacheLocked", "(", "ctx", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "encodedInfo", ",", "err", ":=", "cache", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "&", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "cache", ".", "db", ".", "PutWithMeter", "(", "[", "]", "byte", "(", "id", ".", "String", "(", ")", ")", ",", "encodedInfo", ",", "cache", ".", "putMeter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "cache", ".", "quotasCached", "[", "id", "]", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Put", "implements", "the", "DiskQuotaCache", "interface", "for", "DiskQuotaCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskQuotaCacheLocal", ")", "Status", "(", "_", "context", ".", "Context", ")", "DiskQuotaCacheStatus", "{", "select", "{", "case", "<-", "cache", ".", "startedCh", ":", "case", "<-", "cache", ".", "startErrCh", ":", "return", "DiskQuotaCacheStatus", "{", "StartState", ":", "DiskQuotaCacheStartStateFailed", "}", "\n", "default", ":", "return", "DiskQuotaCacheStatus", "{", "StartState", ":", "DiskQuotaCacheStartStateStarting", "}", "\n", "}", "\n\n", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "return", "DiskQuotaCacheStatus", "{", "StartState", ":", "DiskQuotaCacheStartStateStarted", ",", "NumQuotas", ":", "uint64", "(", "len", "(", "cache", ".", "quotasCached", ")", ")", ",", "Hits", ":", "rateMeterToStatus", "(", "cache", ".", "hitMeter", ")", ",", "Misses", ":", "rateMeterToStatus", "(", "cache", ".", "missMeter", ")", ",", "Puts", ":", "rateMeterToStatus", "(", "cache", ".", "putMeter", ")", ",", "}", "\n", "}" ]

[ "Status", "implements", "the", "DiskQuotaCache", "interface", "for", "DiskQuotaCacheLocal", "." ]

[ "func", "NewBlockServerMeasured", "(", "delegate", "BlockServer", ",", "r", "metrics", ".", "Registry", ")", "BlockServerMeasured", "{", "getTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "getEncodedSizeTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "putTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "addBlockReferenceTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "removeBlockReferencesTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "archiveBlockReferencesTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "getLiveBlockReferencesTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "isUnflushedTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "return", "BlockServerMeasured", "{", "delegate", ":", "delegate", ",", "getTimer", ":", "getTimer", ",", "getEncodedSizeTimer", ":", "getEncodedSizeTimer", ",", "putTimer", ":", "putTimer", ",", "addBlockReferenceTimer", ":", "addBlockReferenceTimer", ",", "removeBlockReferencesTimer", ":", "removeBlockReferencesTimer", ",", "archiveBlockReferencesTimer", ":", "archiveBlockReferencesTimer", ",", "getLiveBlockReferencesTimer", ":", "getLiveBlockReferencesTimer", ",", "isUnflushedTimer", ":", "isUnflushedTimer", ",", "}", "\n", "}" ]

[ "NewBlockServerMeasured", "creates", "and", "returns", "a", "new", "BlockServerMeasured", "instance", "with", "the", "given", "delegate", "and", "registry", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ",", "cacheType", "DiskBlockCacheType", ")", "(", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "err", "error", ")", "{", "b", ".", "getTimer", ".", "Time", "(", "func", "(", ")", "{", "buf", ",", "serverHalf", ",", "err", "=", "b", ".", "delegate", ".", "Get", "(", "ctx", ",", "tlfID", ",", "id", ",", "context", ",", "cacheType", ")", "\n", "}", ")", "\n", "return", "buf", ",", "serverHalf", ",", "err", "\n", "}" ]

[ "Get", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "GetEncodedSize", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ")", "(", "size", "uint32", ",", "status", "keybase1", ".", "BlockStatus", ",", "err", "error", ")", "{", "b", ".", "getEncodedSizeTimer", ".", "Time", "(", "func", "(", ")", "{", "size", ",", "status", ",", "err", "=", "b", ".", "delegate", ".", "GetEncodedSize", "(", "ctx", ",", "tlfID", ",", "id", ",", "context", ")", "\n", "}", ")", "\n", "return", "size", ",", "status", ",", "err", "\n", "}" ]

[ "GetEncodedSize", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "AddBlockReference", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ")", "(", "err", "error", ")", "{", "b", ".", "addBlockReferenceTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "b", ".", "delegate", ".", "AddBlockReference", "(", "ctx", ",", "tlfID", ",", "id", ",", "context", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "AddBlockReference", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "RemoveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "liveCounts", "map", "[", "kbfsblock", ".", "ID", "]", "int", ",", "err", "error", ")", "{", "b", ".", "removeBlockReferencesTimer", ".", "Time", "(", "func", "(", ")", "{", "liveCounts", ",", "err", "=", "b", ".", "delegate", ".", "RemoveBlockReferences", "(", "ctx", ",", "tlfID", ",", "contexts", ")", "\n", "}", ")", "\n", "return", "liveCounts", ",", "err", "\n", "}" ]

[ "RemoveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "ArchiveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "err", "error", ")", "{", "b", ".", "archiveBlockReferencesTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "b", ".", "delegate", ".", "ArchiveBlockReferences", "(", "ctx", ",", "tlfID", ",", "contexts", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "ArchiveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "IsUnflushed", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ")", "(", "isUnflushed", "bool", ",", "err", "error", ")", "{", "b", ".", "isUnflushedTimer", ".", "Time", "(", "func", "(", ")", "{", "isUnflushed", ",", "err", "=", "b", ".", "delegate", ".", "IsUnflushed", "(", "ctx", ",", "tlfID", ",", "id", ")", "\n", "}", ")", "\n", "return", "isUnflushed", ",", "err", "\n\n", "}" ]

[ "IsUnflushed", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "{", "b", ".", "delegate", ".", "Shutdown", "(", "ctx", ")", "\n", "}" ]

[ "Shutdown", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "RefreshAuthToken", "(", "ctx", "context", ".", "Context", ")", "{", "b", ".", "delegate", ".", "RefreshAuthToken", "(", "ctx", ")", "\n", "}" ]

[ "RefreshAuthToken", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured", "." ]

[ "func", "(", "b", "BlockServerMeasured", ")", "GetUserQuotaInfo", "(", "ctx", "context", ".", "Context", ")", "(", "info", "*", "kbfsblock", ".", "QuotaInfo", ",", "err", "error", ")", "{", "return", "b", ".", "delegate", ".", "GetUserQuotaInfo", "(", "ctx", ")", "\n", "}" ]

[ "GetUserQuotaInfo", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured" ]

[ "func", "(", "b", "BlockServerMeasured", ")", "GetTeamQuotaInfo", "(", "ctx", "context", ".", "Context", ",", "tid", "keybase1", ".", "TeamID", ")", "(", "info", "*", "kbfsblock", ".", "QuotaInfo", ",", "err", "error", ")", "{", "return", "b", ".", "delegate", ".", "GetTeamQuotaInfo", "(", "ctx", ",", "tid", ")", "\n", "}" ]

[ "GetTeamQuotaInfo", "implements", "the", "BlockServer", "interface", "for", "BlockServerMeasured" ]

[ "func", "attemptLoadImpteamAndConflict", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "impTeamName", "keybase1", ".", "ImplicitTeamDisplayName", ",", "nameWithoutConflict", "string", ",", "preResolveDisplayName", "string", ",", "skipCache", "bool", ")", "(", "conflicts", "[", "]", "keybase1", ".", "ImplicitTeamConflictInfo", ",", "teamID", "keybase1", ".", "TeamID", ",", "hitCache", "bool", ",", "err", "error", ")", "{", "defer", "g", ".", "CTraceTimed", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "impTeamName", ",", "nameWithoutConflict", ",", "preResolveDisplayName", ",", "skipCache", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "imp", ",", "hitCache", ",", "err", ":=", "loadImpteam", "(", "ctx", ",", "g", ",", "nameWithoutConflict", ",", "impTeamName", ".", "IsPublic", ",", "skipCache", ")", "\n", "if", "err", "!=", "nil", "{", "return", "conflicts", ",", "teamID", ",", "hitCache", ",", "err", "\n", "}", "\n", "if", "len", "(", "imp", ".", "Conflicts", ")", ">", "0", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "imp", ".", "Conflicts", ")", ")", "\n", "}", "\n", "// We will use this team. Changed later if we selected a conflict.", "var", "foundSelectedConflict", "bool", "\n", "teamID", "=", "imp", ".", "TeamID", "\n", "// We still need to iterate over Conflicts because we are returning parsed", "// conflict list. So even if caller is not requesting a conflict team, go", "// through this loop.", "for", "i", ",", "conflict", ":=", "range", "imp", ".", "Conflicts", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "conflict", ",", "i", ")", "\n", "conflictInfo", ",", "err", ":=", "conflict", ".", "parse", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "// warn, don't fail", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "err", "=", "nil", "\n", "continue", "\n", "}", "\n", "conflicts", "=", "append", "(", "conflicts", ",", "*", "conflictInfo", ")", "\n\n", "if", "conflictInfo", "==", "nil", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "i", ")", "\n", "continue", "\n", "}", "\n\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "*", "conflictInfo", ")", "\n\n", "if", "impTeamName", ".", "ConflictInfo", "!=", "nil", "{", "match", ":=", "libkb", ".", "FormatImplicitTeamDisplayNameSuffix", "(", "*", "impTeamName", ".", "ConflictInfo", ")", "==", "libkb", ".", "FormatImplicitTeamDisplayNameSuffix", "(", "*", "conflictInfo", ")", "\n", "if", "match", "{", "teamID", "=", "conflict", ".", "TeamID", "\n", "foundSelectedConflict", "=", "true", "\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "teamID", ")", "\n", "}", "else", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "conflict", ".", "TeamID", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "impTeamName", ".", "ConflictInfo", "!=", "nil", "&&", "!", "foundSelectedConflict", "{", "// We got the team but didn't find the specific conflict requested.", "return", "conflicts", ",", "teamID", ",", "hitCache", ",", "NewTeamDoesNotExistError", "(", "impTeamName", ".", "IsPublic", ",", "\"", "\"", ",", "preResolveDisplayName", ")", "\n", "}", "\n", "return", "conflicts", ",", "teamID", ",", "hitCache", ",", "nil", "\n", "}" ]

[ "attemptLoadImpteamAndConflits", "attempts", "to", "lead", "the", "implicit", "team", "with", "conflict", "but", "it", "might", "find", "the", "team", "but", "not", "the", "specific", "conflict", "if", "the", "conflict", "was", "not", "in", "cache", ".", "This", "can", "be", "detected", "with", "hitCache", "return", "value", "and", "mitigated", "by", "passing", "skipCache", "=", "false", "argument", "." ]

[ "func", "LookupOrCreateImplicitTeam", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "displayName", "string", ",", "public", "bool", ")", "(", "res", "*", "Team", ",", "teamName", "keybase1", ".", "TeamName", ",", "impTeamName", "keybase1", ".", "ImplicitTeamDisplayName", ",", "err", "error", ")", "{", "defer", "g", ".", "CTraceTimed", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "displayName", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "lookupName", ",", "err", ":=", "ResolveImplicitTeamDisplayName", "(", "ctx", ",", "g", ",", "displayName", ",", "public", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "teamName", ",", "impTeamName", ",", "err", "\n", "}", "\n\n", "res", ",", "teamName", ",", "impTeamName", ",", "_", ",", "err", "=", "lookupImplicitTeamAndConflicts", "(", "ctx", ",", "g", ",", "displayName", ",", "lookupName", ",", "ImplicitTeamOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "TeamDoesNotExistError", ")", ";", "ok", "{", "if", "lookupName", ".", "ConflictInfo", "!=", "nil", "{", "// Don't create it if a conflict is specified.", "// Unlikely a caller would know the conflict info if it didn't exist.", "return", "res", ",", "teamName", ",", "impTeamName", ",", "err", "\n", "}", "\n", "// If the team does not exist, then let's create it", "impTeamName", "=", "lookupName", "\n", "var", "teamID", "keybase1", ".", "TeamID", "\n", "teamID", ",", "teamName", ",", "err", "=", "CreateImplicitTeam", "(", "ctx", ",", "g", ",", "impTeamName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "isDupImplicitTeamError", "(", "ctx", ",", "err", ")", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "res", ",", "teamName", ",", "impTeamName", ",", "_", ",", "err", "=", "lookupImplicitTeamAndConflicts", "(", "ctx", ",", "g", ",", "displayName", ",", "lookupName", ",", "ImplicitTeamOptions", "{", "}", ")", "\n", "}", "\n", "return", "res", ",", "teamName", ",", "impTeamName", ",", "err", "\n", "}", "\n", "res", ",", "err", "=", "Load", "(", "ctx", ",", "g", ",", "keybase1", ".", "LoadTeamArg", "{", "ID", ":", "teamID", ",", "Public", ":", "impTeamName", ".", "IsPublic", ",", "ForceRepoll", ":", "true", ",", "}", ")", "\n", "return", "res", ",", "teamName", ",", "impTeamName", ",", "err", "\n", "}", "\n", "return", "res", ",", "teamName", ",", "impTeamName", ",", "err", "\n", "}", "\n", "return", "res", ",", "teamName", ",", "impTeamName", ",", "nil", "\n", "}" ]

[ "LookupOrCreateImplicitTeam", "by", "name", "like", "alice", "bob", "+", "bob" ]

[ "func", "FormatImplicitTeamDisplayNameWithUserFront", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "impTeamName", "keybase1", ".", "ImplicitTeamDisplayName", ",", "frontName", "libkb", ".", "NormalizedUsername", ")", "(", "string", ",", "error", ")", "{", "return", "formatImplicitTeamDisplayNameCommon", "(", "ctx", ",", "g", ",", "impTeamName", ",", "&", "frontName", ")", "\n", "}" ]

[ "Format", "an", "implicit", "display", "name", "but", "order", "the", "specified", "username", "first", "in", "each", "of", "the", "writer", "and", "reader", "lists", "if", "it", "appears", "." ]

[ "func", "sortStringsFront", "(", "ss", "[", "]", "string", ",", "front", "string", ")", "{", "sort", ".", "Slice", "(", "ss", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "a", ":=", "ss", "[", "i", "]", "\n", "b", ":=", "ss", "[", "j", "]", "\n", "if", "a", "==", "front", "{", "return", "true", "\n", "}", "\n", "if", "b", "==", "front", "{", "return", "false", "\n", "}", "\n", "return", "a", "<", "b", "\n", "}", ")", "\n", "}" ]

[ "Sort", "a", "list", "of", "strings", "but", "order", "front", "in", "front", "IF", "it", "appears", "." ]

[ "func", "(", "c", "KbfsClient", ")", "FSEditList", "(", "ctx", "context", ".", "Context", ",", "__arg", "FSEditListArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "kbfs", "calls", "this", "as", "a", "response", "to", "receiving", "an", "FSEditListRequest", "with", "a", "given", "requestID", "." ]

[ "func", "(", "c", "KbfsClient", ")", "FSSyncStatus", "(", "ctx", "context", ".", "Context", ",", "__arg", "FSSyncStatusArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "FSSyncStatus", "is", "called", "by", "KBFS", "as", "a", "response", "to", "receiving", "an", "FSSyncStatusRequest", "with", "a", "given", "requestID", "." ]

[ "func", "(", "c", "KbfsClient", ")", "FSSyncEvent", "(", "ctx", "context", ".", "Context", ",", "event", "FSPathSyncStatus", ")", "(", "err", "error", ")", "{", "__arg", ":=", "FSSyncEventArg", "{", "Event", ":", "event", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "FSSyncEvent", "is", "called", "by", "KBFS", "when", "the", "sync", "status", "of", "an", "individual", "path", "changes", "." ]

[ "func", "(", "c", "KbfsClient", ")", "FSOverallSyncEvent", "(", "ctx", "context", ".", "Context", ",", "status", "FolderSyncStatus", ")", "(", "err", "error", ")", "{", "__arg", ":=", "FSOverallSyncEventArg", "{", "Status", ":", "status", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "FSOverallSyncEvent", "is", "called", "by", "KBFS", "when", "the", "overall", "sync", "status", "changes", "." ]

[ "func", "(", "c", "KbfsClient", ")", "FSOnlineStatusChangedEvent", "(", "ctx", "context", ".", "Context", ",", "online", "bool", ")", "(", "err", "error", ")", "{", "__arg", ":=", "FSOnlineStatusChangedEventArg", "{", "Online", ":", "online", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "FSOnlineStatusChangedEvent", "is", "called", "by", "KBFS", "when", "the", "online", "status", "changes", "." ]

[ "func", "(", "c", "KbfsClient", ")", "CreateTLF", "(", "ctx", "context", ".", "Context", ",", "__arg", "CreateTLFArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "createTLF", "is", "called", "by", "KBFS", "to", "associate", "the", "tlfID", "with", "the", "given", "teamID", "using", "the", "v2", "Team", "-", "based", "system", "." ]

[ "func", "(", "c", "KbfsClient", ")", "GetKBFSTeamSettings", "(", "ctx", "context", ".", "Context", ",", "__arg", "GetKBFSTeamSettingsArg", ")", "(", "res", "KBFSTeamSettings", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "getKBFSTeamSettings", "gets", "the", "settings", "written", "for", "the", "team", "in", "the", "team", "s", "sigchain", "." ]

[ "func", "(", "c", "KbfsClient", ")", "UpgradeTLF", "(", "ctx", "context", ".", "Context", ",", "__arg", "UpgradeTLFArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "upgradeTLF", "upgrades", "a", "TLF", "to", "use", "implicit", "team", "keys" ]

[ "func", "(", "c", "KbfsClient", ")", "EncryptFavorites", "(", "ctx", "context", ".", "Context", ",", "dataToEncrypt", "[", "]", "byte", ")", "(", "res", "[", "]", "byte", ",", "err", "error", ")", "{", "__arg", ":=", "EncryptFavoritesArg", "{", "DataToEncrypt", ":", "dataToEncrypt", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Encrypt", "cached", "favorites", "to", "store", "on", "disk", "." ]

[ "func", "(", "c", "KbfsClient", ")", "DecryptFavorites", "(", "ctx", "context", ".", "Context", ",", "dataToEncrypt", "[", "]", "byte", ")", "(", "res", "[", "]", "byte", ",", "err", "error", ")", "{", "__arg", ":=", "DecryptFavoritesArg", "{", "DataToEncrypt", ":", "dataToEncrypt", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Decrypt", "cached", "favorites", "stored", "on", "disk", "." ]

[ "func", "Encode", "(", "data", "[", "]", "byte", ")", "(", "*", "Encodings", ",", "error", ")", "{", "code", ",", "err", ":=", "qr", ".", "Encode", "(", "string", "(", "data", ")", ",", "qr", ".", "L", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "result", "Encodings", "\n", "result", ".", "PNG", "=", "code", ".", "PNG", "(", ")", "\n", "result", ".", "Terminal", "=", "terminal", "(", "code", ")", "\n", "result", ".", "ASCII", "=", "ascii", "(", "code", ")", "\n\n", "return", "&", "result", ",", "nil", "\n", "}" ]

[ "Encode", "makes", "a", "QR", "code", "out", "of", "data", "and", "encodes", "it", "into", "three", "different", "representations", "." ]

[ "func", "(", "brw", "*", "blockRetrievalWorker", ")", "run", "(", ")", "{", "defer", "close", "(", "brw", ".", "doneCh", ")", "\n", "for", "{", "err", ":=", "brw", ".", "HandleRequest", "(", ")", "\n", "// Only io.EOF is relevant to the loop; other errors are handled in", "// FinalizeRequest", "if", "err", "==", "io", ".", "EOF", "{", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "run", "runs", "the", "worker", "loop", "until", "Shutdown", "is", "called" ]

[ "func", "newBlockRetrievalWorker", "(", "bg", "blockGetter", ",", "q", "*", "blockRetrievalQueue", ",", "workCh", "channels", ".", "Channel", ")", "*", "blockRetrievalWorker", "{", "brw", ":=", "&", "blockRetrievalWorker", "{", "blockGetter", ":", "bg", ",", "stopCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "doneCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "queue", ":", "q", ",", "workCh", ":", "workCh", ",", "}", "\n", "go", "brw", ".", "run", "(", ")", "\n", "return", "brw", "\n", "}" ]

[ "newBlockRetrievalWorker", "returns", "a", "blockRetrievalWorker", "for", "a", "given", "blockRetrievalQueue", "using", "the", "passed", "in", "blockGetter", "to", "obtain", "blocks", "for", "requests", "." ]

[ "func", "(", "brw", "*", "blockRetrievalWorker", ")", "HandleRequest", "(", ")", "(", "err", "error", ")", "{", "var", "retrieval", "*", "blockRetrieval", "\n", "select", "{", "case", "<-", "brw", ".", "workCh", ".", "Out", "(", ")", ":", "retrieval", "=", "brw", ".", "queue", ".", "popIfNotEmpty", "(", ")", "\n", "if", "retrieval", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "case", "<-", "brw", ".", "stopCh", ":", "return", "io", ".", "EOF", "\n", "}", "\n\n", "var", "block", "data", ".", "Block", "\n", "var", "cacheType", "DiskBlockCacheType", "\n", "defer", "func", "(", ")", "{", "brw", ".", "queue", ".", "FinalizeRequest", "(", "retrieval", ",", "block", ",", "cacheType", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "// Handle canceled contexts.", "select", "{", "case", "<-", "retrieval", ".", "ctx", ".", "Done", "(", ")", ":", "return", "retrieval", ".", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n\n", "var", "action", "BlockRequestAction", "\n", "func", "(", ")", "{", "retrieval", ".", "reqMtx", ".", "RLock", "(", ")", "\n", "defer", "retrieval", ".", "reqMtx", ".", "RUnlock", "(", ")", "\n", "block", "=", "retrieval", ".", "requests", "[", "0", "]", ".", "block", ".", "NewEmpty", "(", ")", "\n", "action", "=", "retrieval", ".", "action", "\n", "}", "(", ")", "\n\n", "// If we running with a \"stop-if-full\" action, before we fetch the", "// block, make sure the disk cache has room for it.", "if", "action", ".", "StopIfFull", "(", ")", "{", "dbc", ":=", "brw", ".", "queue", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "!=", "nil", "{", "hasRoom", ",", "err", ":=", "dbc", ".", "DoesCacheHaveSpace", "(", "retrieval", ".", "ctx", ",", "action", ".", "CacheType", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "hasRoom", "{", "return", "DiskCacheTooFullForBlockError", "{", "retrieval", ".", "blockPtr", ",", "action", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "cacheType", "=", "action", ".", "CacheType", "(", ")", "\n", "if", "action", ".", "DelayCacheCheck", "(", ")", "{", "_", ",", "err", ":=", "brw", ".", "queue", ".", "checkCaches", "(", "retrieval", ".", "ctx", ",", "retrieval", ".", "kmd", ",", "retrieval", ".", "blockPtr", ",", "block", ",", "action", ".", "WithoutDelayedCacheCheckAction", "(", ")", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "}", "\n\n", "return", "brw", ".", "getBlock", "(", "retrieval", ".", "ctx", ",", "retrieval", ".", "kmd", ",", "retrieval", ".", "blockPtr", ",", "block", ",", "cacheType", ")", "\n", "}" ]

[ "HandleRequest", "is", "the", "main", "work", "method", "for", "the", "worker", ".", "It", "obtains", "a", "blockRetrieval", "from", "the", "queue", "retrieves", "the", "block", "using", "blockGetter", ".", "getBlock", "and", "responds", "to", "the", "subscribed", "requestors", "with", "the", "results", "." ]

[ "func", "(", "brw", "*", "blockRetrievalWorker", ")", "Shutdown", "(", ")", "<-", "chan", "struct", "{", "}", "{", "select", "{", "case", "<-", "brw", ".", "stopCh", ":", "default", ":", "close", "(", "brw", ".", "stopCh", ")", "\n", "}", "\n", "return", "brw", ".", "doneCh", "\n", "}" ]

[ "Shutdown", "shuts", "down", "the", "blockRetrievalWorker", "once", "its", "current", "work", "is", "done", "." ]

[ "func", "NewStathatReporter", "(", "logger", "*", "zap", ".", "Logger", ",", "prefix", "string", ",", "ezKey", "string", ",", "enableActivityBasedStats", "*", "ActivityStatsEnabler", ")", "StatsReporter", "{", "if", "len", "(", "ezKey", ")", "==", "0", "{", "return", "&", "stathatReporter", "{", "}", "\n", "}", "\n\n", "enabler", ":=", "enableActivityBasedStats", "\n", "if", "enabler", "==", "nil", "{", "enabler", "=", "&", "ActivityStatsEnabler", "{", "Storer", ":", "nullActivityStatsStorer", "{", "}", ",", "Durations", ":", "nil", ",", "}", "\n", "}", "\n\n", "prefix", "=", "strings", ".", "TrimSpace", "(", "prefix", ")", "+", "\"", "\"", "\n", "reporter", ":=", "&", "stathatReporter", "{", "logger", ":", "logger", ",", "ezKey", ":", "ezKey", ",", "reporter", ":", "stathat", ".", "NewBatchReporter", "(", "stathat", ".", "DefaultReporter", ",", "stathatReportInterval", ")", ",", "statNameRequests", ":", "prefix", "+", "\"", "\"", ",", "statNameAuthenticated", ":", "prefix", "+", "\"", "\"", ",", "statNameCloningShown", ":", "prefix", "+", "\"", "\"", ",", "statNameInvalidConfig", ":", "prefix", "+", "\"", "\"", ",", "statPrefixProto", ":", "prefix", "+", "\"", "\"", ",", "statPrefixStatus", ":", "prefix", "+", "\"", "\"", ",", "statPrefixTlfType", ":", "prefix", "+", "\"", "\"", ",", "statPrefixRootType", ":", "prefix", "+", "\"", "\"", ",", "activityStats", ":", "*", "enabler", ",", "statPrefixActiveHosts", ":", "prefix", "+", "\"", "\"", ",", "statPrefixActiveTlfs", ":", "prefix", "+", "\"", "\"", ",", "}", "\n", "go", "reporter", ".", "activityStatsReportLoop", "(", ")", "\n", "return", "reporter", "\n", "}" ]

[ "NewStathatReporter", "create", "a", "new", "StatsReporter", "that", "reports", "stats", "to", "stathat", ".", "If", "enableActivityBasedStats", "if", "set", "to", "non", "-", "nil", "causes", "the", "reporter", "to", "generate", "activity", "-", "based", "stats", ".", "Caller", "should", "not", "modify", "enableActivityBasedStats", "passed", "into", "this", "function", "." ]

[ "func", "(", "s", "*", "stathatReporter", ")", "ReportServedRequest", "(", "sri", "*", "ServedRequestInfo", ")", "{", "s", ".", "postCountOneOrLog", "(", "s", ".", "statNameRequests", ")", "\n", "s", ".", "postCountOneOrLog", "(", "s", ".", "statPrefixProto", "+", "sri", ".", "Proto", ")", "\n", "s", ".", "postCountOneOrLog", "(", "s", ".", "statPrefixStatus", "+", "strconv", ".", "Itoa", "(", "sri", ".", "HTTPStatus", ")", ")", "\n", "if", "sri", ".", "Authenticated", "{", "s", ".", "postCountOneOrLog", "(", "s", ".", "statNameAuthenticated", ")", "\n", "}", "\n", "if", "sri", ".", "CloningShown", "{", "s", ".", "postCountOneOrLog", "(", "s", ".", "statNameCloningShown", ")", "\n", "}", "\n", "if", "sri", ".", "InvalidConfig", "{", "s", ".", "postCountOneOrLog", "(", "s", ".", "statNameInvalidConfig", ")", "\n", "}", "\n", "s", ".", "postCountOneOrLog", "(", "s", ".", "statPrefixTlfType", "+", "sri", ".", "TlfType", ".", "String", "(", ")", ")", "\n", "s", ".", "postCountOneOrLog", "(", "s", ".", "statPrefixRootType", "+", "sri", ".", "RootType", ".", "String", "(", ")", ")", "\n\n", "s", ".", "activityStats", ".", "Storer", ".", "RecordActives", "(", "sri", ".", "TlfID", ",", "sri", ".", "Host", ")", "\n", "}" ]

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

[ "func", "StaticSizeOfMapWithSize", "(", "keyStaticSize", ",", "valueStaticSize", "int", ",", "count", "int", ")", "(", "bytes", "int", ")", "{", "keySize", ":=", "mapKeyOrValueSizeWithIndirectPointerOverhead", "(", "keyStaticSize", ")", "\n", "valueSize", ":=", "mapKeyOrValueSizeWithIndirectPointerOverhead", "(", "valueStaticSize", ")", "\n\n", "// See the comment of `B` field of `hmap` struct above.", "B", ":=", "math", ".", "Ceil", "(", "math", ".", "Log2", "(", "float64", "(", "count", ")", "/", "mapLoadFactor", ")", ")", "\n", "numBuckets", ":=", "int", "(", "math", ".", "Exp2", "(", "B", ")", ")", "\n\n", "return", "hmapStructSize", "+", "bucketSizeWithoutIndirectPointerOverhead", "*", "numBuckets", "+", "(", "keySize", "+", "valueSize", ")", "*", "count", "\n", "}" ]

[ "StaticSizeOfMapWithSize", "is", "a", "slightly", "more", "efficient", "version", "of", "StaticSizeOfMap", "for", "when", "the", "caller", "knows", "the", "static", "size", "of", "key", "and", "value", "without", "having", "to", "use", "reflect", "." ]

[ "func", "(", "acl", "*", "ACL", ")", "AddAllowAccess", "(", "accessMask", "uint32", ",", "sid", "*", "SID", ")", "{", "acl", ".", "initIfEmpty", "(", ")", "\n", "ssize", ":=", "sidSize", "(", "sid", ")", "\n", "var", "bs", "[", "8", "]", "byte", "\n", "// ACLs are little endian...", "binary", ".", "LittleEndian", ".", "PutUint16", "(", "bs", "[", "2", ":", "]", ",", "uint16", "(", "8", "+", "align4up", "(", "uint32", "(", "sidSize", "(", "sid", ")", ")", ")", ")", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "bs", "[", "4", ":", "]", ",", "accessMask", ")", "\n", "acl", ".", "raw", "=", "append", "(", "acl", ".", "raw", ",", "bs", "[", ":", "]", "...", ")", "\n", "acl", ".", "raw", "=", "append", "(", "acl", ".", "raw", ",", "bufToSlice", "(", "unsafe", ".", "Pointer", "(", "sid", ")", ",", "ssize", ")", "...", ")", "\n", "for", "len", "(", "acl", ".", "raw", ")", "&", "3", "!=", "0", "{", "acl", ".", "raw", "=", "append", "(", "acl", ".", "raw", ",", "0", ")", "\n", "}", "\n", "acl", ".", "aceCount", "++", "\n", "}" ]

[ "AddAllowAccess", "add", "a", "new", "ALLOW_ACCESS", "ACE", "to", "the", "ACL", "." ]

[ "func", "NewParamProofStoreAndInstall", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "libkb", ".", "MerkleStore", "{", "supportedVersion", ":=", "keybase1", ".", "MerkleStoreSupportedVersion", "(", "SupportedVersion", ")", "\n", "tag", ":=", "\"", "\"", "\n", "endpoint", ":=", "\"", "\"", "\n", "getHash", ":=", "func", "(", "root", "libkb", ".", "MerkleRoot", ")", "string", "{", "return", "root", ".", "ProofServicesHash", "(", ")", "\n", "}", "\n", "kitFilename", ":=", "g", ".", "Env", ".", "GetParamProofKitFilename", "(", ")", "\n", "s", ":=", "merklestore", ".", "NewMerkleStore", "(", "g", ",", "tag", ",", "endpoint", ",", "kitFilename", ",", "supportedVersion", ",", "getHash", ")", "\n", "g", ".", "SetParamProofStore", "(", "s", ")", "\n", "return", "s", "\n", "}" ]

[ "NewParamProofStore", "creates", "a", "new", "source", "and", "installs", "it", "into", "G", "." ]

[ "func", "(", "b", "*", "Badger", ")", "Send", "(", "ctx", "context", ".", "Context", ")", "error", "{", "state", ",", "err", ":=", "b", ".", "badgeState", ".", "Export", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "b", ".", "log", "(", "ctx", ",", "state", ")", "\n", "b", ".", "notifyCh", "<-", "state", "\n", "return", "nil", "\n", "}" ]

[ "Send", "the", "badgestate", "to", "electron" ]

[ "func", "(", "b", "*", "Badger", ")", "log", "(", "ctx", "context", ".", "Context", ",", "state1", "keybase1", ".", "BadgeState", ")", "{", "var", "state2", "keybase1", ".", "BadgeState", "\n", "state2", "=", "state1", "\n", "state2", ".", "Conversations", "=", "nil", "\n", "for", "_", ",", "c1", ":=", "range", "state1", ".", "Conversations", "{", "if", "c1", ".", "UnreadMessages", "==", "0", "{", "continue", "\n", "}", "\n", "c2id", ":=", "c1", ".", "ConvID", "\n", "if", "len", "(", "c1", ".", "ConvID", ")", ">=", "chat1", ".", "DbShortFormLen", "{", "// This is the db short form for logging brevity only.", "// Don't let this leave this method.", "c2id", "=", "chat1", ".", "ConversationID", "(", "[", "]", "byte", "(", "c1", ".", "ConvID", ")", ")", ".", "DbShortForm", "(", ")", "\n", "}", "\n\n", "c2", ":=", "keybase1", ".", "BadgeConversationInfo", "{", "ConvID", ":", "c2id", ",", "UnreadMessages", ":", "c1", ".", "UnreadMessages", ",", "BadgeCounts", ":", "c1", ".", "BadgeCounts", ",", "}", "\n", "state2", ".", "Conversations", "=", "append", "(", "state2", ".", "Conversations", ",", "c2", ")", "\n", "}", "\n", "b", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "state2", ")", "\n", "}" ]

[ "Log", "a", "copy", "of", "the", "badgestate", "with", "some", "zeros", "stripped", "off", "for", "brevity", "." ]

[ "func", "canExec", "(", "s", "string", ")", "error", "{", "if", "strings", ".", "IndexAny", "(", "s", ",", "`:\\/`", ")", "==", "-", "1", "{", "s", "+=", "string", "(", "filepath", ".", "Separator", ")", "\n", "}", "\n", "_", ",", "err", ":=", "exec", ".", "LookPath", "(", "s", ")", "\n", "return", "err", "\n", "}" ]

[ "LookPath", "searches", "for", "an", "executable", "binary", "named", "file", "in", "the", "directories", "named", "by", "the", "PATH", "environment", "variable", ".", "If", "file", "contains", "a", "slash", "it", "is", "tried", "directly", "and", "the", "PATH", "is", "not", "consulted", "." ]

[ "func", "GetEncodedUserEditHistory", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ")", "(", "data", "[", "]", "byte", ",", "t", "time", ".", "Time", ",", "err", "error", ")", "{", "session", ",", "err", ":=", "idutil", ".", "GetCurrentSessionIfPossible", "(", "ctx", ",", "config", ".", "KBPKI", "(", ")", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n\n", "edits", ":=", "config", ".", "UserHistory", "(", ")", ".", "Get", "(", "string", "(", "session", ".", "Name", ")", ")", "\n", "data", ",", "err", "=", "PrettyJSON", "(", "edits", ")", "\n", "return", "data", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}" ]

[ "GetEncodedUserEditHistory", "returns", "serialized", "JSON", "containing", "the", "file", "edit", "history", "for", "the", "user", "." ]

[ "func", "NewMDServerRemote", "(", "config", "Config", ",", "srvRemote", "rpc", ".", "Remote", ",", "rpcLogFactory", "rpc", ".", "LogFactory", ")", "*", "MDServerRemote", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "deferLog", ":=", "log", ".", "CloneWithAddedDepth", "(", "1", ")", "\n", "mdServer", ":=", "&", "MDServerRemote", "{", "config", ":", "config", ",", "observers", ":", "make", "(", "map", "[", "tlf", ".", "ID", "]", "chan", "<-", "error", ")", ",", "log", ":", "traceLogger", "{", "log", "}", ",", "deferLog", ":", "traceLogger", "{", "deferLog", "}", ",", "mdSrvRemote", ":", "srvRemote", ",", "rpcLogFactory", ":", "rpcLogFactory", ",", "rekeyTimer", ":", "time", ".", "NewTimer", "(", "nextRekeyTime", "(", ")", ")", ",", "}", "\n\n", "mdServer", ".", "pinger", "=", "pinger", "{", "name", ":", "\"", "\"", ",", "doPing", ":", "mdServer", ".", "pingOnce", ",", "timeout", ":", "MdServerPingTimeout", ",", "log", ":", "mdServer", ".", "log", ",", "}", "\n\n", "mdServer", ".", "authToken", "=", "kbfscrypto", ".", "NewAuthToken", "(", "config", ".", "Crypto", "(", ")", ",", "kbfsmd", ".", "ServerTokenServer", ",", "kbfsmd", ".", "ServerTokenExpireIn", ",", "\"", "\"", ",", "VersionString", "(", ")", ",", "mdServer", ")", "\n", "constBackoff", ":=", "backoff", ".", "NewConstantBackOff", "(", "RPCReconnectInterval", ")", "\n", "mdServer", ".", "connOpts", "=", "rpc", ".", "ConnectionOpts", "{", "WrapErrorFunc", ":", "libkb", ".", "WrapError", ",", "TagsFunc", ":", "libkb", ".", "LogTagsFromContext", ",", "ReconnectBackoff", ":", "func", "(", ")", "backoff", ".", "BackOff", "{", "return", "constBackoff", "}", ",", "DialerTimeout", ":", "dialerTimeout", ",", "InitialReconnectBackoffWindow", ":", "func", "(", ")", "time", ".", "Duration", "{", "return", "mdserverReconnectBackoffWindow", "}", ",", "}", "\n", "mdServer", ".", "initNewConnection", "(", ")", "\n\n", "// Check for rekey opportunities periodically.", "rekeyCtx", ",", "rekeyCancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "mdServer", ".", "rekeyCancel", "=", "rekeyCancel", "\n", "if", "config", ".", "Mode", "(", ")", ".", "RekeyWorkers", "(", ")", ">", "0", "{", "go", "mdServer", ".", "backgroundRekeyChecker", "(", "rekeyCtx", ")", "\n", "}", "\n\n", "return", "mdServer", "\n", "}" ]

[ "NewMDServerRemote", "returns", "a", "new", "instance", "of", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "resetAuth", "(", "ctx", "context", ".", "Context", ",", "c", "keybase1", ".", "MetadataClient", ")", "(", "int", ",", "error", ")", "{", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "ctxMDServerResetKey", ",", "\"", "\"", ")", "\n\n", "isAuthenticated", ":=", "false", "\n", "defer", "func", "(", ")", "{", "md", ".", "setIsAuthenticated", "(", "isAuthenticated", ")", "\n", "}", "(", ")", "\n\n", "session", ",", "err", ":=", "md", ".", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "md", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "MdServerDefaultPingIntervalSeconds", ",", "err", "\n", "}", "\n\n", "challenge", ",", "err", ":=", "c", ".", "GetChallenge", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "md", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "0", ",", "err", "\n", "}", "\n", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "// get a new signature", "signature", ",", "err", ":=", "md", ".", "authToken", ".", "Sign", "(", "ctx", ",", "session", ".", "Name", ",", "session", ".", "UID", ",", "session", ".", "VerifyingKey", ",", "challenge", ")", "\n", "if", "err", "!=", "nil", "{", "md", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "0", ",", "err", "\n", "}", "\n", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "// authenticate", "pingIntervalSeconds", ",", "err", ":=", "c", ".", "Authenticate", "(", "ctx", ",", "signature", ")", "\n", "if", "err", "!=", "nil", "{", "md", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "0", ",", "err", "\n", "}", "\n", "md", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", ",", "pingIntervalSeconds", ")", "\n\n", "isAuthenticated", "=", "true", "\n\n", "md", ".", "authenticatedMtx", ".", "Lock", "(", ")", "\n", "if", "!", "md", ".", "isAuthenticated", "&&", "md", ".", "config", ".", "Mode", "(", ")", ".", "RekeyWorkers", "(", ")", ">", "0", "{", "defer", "func", "(", ")", "{", "// request a list of folders needing rekey action", "if", "err", ":=", "md", ".", "getFoldersForRekey", "(", "ctx", ",", "c", ")", ";", "err", "!=", "nil", "{", "md", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "md", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "(", ")", "\n", "}", "\n", "// Need to ensure that any conflicting thread gets the updated value", "md", ".", "isAuthenticated", "=", "true", "\n", "md", ".", "authenticatedMtx", ".", "Unlock", "(", ")", "\n\n", "return", "pingIntervalSeconds", ",", "nil", "\n", "}" ]

[ "resetAuth", "is", "called", "to", "reset", "the", "authorization", "on", "an", "MDServer", "connection", ".", "If", "this", "function", "returns", "idutil", ".", "NoCurrentSessionError", "the", "caller", "should", "treat", "this", "as", "a", "logged", "-", "out", "user", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "CheckReachability", "(", "ctx", "context", ".", "Context", ")", "{", "conn", ",", "err", ":=", "net", ".", "DialTimeout", "(", "\"", "\"", ",", "// The peeked address is the top choice in most cases.", "md", ".", "mdSrvRemote", ".", "Peek", "(", ")", ",", "MdServerPingTimeout", ")", "\n", "if", "err", "!=", "nil", "{", "if", "md", ".", "getIsAuthenticated", "(", ")", "{", "md", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "if", "err", "=", "md", ".", "reconnect", "(", ")", ";", "err", "!=", "nil", "{", "md", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "md", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "conn", "!=", "nil", "{", "conn", ".", "Close", "(", ")", "\n", "}", "\n", "}" ]

[ "CheckReachability", "implements", "the", "MDServer", "interface", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "cancelObservers", "(", ")", "{", "md", ".", "observerMu", ".", "Lock", "(", ")", "\n", "defer", "md", ".", "observerMu", ".", "Unlock", "(", ")", "\n", "// fire errors for any registered observers", "for", "id", ",", "observerChan", ":=", "range", "md", ".", "observers", "{", "md", ".", "signalObserverLocked", "(", "observerChan", ",", "id", ",", "MDServerDisconnected", "{", "}", ")", "\n", "}", "\n", "}" ]

[ "Signal", "errors", "and", "clear", "any", "registered", "observers", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "CancelRegistration", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ")", "{", "md", ".", "observerMu", ".", "Lock", "(", ")", "\n", "defer", "md", ".", "observerMu", ".", "Unlock", "(", ")", "\n", "observerChan", ",", "ok", ":=", "md", ".", "observers", "[", "id", "]", "\n", "if", "!", "ok", "{", "// not registered", "return", "\n", "}", "\n\n", "// signal that we've seen the update", "md", ".", "signalObserverLocked", "(", "observerChan", ",", "id", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "// Setting nil here indicates that the remote MD server thinks", "// we're still registered, though locally no one is listening.", "md", ".", "observers", "[", "id", "]", "=", "nil", "\n", "}" ]

[ "CancelRegistration", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "signalObserverLocked", "(", "observerChan", "chan", "<-", "error", ",", "id", "tlf", ".", "ID", ",", "err", "error", ")", "{", "if", "observerChan", "!=", "nil", "{", "observerChan", "<-", "err", "\n", "close", "(", "observerChan", ")", "\n", "}", "\n", "delete", "(", "md", ".", "observers", ",", "id", ")", "\n", "}" ]

[ "Signal", "an", "observer", ".", "The", "observer", "lock", "must", "be", "held", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "get", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "GetMetadataArg", ")", "(", "tlfID", "tlf", ".", "ID", ",", "rmdses", "[", "]", "*", "RootMetadataSigned", ",", "err", "error", ")", "{", "// request", "response", ",", "err", ":=", "md", ".", "getClient", "(", ")", ".", "GetMetadata", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "ID", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n\n", "// response", "tlfID", ",", "err", "=", "tlf", ".", "ParseID", "(", "response", ".", "FolderID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "ID", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n\n", "// deserialize blocks", "rmdses", "=", "make", "(", "[", "]", "*", "RootMetadataSigned", ",", "len", "(", "response", ".", "MdBlocks", ")", ")", "\n", "diskMDCache", ":=", "md", ".", "config", ".", "DiskMDCache", "(", ")", "\n", "for", "i", ",", "block", ":=", "range", "response", ".", "MdBlocks", "{", "ver", ",", "max", ":=", "kbfsmd", ".", "MetadataVer", "(", "block", ".", "Version", ")", ",", "md", ".", "config", ".", "MetadataVersion", "(", ")", "\n", "timestamp", ":=", "keybase1", ".", "FromTime", "(", "block", ".", "Timestamp", ")", "\n", "rmds", ",", "err", ":=", "DecodeRootMetadataSigned", "(", "md", ".", "config", ".", "Codec", "(", ")", ",", "tlfID", ",", "ver", ",", "max", ",", "block", ".", "Block", ",", "keybase1", ".", "FromTime", "(", "block", ".", "Timestamp", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "ID", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "rmdses", "[", "i", "]", "=", "rmds", "\n", "if", "diskMDCache", "!=", "nil", "&&", "rmds", ".", "MD", ".", "MergedStatus", "(", ")", "==", "kbfsmd", ".", "Merged", "{", "err", "=", "diskMDCache", ".", "Stage", "(", "ctx", ",", "tlfID", ",", "rmds", ".", "MD", ".", "RevisionNumber", "(", ")", ",", "block", ".", "Block", ",", "ver", ",", "timestamp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "ID", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "tlfID", ",", "rmdses", ",", "nil", "\n", "}" ]

[ "Helper", "used", "to", "retrieve", "metadata", "blocks", "from", "the", "MD", "server", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "GetForHandle", "(", "ctx", "context", ".", "Context", ",", "handle", "tlf", ".", "Handle", ",", "mStatus", "kbfsmd", ".", "MergeStatus", ",", "lockBeforeGet", "*", "keybase1", ".", "LockID", ")", "(", "tlfID", "tlf", ".", "ID", ",", "rmds", "*", "RootMetadataSigned", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "// TODO: Ideally, *tlf.Handle would have a nicer String() function.", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "handle", ",", "mStatus", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "handle", ",", "mStatus", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "encodedHandle", ",", "err", ":=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "handle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "ID", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "// kbfsmd.BranchID needs to be present when Unmerged is true;", "// kbfsmd.NullBranchID signals that the folder's current branch ID", "// should be looked up.", "arg", ":=", "keybase1", ".", "GetMetadataArg", "{", "FolderHandle", ":", "encodedHandle", ",", "BranchID", ":", "kbfsmd", ".", "NullBranchID", ".", "String", "(", ")", ",", "Unmerged", ":", "mStatus", "==", "kbfsmd", ".", "Unmerged", ",", "LockBeforeGet", ":", "lockBeforeGet", ",", "}", "\n\n", "id", ",", "rmdses", ",", "err", ":=", "md", ".", "get", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "ID", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "rmdses", ")", "==", "0", "{", "return", "id", ",", "nil", ",", "nil", "\n", "}", "\n", "// TODO: Error if server returns more than one rmds.", "return", "id", ",", "rmdses", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "GetForHandle", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "GetForTLF", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ",", "mStatus", "kbfsmd", ".", "MergeStatus", ",", "lockBeforeGet", "*", "keybase1", ".", "LockID", ")", "(", "rmds", "*", "RootMetadataSigned", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "bid", ",", "mStatus", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "bid", ",", "mStatus", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "var", "cachedRmds", "*", "RootMetadataSigned", "\n", "getCtx", ":=", "ctx", "\n", "if", "mStatus", "==", "kbfsmd", ".", "Merged", "&&", "lockBeforeGet", "==", "nil", "{", "cachedRmds", ",", "err", "=", "md", ".", "getLatestFromCache", "(", "ctx", ",", "id", ")", "\n", "if", "err", "==", "nil", "&&", "cachedRmds", "!=", "nil", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "cachedRmds", ".", "MD", ".", "RevisionNumber", "(", ")", ",", "id", ")", "\n", "var", "cancel", "context", ".", "CancelFunc", "\n", "getCtx", ",", "cancel", "=", "context", ".", "WithTimeout", "(", "ctx", ",", "mdServerTimeoutWhenMDCached", ")", "\n", "defer", "cancel", "(", ")", "\n", "}", "\n", "}", "\n\n", "arg", ":=", "keybase1", ".", "GetMetadataArg", "{", "FolderID", ":", "id", ".", "String", "(", ")", ",", "BranchID", ":", "bid", ".", "String", "(", ")", ",", "Unmerged", ":", "mStatus", "==", "kbfsmd", ".", "Unmerged", ",", "LockBeforeGet", ":", "lockBeforeGet", ",", "}", "\n\n", "_", ",", "rmdses", ",", "err", ":=", "md", ".", "get", "(", "getCtx", ",", "arg", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", "{", "case", "nil", ":", "case", "context", ".", "DeadlineExceeded", ":", "if", "cachedRmds", "!=", "nil", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "cachedRmds", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "default", ":", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "rmdses", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "if", "cachedRmds", "!=", "nil", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "rmdses", "[", "0", "]", ".", "MD", ".", "RevisionNumber", "(", ")", ",", "id", ")", "\n", "}", "\n\n", "// TODO: Error if server returns more than one rmds.", "return", "rmdses", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "GetForTLF", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "GetForTLFByTime", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "serverTime", "time", ".", "Time", ")", "(", "rmds", "*", "RootMetadataSigned", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "serverTime", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "serverTime", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "arg", ":=", "keybase1", ".", "GetMetadataByTimestampArg", "{", "FolderID", ":", "id", ".", "String", "(", ")", ",", "ServerTime", ":", "keybase1", ".", "ToTime", "(", "serverTime", ")", ",", "}", "\n\n", "block", ",", "err", ":=", "md", ".", "getClient", "(", ")", ".", "GetMetadataByTimestamp", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "len", "(", "block", ".", "Block", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "serverTime", ")", "\n", "}", "\n\n", "ver", ",", "max", ":=", "kbfsmd", ".", "MetadataVer", "(", "block", ".", "Version", ")", ",", "md", ".", "config", ".", "MetadataVersion", "(", ")", "\n", "rmds", ",", "err", "=", "DecodeRootMetadataSigned", "(", "md", ".", "config", ".", "Codec", "(", ")", ",", "id", ",", "ver", ",", "max", ",", "block", ".", "Block", ",", "keybase1", ".", "FromTime", "(", "block", ".", "Timestamp", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "rmds", ",", "nil", "\n", "}" ]

[ "GetForTLFByTime", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "GetRange", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ",", "mStatus", "kbfsmd", ".", "MergeStatus", ",", "start", ",", "stop", "kbfsmd", ".", "Revision", ",", "lockBeforeGet", "*", "keybase1", ".", "LockID", ")", "(", "rmdses", "[", "]", "*", "RootMetadataSigned", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "bid", ",", "mStatus", ",", "start", ",", "stop", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "bid", ",", "mStatus", ",", "start", ",", "stop", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "arg", ":=", "keybase1", ".", "GetMetadataArg", "{", "FolderID", ":", "id", ".", "String", "(", ")", ",", "BranchID", ":", "bid", ".", "String", "(", ")", ",", "Unmerged", ":", "mStatus", "==", "kbfsmd", ".", "Unmerged", ",", "StartRevision", ":", "start", ".", "Number", "(", ")", ",", "StopRevision", ":", "stop", ".", "Number", "(", ")", ",", "LockBeforeGet", ":", "lockBeforeGet", ",", "}", "\n\n", "_", ",", "rmds", ",", "err", ":=", "md", ".", "get", "(", "ctx", ",", "arg", ")", "\n", "return", "rmds", ",", "err", "\n", "}" ]

[ "GetRange", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "Lock", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "lockID", "keybase1", ".", "LockID", ")", "error", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "lockID", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "lockID", ")", "\n", "}", "(", ")", "\n", "return", "md", ".", "getClient", "(", ")", ".", "Lock", "(", "ctx", ",", "keybase1", ".", "LockArg", "{", "FolderID", ":", "tlfID", ".", "String", "(", ")", ",", "LockID", ":", "lockID", ",", "}", ")", "\n", "}" ]

[ "Lock", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "PruneBranch", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ")", "(", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "bid", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "bid", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "arg", ":=", "keybase1", ".", "PruneBranchArg", "{", "FolderID", ":", "id", ".", "String", "(", ")", ",", "BranchID", ":", "bid", ".", "String", "(", ")", ",", "LogTags", ":", "nil", ",", "}", "\n", "return", "md", ".", "getClient", "(", ")", ".", "PruneBranch", "(", "ctx", ",", "arg", ")", "\n", "}" ]

[ "PruneBranch", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "MetadataUpdate", "(", "_", "context", ".", "Context", ",", "arg", "keybase1", ".", "MetadataUpdateArg", ")", "error", "{", "id", ",", "err", ":=", "tlf", ".", "ParseID", "(", "arg", ".", "FolderID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "md", ".", "observerMu", ".", "Lock", "(", ")", "\n", "defer", "md", ".", "observerMu", ".", "Unlock", "(", ")", "\n", "observerChan", ",", "ok", ":=", "md", ".", "observers", "[", "id", "]", "\n", "if", "!", "ok", "{", "// not registered", "return", "nil", "\n", "}", "\n\n", "// signal that we've seen the update", "md", ".", "signalObserverLocked", "(", "observerChan", ",", "id", ",", "nil", ")", "\n", "return", "nil", "\n", "}" ]

[ "MetadataUpdate", "implements", "the", "MetadataUpdateProtocol", "interface", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "FoldersNeedRekey", "(", "ctx", "context", ".", "Context", ",", "requests", "[", "]", "keybase1", ".", "RekeyRequest", ")", "error", "{", "if", "md", ".", "squelchRekey", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "for", "_", ",", "req", ":=", "range", "requests", "{", "id", ",", "err", ":=", "tlf", ".", "ParseID", "(", "req", ".", "FolderID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ".", "String", "(", ")", ")", "\n", "// queue the folder for rekeying", "md", ".", "config", ".", "RekeyQueue", "(", ")", ".", "Enqueue", "(", "id", ")", "\n", "}", "\n", "// Reset the timer in case there are a lot of rekey folders", "// dribbling in from the server still.", "md", ".", "resetRekeyTimer", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "FoldersNeedRekey", "implements", "the", "MetadataUpdateProtocol", "interface", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "FolderNeedsRekey", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "FolderNeedsRekeyArg", ")", "error", "{", "id", ",", "err", ":=", "tlf", ".", "ParseID", "(", "arg", ".", "FolderID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ".", "String", "(", ")", ")", "\n", "if", "md", ".", "squelchRekey", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "// queue the folder for rekeying", "md", ".", "config", ".", "RekeyQueue", "(", ")", ".", "Enqueue", "(", "id", ")", "\n", "// Reset the timer in case there are a lot of rekey folders", "// dribbling in from the server still.", "md", ".", "resetRekeyTimer", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "FolderNeedsRekey", "implements", "the", "MetadataUpdateProtocol", "interface", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "RegisterForUpdate", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "currHead", "kbfsmd", ".", "Revision", ")", "(", "<-", "chan", "error", ",", "error", ")", "{", "arg", ":=", "keybase1", ".", "RegisterForUpdatesArg", "{", "FolderID", ":", "id", ".", "String", "(", ")", ",", "CurrRevision", ":", "currHead", ".", "Number", "(", ")", ",", "LogTags", ":", "nil", ",", "}", "\n\n", "// register", "var", "c", "chan", "error", "\n", "conn", ":=", "md", ".", "getConn", "(", ")", "\n", "err", ":=", "conn", ".", "DoCommand", "(", "ctx", ",", "\"", "\"", ",", "func", "(", "rawClient", "rpc", ".", "GenericClient", ")", "error", "{", "// set up the server to receive updates, since we may", "// get disconnected between retries.", "server", ":=", "conn", ".", "GetServer", "(", ")", "\n", "err", ":=", "server", ".", "Register", "(", "keybase1", ".", "MetadataUpdateProtocol", "(", "md", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "rpc", ".", "AlreadyRegisteredError", ")", ";", "!", "ok", "{", "return", "err", "\n", "}", "\n", "}", "\n", "// TODO: Do something with server.Err() when server is", "// done?", "server", ".", "Run", "(", ")", "\n\n", "// keep re-adding the observer on retries, since", "// disconnects or connection errors clear observers.", "alreadyRegistered", ":=", "func", "(", ")", "bool", "{", "md", ".", "observerMu", ".", "Lock", "(", ")", "\n", "defer", "md", ".", "observerMu", ".", "Unlock", "(", ")", "\n", "// It's possible for a nil channel to be in", "// `md.observers`, if we are still registered with the", "// server after a previous cancellation.", "existingCh", ",", "alreadyRegistered", ":=", "md", ".", "observers", "[", "id", "]", "\n", "if", "existingCh", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ")", ")", "\n", "}", "\n", "c", "=", "make", "(", "chan", "error", ",", "1", ")", "\n", "md", ".", "observers", "[", "id", "]", "=", "c", "\n", "return", "alreadyRegistered", "\n", "}", "(", ")", "\n", "if", "alreadyRegistered", "{", "return", "nil", "\n", "}", "\n", "// Use this instead of md.client since we're already", "// inside a DoCommand().", "c", ":=", "keybase1", ".", "MetadataClient", "{", "Cli", ":", "rawClient", "}", "\n", "err", "=", "c", ".", "RegisterForUpdates", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "func", "(", ")", "{", "md", ".", "observerMu", ".", "Lock", "(", ")", "\n", "defer", "md", ".", "observerMu", ".", "Unlock", "(", ")", "\n", "// we could've been canceled by a shutdown so look this up", "// again before closing and deleting.", "if", "updateChan", ",", "ok", ":=", "md", ".", "observers", "[", "id", "]", ";", "ok", "{", "close", "(", "updateChan", ")", "\n", "delete", "(", "md", ".", "observers", ",", "id", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "return", "err", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "c", "=", "nil", "\n", "}", "\n\n", "return", "c", ",", "err", "\n", "}" ]

[ "RegisterForUpdate", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "OffsetFromServerTime", "(", ")", "(", "time", ".", "Duration", ",", "bool", ")", "{", "md", ".", "serverOffsetMu", ".", "RLock", "(", ")", "\n", "defer", "md", ".", "serverOffsetMu", ".", "RUnlock", "(", ")", "\n", "return", "md", ".", "serverOffset", ",", "md", ".", "serverOffsetKnown", "\n", "}" ]

[ "OffsetFromServerTime", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "getFoldersForRekey", "(", "ctx", "context", ".", "Context", ",", "client", "keybase1", ".", "MetadataClient", ")", "error", "{", "// get this device's crypt public key", "session", ",", "err", ":=", "md", ".", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "client", ".", "GetFoldersForRekey", "(", "ctx", ",", "session", ".", "CryptPublicKey", ".", "KID", "(", ")", ")", "\n", "}" ]

[ "getFoldersForRekey", "registers", "to", "receive", "updates", "about", "folders", "needing", "rekey", "actions", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "Shutdown", "(", ")", "{", "md", ".", "connMu", ".", "Lock", "(", ")", "\n", "defer", "md", ".", "connMu", ".", "Unlock", "(", ")", "\n\n", "// close the connection", "md", ".", "conn", ".", "Shutdown", "(", ")", "\n", "// cancel pending observers", "md", ".", "cancelObservers", "(", ")", "\n", "// cancel the ping ticker", "md", ".", "pinger", ".", "cancelTicker", "(", ")", "\n", "// cancel the auth token ticker", "if", "md", ".", "authToken", "!=", "nil", "{", "md", ".", "authToken", ".", "Shutdown", "(", ")", "\n", "}", "\n", "if", "md", ".", "rekeyCancel", "!=", "nil", "{", "md", ".", "rekeyCancel", "(", ")", "\n", "}", "\n", "}" ]

[ "Shutdown", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "IsConnected", "(", ")", "bool", "{", "conn", ":=", "md", ".", "getConn", "(", ")", "\n", "return", "conn", "!=", "nil", "&&", "conn", ".", "IsConnected", "(", ")", "\n", "}" ]

[ "IsConnected", "implements", "the", "MDServer", "interface", "for", "MDServerLocal" ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "GetTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ",", "cryptKey", "kbfscrypto", ".", "CryptPublicKey", ")", "(", "serverHalf", "kbfscrypto", ".", "TLFCryptKeyServerHalf", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "serverHalfID", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "serverHalfID", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "// encode the ID", "idBytes", ",", "err", ":=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "serverHalfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// get the key", "arg", ":=", "keybase1", ".", "GetKeyArg", "{", "KeyHalfID", ":", "idBytes", ",", "DeviceKID", ":", "cryptKey", ".", "KID", "(", ")", ".", "String", "(", ")", ",", "LogTags", ":", "nil", ",", "}", "\n", "keyBytes", ",", "err", ":=", "md", ".", "getClient", "(", ")", ".", "GetKey", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// decode the key", "err", "=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "keyBytes", ",", "&", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "The", "below", "methods", "support", "the", "MD", "server", "acting", "as", "the", "key", "server", ".", "This", "will", "be", "the", "case", "for", "v1", "of", "KBFS", "but", "we", "may", "move", "to", "our", "own", "separate", "key", "server", "at", "some", "point", ".", "GetTLFCryptKeyServerHalf", "is", "an", "implementation", "of", "the", "KeyServer", "interface", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "PutTLFCryptKeyServerHalves", "(", "ctx", "context", ".", "Context", ",", "keyServerHalves", "kbfsmd", ".", "UserDeviceKeyServerHalves", ")", "(", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "keyServerHalves", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "keyServerHalves", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "// flatten out the map into an array", "var", "keyHalves", "[", "]", "keybase1", ".", "KeyHalf", "\n", "for", "user", ",", "deviceMap", ":=", "range", "keyServerHalves", "{", "for", "devicePubKey", ",", "serverHalf", ":=", "range", "deviceMap", "{", "keyHalf", ",", "err", ":=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "keyHalves", "=", "append", "(", "keyHalves", ",", "keybase1", ".", "KeyHalf", "{", "User", ":", "user", ",", "DeviceKID", ":", "devicePubKey", ".", "KID", "(", ")", ",", "Key", ":", "keyHalf", ",", "}", ")", "\n", "}", "\n", "}", "\n", "// put the keys", "arg", ":=", "keybase1", ".", "PutKeysArg", "{", "KeyHalves", ":", "keyHalves", ",", "LogTags", ":", "nil", ",", "}", "\n", "return", "md", ".", "getClient", "(", ")", ".", "PutKeys", "(", "ctx", ",", "arg", ")", "\n", "}" ]

[ "PutTLFCryptKeyServerHalves", "is", "an", "implementation", "of", "the", "KeyServer", "interface", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "DeleteTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ")", "(", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "uid", ",", "serverHalfID", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "uid", ",", "serverHalfID", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "// encode the ID", "idBytes", ",", "err", ":=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "serverHalfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// get the key", "arg", ":=", "keybase1", ".", "DeleteKeyArg", "{", "Uid", ":", "uid", ",", "DeviceKID", ":", "key", ".", "KID", "(", ")", ",", "KeyHalfID", ":", "idBytes", ",", "LogTags", ":", "nil", ",", "}", "\n", "err", "=", "md", ".", "getClient", "(", ")", ".", "DeleteKey", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteTLFCryptKeyServerHalf", "is", "an", "implementation", "of", "the", "KeyServer", "interface", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "GetKeyBundles", "(", "ctx", "context", ".", "Context", ",", "tlf", "tlf", ".", "ID", ",", "wkbID", "kbfsmd", ".", "TLFWriterKeyBundleID", ",", "rkbID", "kbfsmd", ".", "TLFReaderKeyBundleID", ")", "(", "wkb", "*", "kbfsmd", ".", "TLFWriterKeyBundleV3", ",", "rkb", "*", "kbfsmd", ".", "TLFReaderKeyBundleV3", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "tlf", ",", "wkbID", ",", "rkbID", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "tlf", ",", "wkbID", ",", "rkbID", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "arg", ":=", "keybase1", ".", "GetKeyBundlesArg", "{", "FolderID", ":", "tlf", ".", "String", "(", ")", ",", "WriterBundleID", ":", "wkbID", ".", "String", "(", ")", ",", "ReaderBundleID", ":", "rkbID", ".", "String", "(", ")", ",", "}", "\n\n", "response", ",", "err", ":=", "md", ".", "getClient", "(", ")", ".", "GetKeyBundles", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "if", "response", ".", "WriterBundle", ".", "Bundle", "!=", "nil", "{", "if", "response", ".", "WriterBundle", ".", "Version", "!=", "int", "(", "kbfsmd", ".", "SegregatedKeyBundlesVer", ")", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "response", ".", "WriterBundle", ".", "Version", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "wkb", "=", "new", "(", "kbfsmd", ".", "TLFWriterKeyBundleV3", ")", "\n", "err", "=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "response", ".", "WriterBundle", ".", "Bundle", ",", "wkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "// Verify it's what we expect.", "bundleID", ",", "err", ":=", "kbfsmd", ".", "MakeTLFWriterKeyBundleID", "(", "md", ".", "config", ".", "Codec", "(", ")", ",", "*", "wkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "if", "bundleID", "!=", "wkbID", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "wkbID", ",", "bundleID", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "if", "response", ".", "ReaderBundle", ".", "Bundle", "!=", "nil", "{", "if", "response", ".", "ReaderBundle", ".", "Version", "!=", "int", "(", "kbfsmd", ".", "SegregatedKeyBundlesVer", ")", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "response", ".", "ReaderBundle", ".", "Version", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "rkb", "=", "new", "(", "kbfsmd", ".", "TLFReaderKeyBundleV3", ")", "\n", "err", "=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "response", ".", "ReaderBundle", ".", "Bundle", ",", "rkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "// Verify it's what we expect.", "bundleID", ",", "err", ":=", "kbfsmd", ".", "MakeTLFReaderKeyBundleID", "(", "md", ".", "config", ".", "Codec", "(", ")", ",", "*", "rkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "if", "bundleID", "!=", "rkbID", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rkbID", ",", "bundleID", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "wkb", ",", "rkb", ",", "nil", "\n", "}" ]

[ "GetKeyBundles", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "FastForwardBackoff", "(", ")", "{", "md", ".", "connMu", ".", "RLock", "(", ")", "\n", "defer", "md", ".", "connMu", ".", "RUnlock", "(", ")", "\n", "md", ".", "conn", ".", "FastForwardInitialBackoffTimer", "(", ")", "\n", "}" ]

[ "FastForwardBackoff", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "(", "md", "*", "MDServerRemote", ")", "FindNextMD", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "rootSeqno", "keybase1", ".", "Seqno", ")", "(", "nextKbfsRoot", "*", "kbfsmd", ".", "MerkleRoot", ",", "nextMerkleNodes", "[", "]", "[", "]", "byte", ",", "nextRootSeqno", "keybase1", ".", "Seqno", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "md", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "rootSeqno", ")", "\n", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "rootSeqno", ")", "\n", "defer", "func", "(", ")", "{", "md", ".", "deferLog", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "rootSeqno", ",", "err", ")", "\n", "md", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "rootSeqno", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "arg", ":=", "keybase1", ".", "FindNextMDArg", "{", "FolderID", ":", "tlfID", ".", "String", "(", ")", ",", "Seqno", ":", "rootSeqno", ",", "}", "\n\n", "response", ",", "err", ":=", "md", ".", "getClient", "(", ")", ".", "FindNextMD", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "response", ".", "MerkleNodes", ")", "==", "0", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "rootSeqno", ")", "\n", "return", "nil", ",", "nil", ",", "0", ",", "nil", "\n", "}", "\n\n", "if", "response", ".", "KbfsRoot", ".", "Version", "!=", "1", "{", "return", "nil", ",", "nil", ",", "0", ",", "kbfsmd", ".", "NewMerkleVersionError", "{", "Version", ":", "response", ".", "KbfsRoot", ".", "Version", "}", "\n", "}", "\n\n", "// Verify this is a valid merkle root and KBFS root before we", "// decode the bytes.", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "response", ".", "RootSeqno", ")", "\n", "root", ":=", "keybase1", ".", "MerkleRootV2", "{", "Seqno", ":", "response", ".", "RootSeqno", ",", "HashMeta", ":", "response", ".", "RootHash", ",", "}", "\n", "expectedKbfsRoot", ":=", "keybase1", ".", "KBFSRoot", "{", "TreeID", ":", "tlfToMerkleTreeID", "(", "tlfID", ")", ",", "Root", ":", "response", ".", "KbfsRoot", ".", "Root", ",", "}", "\n", "err", "=", "md", ".", "config", ".", "KBPKI", "(", ")", ".", "VerifyMerkleRoot", "(", "ctx", ",", "root", ",", "expectedKbfsRoot", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "var", "kbfsRoot", "kbfsmd", ".", "MerkleRoot", "\n", "err", "=", "md", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "response", ".", "KbfsRoot", ".", "Root", ",", "&", "kbfsRoot", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "// Validate the hashes of the nodes all the way down to the leaf.", "err", "=", "verifyMerkleNodes", "(", "ctx", ",", "&", "kbfsRoot", ",", "response", ".", "MerkleNodes", ",", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "return", "&", "kbfsRoot", ",", "response", ".", "MerkleNodes", ",", "response", ".", "RootSeqno", ",", "nil", "\n", "}" ]

[ "FindNextMD", "implements", "the", "MDServer", "interface", "for", "MDServerRemote", "." ]

[ "func", "normalizeNames", "(", "names", "[", "]", "string", ",", "t", "tlf", ".", "Type", ")", "(", "changesMade", "bool", ",", "err", "error", ")", "{", "for", "i", ",", "name", ":=", "range", "names", "{", "x", ",", "err", ":=", "normalizeAssertionOrName", "(", "name", ",", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "x", "!=", "name", "{", "names", "[", "i", "]", "=", "x", "\n", "changesMade", "=", "true", "\n", "}", "\n", "}", "\n", "return", "changesMade", ",", "nil", "\n", "}" ]

[ "normalizeNames", "normalizes", "a", "slice", "of", "names", "and", "returns", "whether", "any", "of", "them", "changed", "." ]

[ "func", "NormalizeNamesInTLF", "(", "writerNames", ",", "readerNames", "[", "]", "string", ",", "t", "tlf", ".", "Type", ",", "extensionSuffix", "string", ")", "(", "normalizedName", "string", ",", "changesMade", "bool", ",", "err", "error", ")", "{", "changesMade", ",", "err", "=", "normalizeNames", "(", "writerNames", ",", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", ",", "err", "\n", "}", "\n", "sort", ".", "Strings", "(", "writerNames", ")", "\n", "normalizedName", "=", "strings", ".", "Join", "(", "writerNames", ",", "\"", "\"", ")", "\n", "if", "len", "(", "readerNames", ")", ">", "0", "{", "rchanges", ",", "err", ":=", "normalizeNames", "(", "readerNames", ",", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", ",", "err", "\n", "}", "\n", "changesMade", "=", "changesMade", "||", "rchanges", "\n", "sort", ".", "Strings", "(", "readerNames", ")", "\n", "normalizedName", "+=", "tlf", ".", "ReaderSep", "+", "strings", ".", "Join", "(", "readerNames", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "extensionSuffix", ")", "!=", "0", "{", "// This *should* be normalized already but make sure. I can see not", "// doing so might surprise a caller.", "nExt", ":=", "strings", ".", "ToLower", "(", "extensionSuffix", ")", "\n", "normalizedName", "+=", "tlf", ".", "HandleExtensionSep", "+", "nExt", "\n", "changesMade", "=", "changesMade", "||", "nExt", "!=", "extensionSuffix", "\n", "}", "\n\n", "return", "normalizedName", ",", "changesMade", ",", "nil", "\n", "}" ]

[ "NormalizeNamesInTLF", "takes", "a", "split", "TLF", "name", "and", "without", "doing", "any", "resolutions", "or", "identify", "calls", "normalizes", "all", "elements", "of", "the", "name", ".", "It", "then", "returns", "the", "normalized", "name", "and", "a", "boolean", "flag", "whether", "any", "names", "were", "modified", ".", "This", "modifies", "the", "slices", "passed", "as", "arguments", "." ]

[ "func", "SplitAndNormalizeTLFName", "(", "name", "string", ",", "t", "tlf", ".", "Type", ")", "(", "writerNames", ",", "readerNames", "[", "]", "string", ",", "extensionSuffix", "string", ",", "err", "error", ")", "{", "writerNames", ",", "readerNames", ",", "extensionSuffix", ",", "err", "=", "tlf", ".", "SplitName", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "t", "==", "tlf", ".", "SingleTeam", "&&", "len", "(", "writerNames", ")", "!=", "1", "{", "// No team folder can have more than one writer.", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "NoSuchNameError", "{", "Name", ":", "name", "}", "\n", "}", "\n\n", "hasReaders", ":=", "len", "(", "readerNames", ")", "!=", "0", "\n", "if", "t", "!=", "tlf", ".", "Private", "&&", "hasReaders", "{", "// No public/team folder can have readers.", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "NoSuchNameError", "{", "Name", ":", "name", "}", "\n", "}", "\n\n", "normalizedName", ",", "changes", ",", "err", ":=", "NormalizeNamesInTLF", "(", "writerNames", ",", "readerNames", ",", "t", ",", "extensionSuffix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "// Check for changes - not just ordering differences here.", "if", "changes", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "errors", ".", "WithStack", "(", "TlfNameNotCanonical", "{", "name", ",", "normalizedName", "}", ")", "\n", "}", "\n\n", "return", "writerNames", ",", "readerNames", ",", "strings", ".", "ToLower", "(", "extensionSuffix", ")", ",", "nil", "\n", "}" ]

[ "SplitAndNormalizeTLFName", "takes", "a", "tlf", "name", "as", "a", "string", "and", "tries", "to", "normalize", "it", "offline", ".", "In", "addition", "to", "other", "checks", "it", "returns", "TlfNameNotCanonical", "if", "it", "does", "not", "look", "canonical", ".", "Note", "that", "ordering", "differences", "do", "not", "result", "in", "TlfNameNotCanonical", "being", "returned", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "MakeFBOsForExistingJournals", "(", "ctx", "context", ".", "Context", ")", "*", "sync", ".", "WaitGroup", "{", "var", "wg", "sync", ".", "WaitGroup", "\n\n", "j", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "j", ".", "lock", ".", "Unlock", "(", ")", "\n", "for", "tlfID", ",", "tj", ":=", "range", "j", ".", "tlfJournals", "{", "wg", ".", "Add", "(", "1", ")", "\n", "tlfID", ":=", "tlfID", "\n", "tj", ":=", "tj", "\n", "go", "func", "(", ")", "{", "ctx", ":=", "CtxWithRandomIDReplayable", "(", "context", ".", "Background", "(", ")", ",", "CtxFBOIDKey", ",", "CtxFBOOpID", ",", "j", ".", "log", ")", "\n\n", "// Turn off tracker popups.", "ctx", ",", "err", ":=", "tlfhandle", ".", "MakeExtendedIdentify", "(", "ctx", ",", "keybase1", ".", "TLFIdentifyBehavior_KBFS_INIT", ")", "\n", "if", "err", "!=", "nil", "{", "j", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "defer", "wg", ".", "Done", "(", ")", "\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n\n", "err", "=", "j", ".", "makeFBOForJournal", "(", "ctx", ",", "tj", ",", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "j", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ",", "err", ")", "\n", "}", "\n\n", "// The popups and errors were suppressed, but any errors would", "// have been logged. So just close out the extended identify. If", "// the user accesses the TLF directly, another proper identify", "// should happen that shows errors.", "_", "=", "tlfhandle", ".", "GetExtendedIdentify", "(", "ctx", ")", ".", "GetTlfBreakAndClose", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "&", "wg", "\n", "}" ]

[ "MakeFBOsForExistingJournals", "creates", "folderBranchOps", "objects", "for", "all", "existing", "non", "-", "empty", "journals", ".", "This", "is", "useful", "to", "initialize", "the", "unflushed", "edit", "history", "for", "example", ".", "It", "returns", "a", "wait", "group", "that", "the", "caller", "can", "use", "to", "determine", "when", "all", "the", "FBOs", "have", "been", "initialized", ".", "If", "the", "caller", "is", "not", "going", "to", "wait", "on", "the", "group", "it", "should", "provoide", "a", "context", "that", "won", "t", "be", "canceled", "before", "the", "wait", "group", "is", "finished", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "enableLocked", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "chargedTo", "keybase1", ".", "UserOrTeamID", ",", "bws", "TLFJournalBackgroundWorkStatus", ",", "allowEnableIfDirty", "bool", ")", "(", "tj", "*", "tlfJournal", ",", "err", "error", ")", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "bws", ")", "\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "j", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "if", "j", ".", "currentUID", "==", "keybase1", ".", "UID", "(", "\"", "\"", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "j", ".", "currentVerifyingKey", "==", "(", "kbfscrypto", ".", "VerifyingKey", "{", "}", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "tj", ",", "ok", ":=", "j", ".", "tlfJournals", "[", "tlfID", "]", ";", "ok", "{", "err", "=", "tj", ".", "enable", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "tj", ",", "nil", "\n", "}", "\n\n", "err", "=", "func", "(", ")", "error", "{", "if", "j", ".", "dirtyOps", "[", "tlfID", "]", ">", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n", "if", "j", ".", "delegateDirtyBlockCache", ".", "IsAnyDirty", "(", "tlfID", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "allowEnableIfDirty", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "j", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "tlfDir", ":=", "j", ".", "tlfJournalPathLocked", "(", "tlfID", ")", "\n", "tj", ",", "err", "=", "makeTLFJournal", "(", "ctx", ",", "j", ".", "currentUID", ",", "j", ".", "currentVerifyingKey", ",", "tlfDir", ",", "tlfID", ",", "chargedTo", ",", "tlfJournalConfigAdapter", "{", "j", ".", "config", "}", ",", "j", ".", "delegateBlockServer", ",", "bws", ",", "nil", ",", "j", ".", "onBranchChange", ",", "j", ".", "onMDFlush", ",", "j", ".", "config", ".", "DiskLimiter", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "tj", ",", "nil", "\n", "}" ]

[ "enabledLocked", "returns", "an", "enabled", "journal", ";", "it", "is", "the", "caller", "s", "responsibility", "to", "add", "it", "to", "j", ".", "tlfJournals", ".", "This", "allows", "this", "method", "to", "be", "called", "in", "parallel", "during", "initialization", "if", "desired", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "Enable", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "h", "*", "tlfhandle", ".", "Handle", ",", "bws", "TLFJournalBackgroundWorkStatus", ")", "(", "err", "error", ")", "{", "j", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "j", ".", "lock", ".", "Unlock", "(", ")", "\n", "chargedTo", ":=", "j", ".", "currentUID", ".", "AsUserOrTeam", "(", ")", "\n", "if", "tlfID", ".", "Type", "(", ")", "==", "tlf", ".", "SingleTeam", "{", "if", "h", "==", "nil", "{", "// Any path that creates a single-team TLF journal should", "// also provide a handle. If not, we'd have to fetch it", "// from the server, which isn't a trusted path.", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n\n", "chargedTo", "=", "h", ".", "FirstResolvedWriter", "(", ")", "\n", "if", "tid", ":=", "chargedTo", ".", "AsTeamOrBust", "(", ")", ";", "tid", ".", "IsSubTeam", "(", ")", "{", "// We can't charge to subteams; find the root team.", "rootID", ",", "err", ":=", "j", ".", "config", ".", "KBPKI", "(", ")", ".", "GetTeamRootID", "(", "ctx", ",", "tid", ",", "j", ".", "config", ".", "OfflineAvailabilityForID", "(", "tlfID", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "chargedTo", "=", "rootID", ".", "AsUserOrTeam", "(", ")", "\n", "}", "\n", "}", "\n", "tj", ",", "err", ":=", "j", ".", "enableLocked", "(", "ctx", ",", "tlfID", ",", "chargedTo", ",", "bws", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "j", ".", "tlfJournals", "[", "tlfID", "]", "=", "tj", "\n", "return", "nil", "\n", "}" ]

[ "Enable", "turns", "on", "the", "write", "journal", "for", "the", "given", "TLF", ".", "If", "h", "is", "nil", "it", "will", "be", "attempted", "to", "be", "fetched", "from", "the", "remote", "MD", "server", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "EnableAuto", "(", "ctx", "context", ".", "Context", ")", "error", "{", "j", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "j", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "j", ".", "serverConfig", ".", "EnableAuto", "{", "// Nothing to do.", "return", "nil", "\n", "}", "\n\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "j", ".", "serverConfig", ".", "EnableAuto", "=", "true", "\n", "j", ".", "serverConfig", ".", "EnableAutoSetByUser", "=", "true", "\n", "return", "j", ".", "writeConfig", "(", ")", "\n", "}" ]

[ "EnableAuto", "turns", "on", "the", "write", "journal", "for", "all", "TLFs", "even", "new", "ones", "persistently", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "DisableAuto", "(", "ctx", "context", ".", "Context", ")", "error", "{", "j", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "j", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "enabled", ",", "_", ":=", "j", ".", "getEnableAutoLocked", "(", ")", ";", "!", "enabled", "{", "// Nothing to do.", "return", "nil", "\n", "}", "\n\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "j", ".", "serverConfig", ".", "EnableAuto", "=", "false", "\n", "j", ".", "serverConfig", ".", "EnableAutoSetByUser", "=", "true", "\n", "return", "j", ".", "writeConfig", "(", ")", "\n", "}" ]

[ "DisableAuto", "turns", "off", "automatic", "write", "journal", "for", "any", "newly", "-", "accessed", "TLFs", ".", "Existing", "journaled", "TLFs", "need", "to", "be", "disabled", "manually", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "PauseBackgroundWork", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "if", "tlfJournal", ",", "ok", ":=", "j", ".", "getTLFJournal", "(", "tlfID", ",", "nil", ")", ";", "ok", "{", "tlfJournal", ".", "pauseBackgroundWork", "(", ")", "\n", "return", "\n", "}", "\n\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "}" ]

[ "PauseBackgroundWork", "pauses", "the", "background", "work", "goroutine", "if", "it", "s", "not", "already", "paused", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "ResumeBackgroundWork", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "if", "tlfJournal", ",", "ok", ":=", "j", ".", "getTLFJournal", "(", "tlfID", ",", "nil", ")", ";", "ok", "{", "tlfJournal", ".", "resumeBackgroundWork", "(", ")", "\n", "return", "\n", "}", "\n\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "}" ]

[ "ResumeBackgroundWork", "resumes", "the", "background", "work", "goroutine", "if", "it", "s", "not", "already", "resumed", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "Flush", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "(", "err", "error", ")", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "if", "tlfJournal", ",", "ok", ":=", "j", ".", "getTLFJournal", "(", "tlfID", ",", "nil", ")", ";", "ok", "{", "// TODO: do we want to plumb lc through here as well?", "return", "tlfJournal", ".", "flush", "(", "ctx", ")", "\n", "}", "\n\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "return", "nil", "\n", "}" ]

[ "Flush", "flushes", "the", "write", "journal", "for", "the", "given", "TLF", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "FinishSingleOp", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "lc", "*", "keybase1", ".", "LockContext", ",", "priority", "keybase1", ".", "MDPriority", ")", "(", "err", "error", ")", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "if", "tlfJournal", ",", "ok", ":=", "j", ".", "getTLFJournal", "(", "tlfID", ",", "nil", ")", ";", "ok", "{", "return", "tlfJournal", ".", "finishSingleOp", "(", "ctx", ",", "lc", ",", "priority", ")", "\n", "}", "\n\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "return", "nil", "\n", "}" ]

[ "FinishSingleOp", "lets", "the", "write", "journal", "know", "that", "the", "application", "has", "finished", "a", "single", "op", "and", "then", "blocks", "until", "the", "write", "journal", "has", "finished", "flushing", "everything", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "Disable", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "(", "wasEnabled", "bool", ",", "err", "error", ")", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "j", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "j", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "j", ".", "lock", ".", "Unlock", "(", ")", "\n", "tlfJournal", ",", "ok", ":=", "j", ".", "tlfJournals", "[", "tlfID", "]", "\n", "if", "!", "ok", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "return", "false", ",", "nil", "\n", "}", "\n\n", "if", "j", ".", "dirtyOps", "[", "tlfID", "]", ">", "0", "{", "return", "false", ",", "errors", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n", "if", "j", ".", "delegateDirtyBlockCache", ".", "IsAnyDirty", "(", "tlfID", ")", "{", "return", "false", ",", "errors", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n\n", "// Disable the journal. Note that we don't bother deleting the", "// journal from j.tlfJournals, to avoid cases where something", "// keeps it around doing background work or re-enables it, at the", "// same time JournalManager creates a new journal for the same TLF.", "wasEnabled", ",", "err", "=", "tlfJournal", ".", "disable", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "wasEnabled", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n", "return", "wasEnabled", ",", "nil", "\n", "}" ]

[ "Disable", "turns", "off", "the", "write", "journal", "for", "the", "given", "TLF", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "Status", "(", "ctx", "context", ".", "Context", ")", "(", "JournalManagerStatus", ",", "[", "]", "tlf", ".", "ID", ")", "{", "j", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "j", ".", "lock", ".", "RUnlock", "(", ")", "\n", "var", "totalStoredBytes", ",", "totalStoredFiles", ",", "totalUnflushedBytes", "int64", "\n", "tlfIDs", ":=", "make", "(", "[", "]", "tlf", ".", "ID", ",", "0", ",", "len", "(", "j", ".", "tlfJournals", ")", ")", "\n", "for", "_", ",", "tlfJournal", ":=", "range", "j", ".", "tlfJournals", "{", "storedBytes", ",", "storedFiles", ",", "unflushedBytes", ",", "err", ":=", "tlfJournal", ".", "getByteCounts", "(", ")", "\n", "if", "err", "!=", "nil", "{", "j", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "tlfJournal", ".", "tlfID", ",", "err", ")", "\n", "}", "\n", "totalStoredBytes", "+=", "storedBytes", "\n", "totalStoredFiles", "+=", "storedFiles", "\n", "totalUnflushedBytes", "+=", "unflushedBytes", "\n", "tlfIDs", "=", "append", "(", "tlfIDs", ",", "tlfJournal", ".", "tlfID", ")", "\n", "}", "\n", "enableAuto", ",", "enableAutoSetByUser", ":=", "j", ".", "getEnableAutoLocked", "(", ")", "\n", "return", "JournalManagerStatus", "{", "RootDir", ":", "j", ".", "rootPath", "(", ")", ",", "Version", ":", "1", ",", "CurrentUID", ":", "j", ".", "currentUID", ",", "CurrentVerifyingKey", ":", "j", ".", "currentVerifyingKey", ",", "EnableAuto", ":", "enableAuto", ",", "EnableAutoSetByUser", ":", "enableAutoSetByUser", ",", "JournalCount", ":", "len", "(", "tlfIDs", ")", ",", "StoredBytes", ":", "totalStoredBytes", ",", "StoredFiles", ":", "totalStoredFiles", ",", "UnflushedBytes", ":", "totalUnflushedBytes", ",", "DiskLimiterStatus", ":", "j", ".", "config", ".", "DiskLimiter", "(", ")", ".", "getStatus", "(", "ctx", ",", "j", ".", "currentUID", ".", "AsUserOrTeam", "(", ")", ")", ",", "}", ",", "tlfIDs", "\n", "}" ]

[ "Status", "returns", "a", "JournalManagerStatus", "object", "suitable", "for", "diagnostics", ".", "It", "also", "returns", "a", "list", "of", "TLF", "IDs", "which", "have", "journals", "enabled", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "JournalStatus", "(", "tlfID", "tlf", ".", "ID", ")", "(", "TLFJournalStatus", ",", "error", ")", "{", "tlfJournal", ",", "ok", ":=", "j", ".", "getTLFJournal", "(", "tlfID", ",", "nil", ")", "\n", "if", "!", "ok", "{", "return", "TLFJournalStatus", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n\n", "return", "tlfJournal", ".", "getJournalStatus", "(", ")", "\n", "}" ]

[ "JournalStatus", "returns", "a", "TLFServerStatus", "object", "for", "the", "given", "TLF", "suitable", "for", "diagnostics", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "JournalStatusWithPaths", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "cpp", "chainsPathPopulator", ")", "(", "TLFJournalStatus", ",", "error", ")", "{", "tlfJournal", ",", "ok", ":=", "j", ".", "getTLFJournal", "(", "tlfID", ",", "nil", ")", "\n", "if", "!", "ok", "{", "return", "TLFJournalStatus", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "tlfID", ")", "\n", "}", "\n\n", "return", "tlfJournal", ".", "getJournalStatusWithPaths", "(", "ctx", ",", "cpp", ")", "\n", "}" ]

[ "JournalStatusWithPaths", "returns", "a", "TLFServerStatus", "object", "for", "the", "given", "TLF", "suitable", "for", "diagnostics", "including", "paths", "for", "all", "the", "unflushed", "entries", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "shutdownExistingJournalsLocked", "(", "ctx", "context", ".", "Context", ")", "{", "for", "len", "(", "j", ".", "dirtyOps", ")", ">", "0", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "len", "(", "j", ".", "dirtyOps", ")", ")", "\n", "j", ".", "dirtyOpsDone", ".", "Wait", "(", ")", "\n", "}", "\n\n", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "for", "_", ",", "tlfJournal", ":=", "range", "j", ".", "tlfJournals", "{", "tlfJournal", ".", "shutdown", "(", "ctx", ")", "\n", "}", "\n\n", "j", ".", "tlfJournals", "=", "make", "(", "map", "[", "tlf", ".", "ID", "]", "*", "tlfJournal", ")", "\n", "j", ".", "currentUID", "=", "keybase1", ".", "UID", "(", "\"", "\"", ")", "\n", "j", ".", "currentVerifyingKey", "=", "kbfscrypto", ".", "VerifyingKey", "{", "}", "\n", "}" ]

[ "shutdownExistingJournalsLocked", "shuts", "down", "all", "write", "journals", "sets", "the", "current", "UID", "and", "verifying", "key", "to", "zero", "and", "returns", "once", "all", "shutdowns", "are", "complete", ".", "It", "is", "safe", "to", "call", "multiple", "times", "in", "a", "row", "and", "once", "this", "is", "called", "EnableExistingJournals", "may", "be", "called", "again", "." ]

[ "func", "(", "j", "*", "JournalManager", ")", "shutdownExistingJournals", "(", "ctx", "context", ".", "Context", ")", "{", "j", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "j", ".", "lock", ".", "Unlock", "(", ")", "\n", "j", ".", "shutdownExistingJournalsLocked", "(", "ctx", ")", "\n", "}" ]

[ "shutdownExistingJournals", "shuts", "down", "all", "write", "journals", "sets", "the", "current", "UID", "and", "verifying", "key", "to", "zero", "and", "returns", "once", "all", "shutdowns", "are", "complete", ".", "It", "is", "safe", "to", "call", "multiple", "times", "in", "a", "row", "and", "once", "this", "is", "called", "EnableExistingJournals", "may", "be", "called", "again", "." ]

[ "func", "(", "m", "*", "MemMulti", ")", "NumPutParts", "(", ")", "int", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n\n", "return", "m", ".", "numPutParts", "\n", "}" ]

[ "NumPutParts", "returns", "the", "number", "of", "times", "PutPart", "was", "called", "." ]

[ "func", "MakeRefNonce", "(", ")", "(", "RefNonce", ",", "error", ")", "{", "var", "nonce", "RefNonce", "\n", "for", "nonce", "==", "ZeroRefNonce", "{", "err", ":=", "kbfscrypto", ".", "RandRead", "(", "nonce", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ZeroRefNonce", ",", "err", "\n", "}", "\n", "}", "\n", "return", "nonce", ",", "nil", "\n", "}" ]

[ "MakeRefNonce", "generates", "a", "non", "-", "zero", "block", "reference", "nonce", "using", "a", "CSPRNG", ".", "This", "is", "used", "for", "distinguishing", "different", "references", "to", "the", "same", "ID", "." ]

[ "func", "MakeFirstContext", "(", "creator", "keybase1", ".", "UserOrTeamID", ",", "bType", "keybase1", ".", "BlockType", ")", "Context", "{", "return", "Context", "{", "Creator", ":", "creator", ",", "BlockType", ":", "bType", "}", "\n", "}" ]

[ "MakeFirstContext", "makes", "the", "initial", "context", "for", "a", "block", "with", "the", "given", "creator", "." ]

[ "func", "MakeContext", "(", "creator", "keybase1", ".", "UserOrTeamID", ",", "writer", "keybase1", ".", "UserOrTeamID", ",", "nonce", "RefNonce", ",", "bType", "keybase1", ".", "BlockType", ")", "Context", "{", "return", "Context", "{", "Creator", ":", "creator", ",", "Writer", ":", "writer", ",", "RefNonce", ":", "nonce", ",", "BlockType", ":", "bType", ",", "}", "\n", "}" ]

[ "MakeContext", "makes", "a", "context", "with", "the", "given", "creator", "writer", "and", "nonce", "where", "the", "writer", "is", "not", "necessarily", "equal", "to", "the", "creator", "and", "the", "nonce", "is", "usually", "non", "-", "zero", "." ]

[ "func", "(", "c", "Context", ")", "GetWriter", "(", ")", "keybase1", ".", "UserOrTeamID", "{", "if", "!", "c", ".", "Writer", ".", "IsNil", "(", ")", "{", "return", "c", ".", "Writer", "\n", "}", "\n", "return", "c", ".", "Creator", "\n", "}" ]

[ "GetWriter", "returns", "the", "writer", "of", "the", "associated", "block", "." ]

[ "func", "(", "c", "*", "Context", ")", "SetWriter", "(", "newWriter", "keybase1", ".", "UserOrTeamID", ")", "{", "if", "c", ".", "Creator", "!=", "newWriter", "{", "c", ".", "Writer", "=", "newWriter", "\n", "}", "else", "{", "// save some bytes by not populating the separate Writer", "// field if it matches the creator.", "c", ".", "Writer", "=", "\"", "\"", "\n", "}", "\n", "}" ]

[ "SetWriter", "sets", "the", "Writer", "field", "if", "necessary", "." ]

[ "func", "MakeMerkleHash", "(", "codec", "kbfscodec", ".", "Codec", ",", "md", "*", "RootMetadataSigned", ")", "(", "MerkleHash", ",", "error", ")", "{", "buf", ",", "err", ":=", "codec", ".", "Encode", "(", "md", ")", "\n", "if", "err", "!=", "nil", "{", "return", "MerkleHash", "{", "}", ",", "err", "\n", "}", "\n", "h", ",", "err", ":=", "kbfshash", ".", "DefaultHash", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "MerkleHash", "{", "}", ",", "err", "\n", "}", "\n", "return", "MerkleHash", "{", "h", "}", ",", "nil", "\n", "}" ]

[ "MakeMerkleHash", "hashes", "the", "given", "signed", "RootMetadata", "object", "." ]

[ "func", "(", "h", "MerkleHash", ")", "MarshalBinary", "(", ")", "(", "data", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "h", ".", "h", ".", "MarshalBinary", "(", ")", "\n", "}" ]

[ "MarshalBinary", "implements", "the", "encoding", ".", "BinaryMarshaler", "interface", "for", "MerkleHash", ".", "Returns", "an", "error", "if", "the", "MerkleHash", "is", "invalid", "and", "not", "the", "zero", "MerkleHash", "." ]

[ "func", "(", "h", "*", "MerkleHash", ")", "UnmarshalBinary", "(", "data", "[", "]", "byte", ")", "error", "{", "return", "h", ".", "h", ".", "UnmarshalBinary", "(", "data", ")", "\n", "}" ]

[ "UnmarshalBinary", "implements", "the", "encoding", ".", "BinaryUnmarshaler", "interface", "for", "MerkleHash", ".", "Returns", "an", "error", "if", "the", "given", "byte", "array", "is", "non", "-", "empty", "and", "the", "MerkleHash", "is", "invalid", "." ]

[ "func", "(", "to", "*", "PGPKeyBundle", ")", "MergeKey", "(", "from", "*", "PGPKeyBundle", ")", "{", "// First, merge identities, adding any signatures found in matching identities", "for", "name", ",", "fromIdentity", ":=", "range", "from", ".", "Identities", "{", "if", "toIdentity", ",", "ok", ":=", "to", ".", "Identities", "[", "name", "]", ";", "ok", "{", "to", ".", "Identities", "[", "name", "]", ".", "Signatures", "=", "combineSignatures", "(", "toIdentity", ".", "Signatures", ",", "fromIdentity", ".", "Signatures", ")", "\n\n", "// There's a primary self-signature that we use. Always take the later", "// of the two.", "ssTo", ":=", "to", ".", "Identities", "[", "name", "]", ".", "SelfSignature", "\n", "ssFrom", ":=", "fromIdentity", ".", "SelfSignature", "\n", "if", "ssFrom", ".", "CreationTime", ".", "After", "(", "ssTo", ".", "CreationTime", ")", "{", "to", ".", "Identities", "[", "name", "]", ".", "SelfSignature", "=", "ssFrom", "\n", "}", "\n\n", "}", "else", "{", "to", ".", "Identities", "[", "fromIdentity", ".", "Name", "]", "=", "fromIdentity", "\n", "}", "\n", "}", "\n\n", "// Then, merge revocations", "to", ".", "Revocations", "=", "combineSignatures", "(", "to", ".", "Revocations", ",", "from", ".", "Revocations", ")", "\n\n", "// Finally, merge subkeys", "existingSubkeys", ":=", "make", "(", "map", "[", "[", "20", "]", "byte", "]", "int", ")", "\n", "for", "i", ",", "subkey", ":=", "range", "to", ".", "Subkeys", "{", "existingSubkeys", "[", "subkey", ".", "PublicKey", ".", "Fingerprint", "]", "=", "i", "\n", "}", "\n", "for", "_", ",", "subkey", ":=", "range", "from", ".", "Subkeys", "{", "if", "i", ",", "ok", ":=", "existingSubkeys", "[", "subkey", ".", "PublicKey", ".", "Fingerprint", "]", ";", "ok", "{", "if", "subkey", ".", "Sig", ".", "CreationTime", ".", "After", "(", "to", ".", "Subkeys", "[", "i", "]", ".", "Sig", ".", "CreationTime", ")", "{", "to", ".", "Subkeys", "[", "i", "]", ".", "Sig", "=", "subkey", ".", "Sig", "\n", "if", "subkey", ".", "Revocation", "!=", "nil", "{", "to", ".", "Subkeys", "[", "i", "]", ".", "Revocation", "=", "subkey", ".", "Revocation", "\n", "}", "\n", "}", "\n", "}", "else", "{", "to", ".", "Subkeys", "=", "append", "(", "to", ".", "Subkeys", ",", "subkey", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "MergeKey", "adds", "the", "identities", "revocations", "and", "subkeys", "of", "another", "PGPKeyBundle", "to", "this", "key" ]

[ "func", "RunProvisioner", "(", "arg", "ProvisionerArg", ")", "error", "{", "p", ":=", "newProvisioner", "(", "arg", ")", "\n", "err", ":=", "p", ".", "run", "(", ")", "\n", "p", ".", "close", "(", ")", "// ignore any errors in closing the channel", "\n", "return", "err", "\n", "}" ]

[ "RunProvisioner", "runs", "a", "provisioner", "given", "the", "necessary", "arguments", "." ]