Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "GetDesktopNotificationSnippet", "(", "conv", "*", "chat1", ".", "ConversationLocal", ",", "currentUsername", "string", ",", "fromMsg", "*", "chat1", ".", "MessageUnboxed", ")", "string", "{", "if", "conv", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "var", "msg", "chat1", ".", "MessageUnboxed", "\n", "if", "fromMsg", "!=", "nil", "{", "msg", "=", "*", "fromMsg", "\n", "}", "else", "if", "conv", ".", "Info", ".", "SnippetMsg", "!=", "nil", "{", "msg", "=", "*", "conv", ".", "Info", ".", "SnippetMsg", "\n", "}", "else", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "!", "msg", ".", "IsValid", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "mvalid", ":=", "msg", ".", "Valid", "(", ")", "\n", "var", "snippet", "string", "\n", "if", "!", "mvalid", ".", "IsEphemeral", "(", ")", "{", "switch", "msg", ".", "GetMessageType", "(", ")", "{", "case", "chat1", ".", "MessageType_REACTION", ":", "reaction", ",", "err", ":=", "GetReaction", "(", "msg", ")", "\n", "if", "err", "!=", "nil", "{", "snippet", "=", "\"", "\"", "\n", "}", "else", "{", "var", "prefix", "string", "\n", "if", "showSenderPrefix", "(", "mvalid", ",", "*", "conv", ")", "{", "prefix", "=", "mvalid", ".", "SenderUsername", "+", "\"", "\"", "\n", "}", "\n", "snippet", "=", "emoji", ".", "Sprintf", "(", "\"", "\"", ",", "prefix", ",", "reaction", ")", "\n", "}", "\n", "default", ":", "snippet", ",", "_", "=", "GetMsgSnippet", "(", "msg", ",", "*", "conv", ",", "currentUsername", ")", "\n", "}", "\n", "return", "snippet", "\n", "}", "\n\n", "// If the message is already exploded, nothing to see here.", "if", "!", "msg", ".", "IsValidFull", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "switch", "msg", ".", "GetMessageType", "(", ")", "{", "case", "chat1", ".", "MessageType_TEXT", ",", "chat1", ".", "MessageType_ATTACHMENT", ":", "return", "\"", "", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "We", "don", "t", "want", "to", "display", "the", "contents", "of", "an", "exploding", "message", "in", "notifications" ]

[ "func", "AssetsForMessage", "(", "g", "*", "globals", ".", "Context", ",", "msgBody", "chat1", ".", "MessageBody", ")", "(", "assets", "[", "]", "chat1", ".", "Asset", ")", "{", "typ", ",", "err", ":=", "msgBody", ".", "MessageType", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// Log and drop the error for a malformed MessageBody.", "g", ".", "Log", ".", "Warning", "(", "\"", "\"", ",", "err", ")", "\n", "return", "assets", "\n", "}", "\n", "switch", "typ", "{", "case", "chat1", ".", "MessageType_ATTACHMENT", ":", "body", ":=", "msgBody", ".", "Attachment", "(", ")", "\n", "if", "body", ".", "Object", ".", "Path", "!=", "\"", "\"", "{", "assets", "=", "append", "(", "assets", ",", "body", ".", "Object", ")", "\n", "}", "\n", "if", "body", ".", "Preview", "!=", "nil", "{", "assets", "=", "append", "(", "assets", ",", "*", "body", ".", "Preview", ")", "\n", "}", "\n", "assets", "=", "append", "(", "assets", ",", "body", ".", "Previews", "...", ")", "\n", "case", "chat1", ".", "MessageType_ATTACHMENTUPLOADED", ":", "body", ":=", "msgBody", ".", "Attachmentuploaded", "(", ")", "\n", "if", "body", ".", "Object", ".", "Path", "!=", "\"", "\"", "{", "assets", "=", "append", "(", "assets", ",", "body", ".", "Object", ")", "\n", "}", "\n", "assets", "=", "append", "(", "assets", ",", "body", ".", "Previews", "...", ")", "\n", "}", "\n", "return", "assets", "\n", "}" ]

[ "AssetsForMessage", "gathers", "all", "assets", "on", "a", "message" ]

[ "func", "GetQueryRe", "(", "query", "string", ")", "(", "*", "regexp", ".", "Regexp", ",", "error", ")", "{", "return", "regexp", ".", "Compile", "(", "\"", "\"", "+", "regexp", ".", "QuoteMeta", "(", "query", ")", ")", "\n", "}" ]

[ "GetQueryRe", "returns", "a", "regex", "to", "match", "the", "query", "string", "on", "message", "text", ".", "This", "is", "used", "for", "result", "highlighting", "." ]

[ "func", "(", "r", "*", "RemoteStatus", ")", "Init", "(", "ctx", "context", ".", "Context", ",", "log", "logger", ".", "Logger", ",", "config", "libkbfs", ".", "Config", ",", "rs", "RemoteStatusUpdater", ")", "{", "r", ".", "failingServices", "=", "map", "[", "string", "]", "error", "{", "}", "\n", "r", ".", "callbacks", "=", "rs", "\n", "// A time in the far past that is not IsZero", "r", ".", "failingSince", ".", "Add", "(", "time", ".", "Second", ")", "\n", "go", "r", ".", "loop", "(", "ctx", ",", "log", ",", "config", ")", "\n", "}" ]

[ "Init", "a", "RemoteStatus", "and", "register", "it", "with", "libkbfs", "." ]

[ "func", "(", "r", "*", "RemoteStatus", ")", "ExtraFileName", "(", ")", "string", "{", "r", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "Unlock", "(", ")", "\n\n", "if", "r", ".", "extraFileName", "==", "\"", "\"", "||", "time", ".", "Since", "(", "r", ".", "failingSince", ")", "<", "failureDisplayThreshold", "{", "return", "\"", "\"", "\n", "}", "\n\n", "return", "r", ".", "extraFileName", "\n", "}" ]

[ "ExtraFileName", "returns", "the", "extra", "file", "name", "or", "an", "empty", "string", "for", "none", "." ]

[ "func", "(", "r", "*", "RemoteStatus", ")", "ExtraFileNameAndSize", "(", ")", "(", "string", ",", "int64", ")", "{", "r", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "Unlock", "(", ")", "\n\n", "if", "r", ".", "extraFileName", "==", "\"", "\"", "||", "time", ".", "Since", "(", "r", ".", "failingSince", ")", "<", "failureDisplayThreshold", "{", "return", "\"", "\"", ",", "0", "\n", "}", "\n\n", "return", "r", ".", "extraFileName", ",", "int64", "(", "len", "(", "r", ".", "humanReadableBytesLocked", "(", ")", ")", ")", "\n", "}" ]

[ "ExtraFileNameAndSize", "returns", "the", "extra", "file", "name", "or", "an", "empty", "string", "for", "none", "and", "the", "size", "of", "the", "extra", "file", "." ]

[ "func", "(", "r", "*", "RemoteStatus", ")", "humanReadableBytesLocked", "(", ")", "[", "]", "byte", "{", "if", "r", ".", "extraFileContents", "!=", "nil", "{", "return", "r", ".", "extraFileContents", "\n", "}", "\n\n", "var", "ss", "[", "]", "string", "\n", "needLogin", ":=", "false", "\n", "for", "service", ",", "err", ":=", "range", "r", ".", "failingServices", "{", "switch", "err", ".", "(", "type", ")", "{", "case", "*", "libkb", ".", "LoginRequiredError", ":", "needLogin", "=", "true", "\n", "default", ":", "ss", "=", "append", "(", "ss", ",", "service", "+", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "ss", ")", "==", "0", "{", "if", "needLogin", "{", "ss", "=", "append", "(", "ss", ",", "\"", "\"", ")", "\n", "}", "else", "{", "ss", "=", "append", "(", "ss", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "ss", "=", "append", "(", "ss", ",", "\"", "\"", ")", "\n\n", "res", ":=", "[", "]", "byte", "(", "strings", ".", "Join", "(", "ss", ",", "newline", ")", ")", "\n", "r", ".", "extraFileContents", "=", "res", "\n", "return", "res", "\n", "}" ]

[ "humanReadableBytesNeedsLock", "should", "be", "called", "with", "lock", "already", "held", "." ]

[ "func", "(", "r", "*", "RemoteStatus", ")", "NewSpecialReadFunc", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "r", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "Unlock", "(", ")", "\n\n", "return", "r", ".", "humanReadableBytesLocked", "(", ")", ",", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}" ]

[ "NewSpecialReadFunc", "implements", "a", "special", "read", "file", "that", "contains", "human", "readable", "current", "status", "." ]

[ "func", "secWordListN", "(", "n", "int", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "res", "[", "]", "string", "\n", "max", ":=", "big", ".", "NewInt", "(", "int64", "(", "len", "(", "secwords", ")", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "n", ";", "i", "++", "{", "x", ",", "err", ":=", "rand", ".", "Int", "(", "rand", ".", "Reader", ",", "max", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "]", "string", "{", "}", ",", "err", "\n", "}", "\n", "res", "=", "append", "(", "res", ",", "secwords", "[", "x", ".", "Int64", "(", ")", "]", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "secWordListN", "returns", "n", "random", "words", "from", "secwords", "." ]

[ "func", "NewPath", "(", "pathStr", "string", ")", "(", "Path", ",", "error", ")", "{", "components", ",", "err", ":=", "split", "(", "pathStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Path", "{", "}", ",", "err", "\n", "}", "\n", "len", ":=", "len", "(", "components", ")", "\n\n", "if", "(", "len", ">=", "1", "&&", "components", "[", "0", "]", "!=", "topName", ")", "||", "(", "len", ">=", "2", "&&", "components", "[", "1", "]", "!=", "publicName", "&&", "components", "[", "1", "]", "!=", "privateName", ")", "{", "return", "Path", "{", "}", ",", "InvalidPathErr", "{", "pathStr", "}", "\n", "}", "\n\n", "if", "len", "==", "0", "{", "p", ":=", "Path", "{", "PathType", ":", "RootPathType", ",", "}", "\n", "return", "p", ",", "nil", "\n", "}", "\n\n", "if", "len", "==", "1", "{", "p", ":=", "Path", "{", "PathType", ":", "KeybasePathType", ",", "}", "\n", "return", "p", ",", "nil", "\n", "}", "\n\n", "if", "len", "==", "2", "{", "p", ":=", "Path", "{", "PathType", ":", "KeybaseChildPathType", ",", "TLFType", ":", "listTypeToTLFType", "(", "components", "[", "1", "]", ")", ",", "}", "\n", "return", "p", ",", "nil", "\n", "}", "\n\n", "p", ":=", "Path", "{", "PathType", ":", "TLFPathType", ",", "TLFType", ":", "listTypeToTLFType", "(", "components", "[", "1", "]", ")", ",", "TLFName", ":", "components", "[", "2", "]", ",", "TLFComponents", ":", "components", "[", "3", ":", "]", ",", "}", "\n", "return", "p", ",", "nil", "\n", "}" ]

[ "NewPath", "constructs", "a", "Path", "from", "a", "string" ]

[ "func", "(", "p", "Path", ")", "DirAndBasename", "(", ")", "(", "dir", "Path", ",", "basename", "string", ",", "err", "error", ")", "{", "switch", "p", ".", "PathType", "{", "case", "KeybasePathType", ":", "dir", "=", "Path", "{", "PathType", ":", "RootPathType", ",", "}", "\n", "basename", "=", "topName", "\n", "return", "\n\n", "case", "KeybaseChildPathType", ":", "dir", "=", "Path", "{", "PathType", ":", "KeybasePathType", ",", "}", "\n\n", "switch", "p", ".", "TLFType", "{", "case", "tlf", ".", "Public", ":", "basename", "=", "publicName", "\n", "case", "tlf", ".", "Private", ":", "basename", "=", "privateName", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "p", ".", "TLFType", ")", ")", "\n", "}", "\n", "return", "\n\n", "case", "TLFPathType", ":", "len", ":=", "len", "(", "p", ".", "TLFComponents", ")", "\n", "if", "len", "==", "0", "{", "dir", "=", "Path", "{", "PathType", ":", "KeybaseChildPathType", ",", "TLFType", ":", "p", ".", "TLFType", ",", "}", "\n", "basename", "=", "p", ".", "TLFName", "\n", "}", "else", "{", "dir", "=", "Path", "{", "PathType", ":", "TLFPathType", ",", "TLFType", ":", "p", ".", "TLFType", ",", "TLFName", ":", "p", ".", "TLFName", ",", "TLFComponents", ":", "p", ".", "TLFComponents", "[", ":", "len", "-", "1", "]", ",", "}", "\n", "basename", "=", "p", ".", "TLFComponents", "[", "len", "-", "1", "]", "\n", "}", "\n", "return", "\n", "}", "\n\n", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "return", "\n", "}" ]

[ "DirAndBasename", "returns", "directory", "and", "base", "filename" ]

[ "func", "(", "p", "Path", ")", "Join", "(", "childName", "string", ")", "(", "childPath", "Path", ",", "err", "error", ")", "{", "switch", "p", ".", "PathType", "{", "case", "RootPathType", ":", "if", "childName", "!=", "topName", "{", "err", "=", "CannotJoinPathErr", "{", "p", ",", "childName", "}", "\n", "return", "\n", "}", "\n\n", "childPath", "=", "Path", "{", "PathType", ":", "KeybasePathType", ",", "}", "\n", "return", "\n\n", "case", "KeybasePathType", ":", "if", "childName", "!=", "publicName", "&&", "childName", "!=", "privateName", "{", "err", "=", "CannotJoinPathErr", "{", "p", ",", "childName", "}", "\n", "}", "\n\n", "childPath", "=", "Path", "{", "PathType", ":", "KeybaseChildPathType", ",", "TLFType", ":", "listTypeToTLFType", "(", "childName", ")", ",", "}", "\n", "return", "\n\n", "case", "KeybaseChildPathType", ":", "childPath", "=", "Path", "{", "PathType", ":", "TLFPathType", ",", "TLFType", ":", "p", ".", "TLFType", ",", "TLFName", ":", "childName", ",", "}", "\n", "return", "\n\n", "case", "TLFPathType", ":", "childPath", "=", "Path", "{", "PathType", ":", "TLFPathType", ",", "TLFType", ":", "p", ".", "TLFType", ",", "TLFName", ":", "p", ".", "TLFName", ",", "TLFComponents", ":", "append", "(", "p", ".", "TLFComponents", ",", "childName", ")", ",", "}", "\n", "return", "\n", "}", "\n\n", "err", "=", "CannotJoinPathErr", "{", "p", ",", "childName", "}", "\n", "return", "\n", "}" ]

[ "Join", "will", "append", "a", "path", "to", "this", "path" ]

[ "func", "ParseTlfHandle", "(", "ctx", "context", ".", "Context", ",", "kbpki", "libkbfs", ".", "KBPKI", ",", "mdOps", "libkbfs", ".", "MDOps", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "name", "string", ",", "t", "tlf", ".", "Type", ")", "(", "*", "tlfhandle", ".", "Handle", ",", "error", ")", "{", "var", "tlfHandle", "*", "tlfhandle", ".", "Handle", "\n", "outer", ":", "for", "{", "var", "parseErr", "error", "\n", "tlfHandle", ",", "parseErr", "=", "tlfhandle", ".", "ParseHandle", "(", "ctx", ",", "kbpki", ",", "mdOps", ",", "osg", ",", "name", ",", "t", ")", "\n", "switch", "parseErr", ":=", "errors", ".", "Cause", "(", "parseErr", ")", ".", "(", "type", ")", "{", "case", "nil", ":", "// No error.", "break", "outer", "\n\n", "case", "idutil", ".", "TlfNameNotCanonical", ":", "// Non-canonical name, so try again.", "name", "=", "parseErr", ".", "NameToTry", "\n\n", "default", ":", "// Some other error.", "return", "nil", ",", "parseErr", "\n", "}", "\n", "}", "\n\n", "return", "tlfHandle", ",", "nil", "\n", "}" ]

[ "ParseTlfHandle", "is", "a", "wrapper", "around", "libkbfs", ".", "ParseTlfHandle", "that", "automatically", "resolves", "non", "-", "canonical", "names", "." ]

[ "func", "(", "p", "Path", ")", "GetNode", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ")", "(", "libkbfs", ".", "Node", ",", "data", ".", "EntryInfo", ",", "error", ")", "{", "if", "p", ".", "PathType", "!=", "TLFPathType", "{", "entryInfo", ":=", "data", ".", "EntryInfo", "{", "Type", ":", "data", ".", "Dir", ",", "}", "\n", "return", "nil", ",", "entryInfo", ",", "nil", "\n", "}", "\n\n", "tlfHandle", ",", "err", ":=", "ParseTlfHandle", "(", "ctx", ",", "config", ".", "KBPKI", "(", ")", ",", "config", ".", "MDOps", "(", ")", ",", "config", ",", "p", ".", "TLFName", ",", "p", ".", "TLFType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "data", ".", "EntryInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "node", ",", "entryInfo", ",", "err", ":=", "config", ".", "KBFSOps", "(", ")", ".", "GetOrCreateRootNode", "(", "ctx", ",", "tlfHandle", ",", "data", ".", "MasterBranch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "data", ".", "EntryInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "component", ":=", "range", "p", ".", "TLFComponents", "{", "lookupNode", ",", "lookupEntryInfo", ",", "lookupErr", ":=", "config", ".", "KBFSOps", "(", ")", ".", "Lookup", "(", "ctx", ",", "node", ",", "component", ")", "\n", "if", "lookupErr", "!=", "nil", "{", "return", "nil", ",", "data", ".", "EntryInfo", "{", "}", ",", "lookupErr", "\n", "}", "\n", "node", "=", "lookupNode", "\n", "entryInfo", "=", "lookupEntryInfo", "\n", "}", "\n\n", "return", "node", ",", "entryInfo", ",", "nil", "\n", "}" ]

[ "GetNode", "returns", "a", "node" ]

[ "func", "(", "p", "Path", ")", "GetFileNode", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ")", "(", "libkbfs", ".", "Node", ",", "error", ")", "{", "n", ",", "de", ",", "err", ":=", "p", ".", "GetNode", "(", "ctx", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// TODO: What to do with symlinks?", "if", "de", ".", "Type", "!=", "data", ".", "File", "&&", "de", ".", "Type", "!=", "data", ".", "Exec", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ",", "de", ".", "Type", ")", "\n", "}", "\n\n", "return", "n", ",", "nil", "\n", "}" ]

[ "GetFileNode", "returns", "a", "file", "node" ]

[ "func", "(", "p", "Path", ")", "GetDirNode", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ")", "(", "libkbfs", ".", "Node", ",", "error", ")", "{", "// TODO: Handle non-TLFPathTypes.", "n", ",", "de", ",", "err", ":=", "p", ".", "GetNode", "(", "ctx", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// TODO: What to do with symlinks?", "if", "de", ".", "Type", "!=", "data", ".", "Dir", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ",", "de", ".", "Type", ")", "\n", "}", "\n\n", "return", "n", ",", "nil", "\n", "}" ]

[ "GetDirNode", "returns", "a", "nil", "node", "if", "this", "doesn", "t", "have", "type", "TLFPathType" ]

[ "func", "(", "i", "IdentifyOutcome", ")", "NumProofFailures", "(", ")", "int", "{", "nfails", ":=", "0", "\n", "for", "_", ",", "c", ":=", "range", "i", ".", "ProofChecks", "{", "if", "c", ".", "err", "!=", "nil", "{", "nfails", "++", "\n", "}", "\n", "}", "\n", "return", "nfails", "\n", "}" ]

[ "The", "number", "of", "proofs", "that", "failed", "." ]

[ "func", "(", "i", "IdentifyOutcome", ")", "NumProofSuccesses", "(", ")", "int", "{", "nsucc", ":=", "0", "\n", "for", "_", ",", "c", ":=", "range", "i", ".", "ProofChecks", "{", "if", "c", ".", "err", "==", "nil", "{", "nsucc", "++", "\n", "}", "\n", "}", "\n", "return", "nsucc", "\n", "}" ]

[ "The", "number", "of", "proofs", "that", "actually", "worked" ]

[ "func", "(", "i", "IdentifyOutcome", ")", "NumTrackFailures", "(", ")", "int", "{", "ntf", ":=", "0", "\n", "check", ":=", "func", "(", "d", "TrackDiff", ")", "bool", "{", "return", "d", "!=", "nil", "&&", "d", ".", "BreaksTracking", "(", ")", "\n", "}", "\n", "for", "_", ",", "c", ":=", "range", "i", ".", "ProofChecks", "{", "if", "check", "(", "c", ".", "diff", ")", "||", "check", "(", "c", ".", "remoteDiff", ")", "{", "ntf", "++", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "k", ":=", "range", "i", ".", "KeyDiffs", "{", "if", "check", "(", "k", ")", "{", "ntf", "++", "\n", "}", "\n", "}", "\n\n", "return", "ntf", "\n", "}" ]

[ "A", "Track", "Failure", "is", "when", "we", "previously", "tracked", "this", "user", "and", "some", "aspect", "of", "their", "proof", "changed", ".", "Like", "their", "key", "changed", "or", "they", "changed", "Twitter", "names" ]

[ "func", "(", "i", "IdentifyOutcome", ")", "NumTrackChanges", "(", ")", "int", "{", "ntc", ":=", "0", "\n", "check", ":=", "func", "(", "d", "TrackDiff", ")", "bool", "{", "return", "d", "!=", "nil", "&&", "!", "d", ".", "IsSameAsTracked", "(", ")", "\n", "}", "\n", "for", "_", ",", "c", ":=", "range", "i", ".", "ProofChecks", "{", "if", "check", "(", "c", ".", "diff", ")", "||", "check", "(", "c", ".", "remoteDiff", ")", "{", "ntc", "++", "\n", "}", "\n", "}", "\n", "for", "_", ",", "k", ":=", "range", "i", ".", "KeyDiffs", "{", "if", "check", "(", "k", ")", "{", "ntc", "++", "\n", "}", "\n", "}", "\n", "return", "ntc", "\n", "}" ]

[ "A", "Track", "Change", "isn", "t", "necessary", "a", "failure", "maybe", "they", "upgraded", "a", "proof", "from", "HTTP", "to", "HTTPS", ".", "But", "we", "still", "should", "retrack", "if", "we", "can", "." ]

[ "func", "GetMaybeAdminByStringName", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "name", "string", ",", "public", "bool", ")", "(", "*", "Team", ",", "error", ")", "{", "// Find out our up-to-date role.", "team", ",", "err", ":=", "Load", "(", "ctx", ",", "g", ",", "keybase1", ".", "LoadTeamArg", "{", "Name", ":", "name", ",", "Public", ":", "public", ",", "ForceRepoll", ":", "true", ",", "RefreshUIDMapper", ":", "true", ",", "AllowNameLookupBurstCache", ":", "true", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fixupTeamGetError", "(", "ctx", ",", "g", ",", "err", ",", "name", ",", "public", ")", "\n", "}", "\n", "me", ",", "err", ":=", "loadUserVersionByUID", "(", "ctx", ",", "g", ",", "g", ".", "Env", ".", "GetUID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "role", ",", "err", ":=", "team", ".", "MemberRole", "(", "ctx", ",", "me", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "role", ".", "IsAdminOrAbove", "(", ")", "{", "// Will hit the cache _unless_ we had a cached non-admin team", "// and are now an admin.", "team", ",", "err", "=", "Load", "(", "ctx", ",", "g", ",", "keybase1", ".", "LoadTeamArg", "{", "Name", ":", "name", ",", "Public", ":", "public", ",", "NeedAdmin", ":", "true", ",", "AllowNameLookupBurstCache", ":", "true", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "team", ",", "nil", "\n", "}" ]

[ "Get", "a", "team", "with", "no", "stubbed", "links", "if", "we", "are", "an", "admin", ".", "Use", "this", "instead", "of", "NeedAdmin", "when", "you", "don", "t", "know", "whether", "you", "are", "an", "admin", ".", "This", "always", "causes", "roundtrips", ".", "Doesn", "t", "work", "for", "implicit", "admins", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "loadDirAllowNonexistent", "(", "ctx", "context", ".", "Context", ")", "(", "*", "Dir", ",", "bool", ",", "error", ")", "{", "return", "tlf", ".", "loadDirHelper", "(", "ctx", ",", "libkbfs", ".", "ReadMode", ",", "data", ".", "MasterBranch", ",", "true", ")", "\n", "}" ]

[ "loadDirAllowNonexistent", "loads", "a", "TLF", "if", "it", "s", "not", "already", "loaded", ".", "If", "the", "TLF", "doesn", "t", "yet", "exist", "it", "still", "returns", "a", "nil", "error", "and", "indicates", "that", "the", "calling", "function", "should", "pretend", "it", "s", "an", "empty", "folder", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Attr", "(", "ctx", "context", ".", "Context", ",", "a", "*", "fuse", ".", "Attr", ")", "error", "{", "dir", ":=", "tlf", ".", "getStoredDir", "(", ")", "\n", "a", ".", "Inode", "=", "tlf", ".", "inode", "\n", "if", "dir", "==", "nil", "{", "tlf", ".", "vlog", "(", ")", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "tlf", ".", "folder", ".", "name", "(", ")", ")", "\n", "// Have a low non-zero value for Valid to avoid being", "// swamped with requests, while still not showing", "// stale data for too long if we end up loading the", "// dir.", "a", ".", "Valid", "=", "1", "*", "time", ".", "Second", "\n", "a", ".", "Mode", "=", "os", ".", "ModeDir", "|", "0500", "\n", "a", ".", "Uid", "=", "uint32", "(", "os", ".", "Getuid", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n\n", "return", "dir", ".", "Attr", "(", "ctx", ",", "a", ")", "\n", "}" ]

[ "Attr", "implements", "the", "fs", ".", "Node", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Lookup", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "LookupRequest", ",", "resp", "*", "fuse", ".", "LookupResponse", ")", "(", "fs", ".", "Node", ",", "error", ")", "{", "if", "tlfLoadAvoidingLookupNames", "[", "req", ".", "Name", "]", "{", "dir", ":=", "tlf", ".", "getStoredDir", "(", ")", "\n", "if", "dir", "==", "nil", "{", "tlf", ".", "vlog", "(", ")", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "req", ".", "Name", ")", "\n", "return", "nil", ",", "fuse", ".", "ENOENT", "\n", "}", "\n", "return", "dir", ".", "Lookup", "(", "ctx", ",", "req", ",", "resp", ")", "\n", "}", "\n\n", "dir", ",", "exitEarly", ",", "err", ":=", "tlf", ".", "loadDirAllowNonexistent", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "exitEarly", "{", "if", "node", ":=", "handleTLFSpecialFile", "(", "req", ".", "Name", ",", "tlf", ".", "folder", ",", "&", "resp", ".", "EntryValid", ")", ";", "node", "!=", "nil", "{", "return", "node", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "fuse", ".", "ENOENT", "\n", "}", "\n\n", "branch", ",", "isArchivedBranch", ":=", "libfs", ".", "BranchNameFromArchiveRefDir", "(", "req", ".", "Name", ")", "\n", "if", "isArchivedBranch", "{", "archivedTLF", ":=", "newTLF", "(", "ctx", ",", "tlf", ".", "folder", ".", "list", ",", "tlf", ".", "folder", ".", "h", ",", "tlf", ".", "folder", ".", "hPreferredName", ")", "\n", "_", ",", "_", ",", "err", ":=", "archivedTLF", ".", "loadArchivedDir", "(", "ctx", ",", "branch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "archivedTLF", ",", "nil", "\n", "}", "\n\n", "linkTarget", ",", "isArchivedTimeLink", ",", "err", ":=", "libfs", ".", "LinkTargetFromTimeString", "(", "ctx", ",", "tlf", ".", "folder", ".", "fs", ".", "config", ",", "tlf", ".", "folder", ".", "h", ",", "req", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "isArchivedTimeLink", "{", "return", "&", "Alias", "{", "realPath", ":", "linkTarget", ",", "inode", ":", "0", ",", "}", ",", "nil", "\n", "}", "\n\n", "_", ",", "isRelTimeLink", ",", "err", ":=", "libfs", ".", "FileDataFromRelativeTimeString", "(", "ctx", ",", "tlf", ".", "folder", ".", "fs", ".", "config", ",", "tlf", ".", "folder", ".", "h", ",", "req", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "isRelTimeLink", "{", "return", "NewArchiveRelTimeFile", "(", "tlf", ".", "folder", ".", "fs", ",", "tlf", ".", "folder", ".", "h", ",", "req", ".", "Name", ",", "&", "resp", ".", "EntryValid", ")", ",", "nil", "\n", "}", "\n\n", "return", "dir", ".", "Lookup", "(", "ctx", ",", "req", ",", "resp", ")", "\n", "}" ]

[ "Lookup", "implements", "the", "fs", ".", "NodeRequestLookuper", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "CreateRequest", ",", "resp", "*", "fuse", ".", "CreateResponse", ")", "(", "fs", ".", "Node", ",", "fs", ".", "Handle", ",", "error", ")", "{", "dir", ",", "err", ":=", "tlf", ".", "loadDir", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "return", "dir", ".", "Create", "(", "ctx", ",", "req", ",", "resp", ")", "\n", "}" ]

[ "Create", "implements", "the", "fs", ".", "NodeCreater", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Mkdir", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "MkdirRequest", ")", "(", "_", "fs", ".", "Node", ",", "err", "error", ")", "{", "dir", ",", "err", ":=", "tlf", ".", "loadDir", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "dir", ".", "Mkdir", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "Mkdir", "implements", "the", "fs", ".", "NodeMkdirer", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Symlink", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "SymlinkRequest", ")", "(", "fs", ".", "Node", ",", "error", ")", "{", "dir", ",", "err", ":=", "tlf", ".", "loadDir", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "dir", ".", "Symlink", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "Symlink", "implements", "the", "fs", ".", "NodeSymlinker", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Rename", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "RenameRequest", ",", "newDir", "fs", ".", "Node", ")", "error", "{", "dir", ",", "err", ":=", "tlf", ".", "loadDir", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "dir", ".", "Rename", "(", "ctx", ",", "req", ",", "newDir", ")", "\n", "}" ]

[ "Rename", "implements", "the", "fs", ".", "NodeRenamer", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Remove", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "RemoveRequest", ")", "error", "{", "dir", ",", "err", ":=", "tlf", ".", "loadDir", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "dir", ".", "Remove", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "Remove", "implements", "the", "fs", ".", "NodeRemover", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "ReadDirAll", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "fuse", ".", "Dirent", ",", "error", ")", "{", "dir", ",", "exitEarly", ",", "err", ":=", "tlf", ".", "loadDirAllowNonexistent", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "||", "exitEarly", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "dir", ".", "ReadDirAll", "(", "ctx", ")", "\n", "}" ]

[ "ReadDirAll", "implements", "the", "fs", ".", "NodeReadDirAller", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Setattr", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "SetattrRequest", ",", "resp", "*", "fuse", ".", "SetattrResponse", ")", "error", "{", "dir", ",", "err", ":=", "tlf", ".", "loadDir", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "dir", ".", "Setattr", "(", "ctx", ",", "req", ",", "resp", ")", "\n", "}" ]

[ "Setattr", "implements", "the", "fs", ".", "NodeSetattrer", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Fsync", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "FsyncRequest", ")", "(", "err", "error", ")", "{", "dir", ":=", "tlf", ".", "getStoredDir", "(", ")", "\n", "if", "dir", "==", "nil", "{", "// The directory hasn't been loaded yet, so there's nothing to do.", "return", "nil", "\n", "}", "\n\n", "return", "dir", ".", "Fsync", "(", "ctx", ",", "req", ")", "\n", "}" ]

[ "Fsync", "implements", "the", "fs", ".", "NodeFsyncer", "interface", "for", "TLF", "." ]

[ "func", "(", "tlf", "*", "TLF", ")", "Open", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "OpenRequest", ",", "resp", "*", "fuse", ".", "OpenResponse", ")", "(", "fs", ".", "Handle", ",", "error", ")", "{", "// Explicitly load the directory when a TLF is opened, because", "// some OSX programs like ls have a bug that doesn't report errors", "// on a ReadDirAll.", "_", ",", "_", ",", "err", ":=", "tlf", ".", "loadDirAllowNonexistent", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "tlf", ",", "nil", "\n", "}" ]

[ "Open", "implements", "the", "fs", ".", "NodeOpener", "interface", "for", "TLF", "." ]

[ "func", "(", "c", "ReachabilityClient", ")", "StartReachability", "(", "ctx", "context", ".", "Context", ")", "(", "res", "Reachability", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "StartReachabilityArg", "{", "}", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Start", "reachability", "checks", "and", "return", "current", "status", "which", "may", "be", "cached", "." ]

[ "func", "(", "c", "ReachabilityClient", ")", "CheckReachability", "(", "ctx", "context", ".", "Context", ")", "(", "res", "Reachability", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "CheckReachabilityArg", "{", "}", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Performs", "a", "reachability", "check", ".", "This", "is", "not", "a", "cached", "response", "." ]

[ "func", "(", "sc", "*", "StateChecker", ")", "findAllFileBlocks", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "ops", "*", "folderBranchOps", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "file", "data", ".", "Path", ",", "blockSizes", "map", "[", "data", ".", "BlockPointer", "]", "uint32", ")", "error", "{", "infos", ",", "err", ":=", "ops", ".", "blocks", ".", "GetIndirectFileBlockInfos", "(", "ctx", ",", "lState", ",", "kmd", ",", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "info", ":=", "range", "infos", "{", "blockSizes", "[", "info", ".", "BlockPointer", "]", "=", "info", ".", "EncodedSize", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "findAllFileBlocks", "adds", "all", "file", "blocks", "found", "under", "this", "block", "to", "the", "blockSizes", "map", "if", "the", "given", "path", "represents", "an", "indirect", "block", "." ]

[ "func", "(", "sc", "*", "StateChecker", ")", "findAllBlocksInPath", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "ops", "*", "folderBranchOps", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "dir", "data", ".", "Path", ",", "blockSizes", "map", "[", "data", ".", "BlockPointer", "]", "uint32", ")", "error", "{", "children", ",", "err", ":=", "ops", ".", "blocks", ".", "GetEntries", "(", "ctx", ",", "lState", ",", "kmd", ",", "dir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "sc", ".", "findAllDirBlocks", "(", "ctx", ",", "lState", ",", "ops", ",", "kmd", ",", "dir", ",", "blockSizes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "name", ",", "de", ":=", "range", "children", "{", "if", "de", ".", "Type", "==", "data", ".", "Sym", "{", "continue", "\n", "}", "\n\n", "blockSizes", "[", "de", ".", "BlockPointer", "]", "=", "de", ".", "EncodedSize", "\n", "p", ":=", "dir", ".", "ChildPath", "(", "name", ",", "de", ".", "BlockPointer", ")", "\n\n", "if", "de", ".", "Type", "==", "data", ".", "Dir", "{", "err", ":=", "sc", ".", "findAllBlocksInPath", "(", "ctx", ",", "lState", ",", "ops", ",", "kmd", ",", "p", ",", "blockSizes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "// If it's a file, check to see if it's indirect.", "err", ":=", "sc", ".", "findAllFileBlocks", "(", "ctx", ",", "lState", ",", "ops", ",", "kmd", ",", "p", ",", "blockSizes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "findAllBlocksInPath", "adds", "all", "blocks", "found", "within", "this", "directory", "to", "the", "blockSizes", "map", "and", "then", "recursively", "checks", "all", "subdirectories", "." ]

[ "func", "(", "dbcm", "DiskBlockCacheMetadata", ")", "PrefetchStatus", "(", ")", "PrefetchStatus", "{", "if", "dbcm", ".", "FinishedPrefetch", "{", "return", "FinishedPrefetch", "\n", "}", "else", "if", "dbcm", ".", "TriggeredPrefetch", "{", "return", "TriggeredPrefetch", "\n", "}", "\n", "return", "NoPrefetch", "\n", "}" ]

[ "PrefetchStatus", "returns", "the", "overall", "prefetch", "status", "corresponding", "to", "this", "metadata", "." ]

[ "func", "(", "w", "*", "CheckerWrapper", ")", "Check", "(", "m", "MetaContext", ",", "s", "string", ")", "error", "{", "if", "w", ".", "checker", ".", "F", "(", "s", ")", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "New", "(", "w", ".", "checker", ".", "Hint", ")", "\n", "}" ]

[ "Check", "s", "using", "checker", "respond", "with", "checker", ".", "Hint", "if", "check", "fails", "." ]

[ "func", "(", "p", "*", "PaperChecker", ")", "Check", "(", "m", "MetaContext", ",", "s", "string", ")", "error", "{", "phrase", ":=", "NewPaperKeyPhrase", "(", "s", ")", "\n\n", "// check for empty", "if", "len", "(", "phrase", ".", "String", "(", ")", ")", "==", "0", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "PassphraseError", "{", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n\n", "// check for at least PaperKeyWordCountMin words", "if", "phrase", ".", "NumWords", "(", ")", "<", "PaperKeyWordCountMin", "{", "return", "PassphraseError", "{", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n\n", "// check for invalid words", "invalids", ":=", "phrase", ".", "InvalidWords", "(", ")", "\n", "if", "len", "(", "invalids", ")", ">", "0", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "var", "perr", "PassphraseError", "\n", "if", "len", "(", "invalids", ")", ">", "1", "{", "perr", ".", "Msg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "invalids", ",", "\"", "\"", ")", ")", "\n", "}", "else", "{", "perr", ".", "Msg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "invalids", "[", "0", "]", ")", "\n", "}", "\n", "return", "perr", "\n", "}", "\n\n", "// check version", "version", ",", "err", ":=", "phrase", ".", "Version", "(", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "// despite the error, just tell the user the paper key is wrong:", "return", "PassphraseError", "{", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n", "if", "version", "!=", "PaperKeyVersion", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "version", ",", "PaperKeyVersion", ")", "\n", "return", "PassphraseError", "{", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Check", "a", "paper", "key", "format", ".", "Will", "return", "a", "detailed", "error", "message", "specific", "to", "the", "problems", "found", "in", "s", "." ]

[ "func", "GetTriplesecMaybePrompt", "(", "m", "MetaContext", ")", "(", "tsec", "Triplesec", ",", "ppgen", "PassphraseGeneration", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// 1. try cached", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "tsec", ",", "ppgen", "=", "m", ".", "TriplesecAndGeneration", "(", ")", ";", "tsec", "!=", "nil", "&&", "!", "ppgen", ".", "IsNil", "(", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "tsec", ",", "ppgen", ",", "nil", "\n", "}", "\n\n", "// 2. login and get it", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "var", "pps", "*", "PassphraseStream", "\n", "pps", ",", "tsec", ",", "err", "=", "GetPassphraseStreamViaPrompt", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "ppgen", ",", "err", "\n", "}", "\n", "if", "pps", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "ppgen", ",", "NewNoTriplesecError", "(", ")", "\n", "}", "\n", "if", "tsec", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "ppgen", ",", "NewNoTriplesecError", "(", ")", "\n", "}", "\n", "ppgen", "=", "pps", ".", "Generation", "(", ")", "\n", "if", "ppgen", ".", "IsNil", "(", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "ppgen", ",", "NewNoTriplesecError", "(", ")", "\n", "}", "\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "tsec", ",", "ppgen", ",", "err", "\n", "}" ]

[ "GetTriplesecMaybePrompt", "will", "try", "to", "get", "the", "user", "s", "current", "triplesec", ".", "It", "will", "either", "pluck", "it", "out", "of", "the", "environment", "or", "prompt", "the", "user", "for", "a", "passphrase", "if", "it", "can", "t", "be", "found", ".", "The", "secret", "store", "is", "of", "no", "use", "here", "so", "skip", "it", ".", "Recall", "that", "the", "full", "passphrase", "stream", "isn", "t", "stored", "to", "the", "secret", "store", "only", "the", "bits", "that", "encrypt", "local", "keys", "." ]

[ "func", "GetPassphraseStreamViaPrompt", "(", "m", "MetaContext", ")", "(", "pps", "*", "PassphraseStream", ",", "tsec", "Triplesec", ",", "err", "error", ")", "{", "// We have to get the current username before we install the new provisional login context,", "// which will shadow the logged in username.", "nun", ":=", "m", ".", "CurrentUsername", "(", ")", "\n", "defer", "m", ".", "Trace", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "nun", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "m", "=", "m", ".", "WithNewProvisionalLoginContext", "(", ")", "\n", "err", "=", "PassphraseLoginPromptThenSecretStore", "(", "m", ",", "nun", ".", "String", "(", ")", ",", "5", ",", "false", "/* failOnStoreError */", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "pps", ",", "tsec", "=", "m", ".", "PassphraseStreamAndTriplesec", "(", ")", "\n", "m", ".", "CommitProvisionalLogin", "(", ")", "\n\n", "return", "pps", ",", "tsec", ",", "nil", "\n", "}" ]

[ "GetPassphraseStreamViaPrompt", "prompts", "the", "user", "for", "a", "passphrase", "and", "on", "success", "returns", "a", "PassphraseStream", "and", "Triplesec", "derived", "from", "the", "user", "s", "passphrase", ".", "As", "a", "side", "effect", "it", "stores", "the", "full", "LKSec", "in", "the", "secret", "store", "." ]

[ "func", "GetPassphraseStreamViaPromptInLoginContext", "(", "m", "MetaContext", ")", "(", "pps", "*", "PassphraseStream", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "if", "pps", "=", "m", ".", "PassphraseStream", "(", ")", ";", "pps", "!=", "nil", "{", "return", "pps", ",", "nil", "\n", "}", "\n", "nun", ":=", "m", ".", "CurrentUsername", "(", ")", "\n", "if", "nun", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "NewNoUsernameError", "(", ")", "\n", "}", "\n", "if", "err", "=", "PassphraseLoginPrompt", "(", "m", ",", "nun", ".", "String", "(", ")", ",", "5", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "m", ".", "PassphraseStream", "(", ")", ",", "nil", "\n", "}" ]

[ "GetFullPassphraseStreamViaPrompt", "gets", "the", "user", "s", "passphrase", "stream", "either", "cached", "from", "the", "LoginContext", "or", "from", "the", "prompt", ".", "It", "doesn", "t", "involve", "the", "secret", "store", "at", "all", "since", "the", "full", "passphrase", "stream", "isn", "t", "stored", "in", "the", "secret", "store", ".", "And", "also", "it", "doesn", "t", "write", "the", "secret", "store", "because", "this", "function", "is", "called", "right", "before", "the", "user", "changes", "to", "a", "new", "passphrase", "so", "what", "s", "the", "point", ".", "It", "s", "assumed", "that", "the", "login", "context", "is", "set", "to", "non", "-", "nil", "by", "the", "caller", "." ]

[ "func", "VerifyPassphraseGetStreamInLoginContext", "(", "m", "MetaContext", ",", "passphrase", "string", ")", "(", "pps", "*", "PassphraseStream", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "nun", ":=", "m", ".", "CurrentUsername", "(", ")", "\n", "if", "nun", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "NewNoUsernameError", "(", ")", "\n", "}", "\n", "if", "err", "=", "PassphraseLoginNoPrompt", "(", "m", ",", "nun", ".", "String", "(", ")", ",", "passphrase", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "m", ".", "PassphraseStream", "(", ")", ",", "nil", "\n", "}" ]

[ "VerifyPassphraseGetFullStream", "verifies", "the", "current", "passphrase", "is", "a", "correct", "login", "and", "if", "so", "will", "return", "a", "full", "passphrase", "stream", "derived", "from", "it", ".", "Assumes", "the", "caller", "made", "a", "non", "-", "nil", "LoginContext", "for", "us", "to", "operate", "in", "." ]

[ "func", "VerifyPassphraseForLoggedInUser", "(", "m", "MetaContext", ",", "pp", "string", ")", "(", "pps", "*", "PassphraseStream", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "uv", ",", "un", ":=", "m", ".", "ActiveDevice", "(", ")", ".", "GetUsernameAndUserVersionIfValid", "(", "m", ")", "\n", "if", "uv", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "NewLoginRequiredError", "(", "\"", "\"", ")", "\n", "}", "\n", "m", "=", "m", ".", "WithNewProvisionalLoginContextForUserVersionAndUsername", "(", "uv", ",", "un", ")", "\n", "pps", ",", "err", "=", "VerifyPassphraseGetStreamInLoginContext", "(", "m", ",", "pp", ")", "\n", "return", "pps", ",", "err", "\n", "}" ]

[ "VerifyPassphraseForLoggedInUser", "verifies", "that", "the", "current", "passphrase", "is", "correct", "for", "the", "logged", "in", "user", "returning", "nil", "if", "correct", "and", "an", "error", "if", "not", ".", "Only", "used", "in", "tests", "right", "now", "but", "it", "s", "fine", "to", "use", "in", "production", "code", "if", "it", "seems", "appropriate", "." ]

[ "func", "ComputeLoginPackage2", "(", "m", "MetaContext", ",", "pps", "*", "PassphraseStream", ")", "(", "ret", "PDPKALoginPackage", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "var", "ls", "*", "LoginSession", "\n", "if", "m", ".", "LoginContext", "(", ")", "!=", "nil", "{", "ls", "=", "m", ".", "LoginContext", "(", ")", ".", "LoginSession", "(", ")", "\n", "}", "\n", "if", "ls", "==", "nil", "{", "ls", ",", "err", "=", "pplGetLoginSession", "(", "m", ",", "m", ".", "CurrentUsername", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ret", ",", "err", "\n", "}", "\n", "}", "\n", "var", "loginSessionRaw", "[", "]", "byte", "\n", "loginSessionRaw", ",", "err", "=", "ls", ".", "Session", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ret", ",", "err", "\n", "}", "\n", "return", "computeLoginPackageFromUID", "(", "m", ".", "CurrentUID", "(", ")", ",", "pps", ",", "loginSessionRaw", ")", "\n", "}" ]

[ "ComputeLoginPackage2", "computes", "the", "login", "package", "for", "the", "given", "UID", "as", "dictated", "by", "the", "context", ".", "It", "assumes", "that", "a", "passphrase", "stream", "has", "already", "been", "loaded", ".", "A", "LoginSession", "is", "optional", ".", "If", "not", "available", "a", "new", "one", "is", "requested", ".", "Eventually", "we", "will", "kill", "ComputeLoginPackage", "and", "rename", "this", "to", "that", "." ]

[ "func", "UnverifiedPassphraseStream", "(", "m", "MetaContext", ",", "uid", "keybase1", ".", "UID", ",", "passphrase", "string", ")", "(", "tsec", "Triplesec", ",", "ret", "*", "PassphraseStream", ",", "err", "error", ")", "{", "var", "salt", "[", "]", "byte", "\n", "if", "lctx", ":=", "m", ".", "LoginContext", "(", ")", ";", "lctx", "!=", "nil", "&&", "lctx", ".", "GetUID", "(", ")", ".", "Equal", "(", "uid", ")", "{", "salt", "=", "lctx", ".", "Salt", "(", ")", "\n", "}", "\n", "if", "salt", "==", "nil", "{", "salt", ",", "err", "=", "LookupSaltForUID", "(", "m", ",", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "StretchPassphrase", "(", "m", ".", "G", "(", ")", ",", "passphrase", ",", "salt", ")", "\n", "}" ]

[ "UnverifiedPassphraseStream", "takes", "a", "passphrase", "as", "a", "parameter", "and", "also", "the", "salt", "from", "the", "Account", "and", "computes", "a", "Triplesec", "and", "a", "passphrase", "stream", ".", "It", "s", "not", "verified", "through", "a", "Login", "." ]

[ "func", "NewPerUserKeyRoll", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "args", "*", "PerUserKeyRollArgs", ")", "*", "PerUserKeyRoll", "{", "return", "&", "PerUserKeyRoll", "{", "args", ":", "args", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewPerUserKeyRoll", "creates", "a", "PerUserKeyRoll", "engine", "." ]

[ "func", "(", "e", "*", "PerUserKeyRoll", ")", "getPukReceivers", "(", "mctx", "libkb", ".", "MetaContext", ",", "meUPAK", "*", "keybase1", ".", "UserPlusAllKeys", ")", "(", "res", "[", "]", "libkb", ".", "NaclDHKeyPair", ",", "err", "error", ")", "{", "for", "_", ",", "dk", ":=", "range", "meUPAK", ".", "Base", ".", "DeviceKeys", "{", "if", "dk", ".", "IsSibkey", "==", "false", "&&", "!", "dk", ".", "IsRevoked", "{", "receiver", ",", "err", ":=", "libkb", ".", "ImportNaclDHKeyPairFromHex", "(", "dk", ".", "KID", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "res", "=", "append", "(", "res", ",", "receiver", ")", "\n", "}", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "Get", "the", "receivers", "of", "the", "new", "per", "-", "user", "-", "key", "boxes", ".", "Includes", "all", "the", "user", "s", "device", "subkeys", "." ]

[ "func", "newDiskBlockMetadataStore", "(", "config", "diskBlockMetadataStoreConfig", ")", "(", "BlockMetadataStore", ",", "error", ")", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "db", ",", "err", ":=", "openVersionedLevelDB", "(", "log", ",", "config", ".", "StorageRoot", "(", ")", ",", "blockMetadataFolderName", ",", "currentBlockMetadataStoreVersion", ",", "blockMetadataDbFilename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "diskBlockMetadataStore", "{", "log", ":", "log", ",", "config", ":", "config", ",", "hitMeter", ":", "NewCountMeter", "(", ")", ",", "missMeter", ":", "NewCountMeter", "(", ")", ",", "putMeter", ":", "NewCountMeter", "(", ")", ",", "db", ":", "db", ",", "shutdownCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", ",", "err", "\n", "}" ]

[ "newDiskBlockMetadataStore", "creates", "a", "new", "disk", "BlockMetadata", "storage", "." ]

[ "func", "(", "s", "*", "diskBlockMetadataStore", ")", "Shutdown", "(", ")", "{", "s", ".", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "Unlock", "(", ")", "\n", "// shutdownCh has to be checked under lock, otherwise we can race.", "select", "{", "case", "<-", "s", ".", "shutdownCh", ":", "s", ".", "log", ".", "Warning", "(", "\"", "\"", ")", "\n", "default", ":", "}", "\n", "close", "(", "s", ".", "shutdownCh", ")", "\n", "if", "s", ".", "db", "==", "nil", "{", "return", "\n", "}", "\n", "s", ".", "db", ".", "Close", "(", ")", "\n", "s", ".", "db", "=", "nil", "\n", "s", ".", "hitMeter", ".", "Shutdown", "(", ")", "\n", "s", ".", "missMeter", ".", "Shutdown", "(", ")", "\n", "s", ".", "putMeter", ".", "Shutdown", "(", ")", "\n", "}" ]

[ "Shutdown", "shuts", "done", "this", "storae", "." ]

[ "func", "(", "s", "*", "diskBlockMetadataStore", ")", "GetMetadata", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ")", "(", "value", "BlockMetadataValue", ",", "err", "error", ")", "{", "s", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "select", "{", "case", "<-", "s", ".", "shutdownCh", ":", "return", "BlockMetadataValue", "{", "}", ",", "ErrBlockMetadataStoreShutdown", "{", "}", "\n", "default", ":", "}", "\n\n", "encoded", ",", "err", ":=", "s", ".", "db", ".", "GetWithMeter", "(", "blockID", ".", "Bytes", "(", ")", ",", "s", ".", "hitMeter", ",", "s", ".", "missMeter", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", "{", "case", "ldberrors", ".", "ErrNotFound", ":", "return", "BlockMetadataValue", "{", "}", ",", "err", "\n", "case", "nil", ":", "if", "err", "=", "s", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "encoded", ",", "&", "value", ")", ";", "err", "!=", "nil", "{", "s", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "BlockMetadataValue", "{", "}", ",", "ldberrors", ".", "ErrNotFound", "\n", "}", "\n", "return", "value", ",", "nil", "\n", "default", ":", "s", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "BlockMetadataValue", "{", "}", ",", "ldberrors", ".", "ErrNotFound", "\n", "}", "\n", "}" ]

[ "GetMetadata", "implements", "the", "BlockMetadataStore", "interface", "." ]

[ "func", "(", "s", "*", "diskBlockMetadataStore", ")", "UpdateMetadata", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ",", "updater", "BlockMetadataUpdater", ")", "error", "{", "bid", ":=", "blockID", ".", "Bytes", "(", ")", "\n\n", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "select", "{", "case", "<-", "s", ".", "shutdownCh", ":", "return", "ErrBlockMetadataStoreShutdown", "{", "}", "\n", "default", ":", "}", "\n\n", "var", "value", "BlockMetadataValue", "\n", "encoded", ",", "err", ":=", "s", ".", "db", ".", "Get", "(", "bid", ",", "nil", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", "{", "case", "ldberrors", ".", "ErrNotFound", ":", "case", "nil", ":", "if", "err", "=", "s", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "encoded", ",", "&", "value", ")", ";", "err", "!=", "nil", "{", "s", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "default", ":", "s", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "updater", "(", "&", "value", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "encoded", ",", "err", "=", "s", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "value", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "s", ".", "db", ".", "PutWithMeter", "(", "bid", ",", "encoded", ",", "s", ".", "putMeter", ")", "\n", "}" ]

[ "UpdateMetadata", "implements", "the", "BlockMetadataStore", "interface", "." ]

[ "func", "NewXattrStoreFromBlockMetadataStore", "(", "store", "BlockMetadataStore", ")", "XattrStore", "{", "return", "xattrStore", "{", "store", ":", "store", ",", "hitMeter", ":", "NewCountMeter", "(", ")", ",", "missMeter", ":", "NewCountMeter", "(", ")", ",", "putMeter", ":", "NewCountMeter", "(", ")", ",", "}", "\n", "}" ]

[ "NewXattrStoreFromBlockMetadataStore", "returns", "a", "XattrStore", "which", "is", "a", "wrapper", "around", "the", "passed", "in", "store", "." ]

[ "func", "(", "s", "xattrStore", ")", "GetXattr", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ",", "xattrType", "XattrType", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "blockMetadata", ",", "err", ":=", "s", ".", "store", ".", "GetMetadata", "(", "ctx", ",", "blockID", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", "{", "case", "ldberrors", ".", "ErrNotFound", ":", "s", ".", "missMeter", ".", "Mark", "(", "1", ")", "\n", "return", "nil", ",", "err", "\n", "case", "nil", ":", "default", ":", "return", "nil", ",", "err", "\n", "}", "\n\n", "v", ",", "ok", ":=", "blockMetadata", ".", "Xattr", "[", "xattrType", "]", "\n", "if", "!", "ok", "{", "s", ".", "missMeter", ".", "Mark", "(", "1", ")", "\n", "return", "nil", ",", "ldberrors", ".", "ErrNotFound", "\n", "}", "\n\n", "s", ".", "hitMeter", ".", "Mark", "(", "1", ")", "\n", "return", "v", ",", "nil", "\n", "}" ]

[ "GetXattr", "implements", "the", "XattrStore", "interface", "." ]

[ "func", "(", "s", "xattrStore", ")", "SetXattr", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ",", "xattrType", "XattrType", ",", "xattrValue", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "if", "err", "=", "s", ".", "store", ".", "UpdateMetadata", "(", "ctx", ",", "blockID", ",", "func", "(", "v", "*", "BlockMetadataValue", ")", "error", "{", "if", "v", ".", "Xattr", "==", "nil", "{", "v", ".", "Xattr", "=", "make", "(", "map", "[", "XattrType", "]", "[", "]", "byte", ")", "\n", "}", "\n", "v", ".", "Xattr", "[", "xattrType", "]", "=", "xattrValue", "\n", "return", "nil", "\n", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "s", ".", "putMeter", ".", "Mark", "(", "1", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetXattr", "implements", "the", "XattrStore", "interface", "." ]

[ "func", "(", "NoopBlockMetadataStore", ")", "GetMetadata", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ")", "(", "value", "BlockMetadataValue", ",", "err", "error", ")", "{", "return", "BlockMetadataValue", "{", "}", ",", "ldberrors", ".", "ErrNotFound", "\n", "}" ]

[ "GetMetadata", "always", "returns", "ldberrors", ".", "ErrNotFound", "." ]

[ "func", "(", "NoopBlockMetadataStore", ")", "UpdateMetadata", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ",", "updater", "BlockMetadataUpdater", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "UpdateMetadata", "returns", "nil", "error", "but", "does", "nothing", "." ]

[ "func", "NewCryptoClientRPC", "(", "config", "Config", ",", "kbCtx", "Context", ")", "*", "CryptoClientRPC", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "deferLog", ":=", "log", ".", "CloneWithAddedDepth", "(", "1", ")", "\n", "c", ":=", "&", "CryptoClientRPC", "{", "CryptoClient", ":", "CryptoClient", "{", "CryptoCommon", ":", "MakeCryptoCommon", "(", "config", ".", "Codec", "(", ")", ",", "config", ")", ",", "log", ":", "log", ",", "deferLog", ":", "deferLog", ",", "}", ",", "config", ":", "config", ",", "}", "\n", "conn", ":=", "NewSharedKeybaseConnection", "(", "kbCtx", ",", "config", ",", "c", ")", "\n", "c", ".", "CryptoClient", ".", "client", "=", "keybase1", ".", "CryptoClient", "{", "Cli", ":", "conn", ".", "GetClient", "(", ")", "}", "\n", "c", ".", "CryptoClient", ".", "teamsClient", "=", "keybase1", ".", "TeamsClient", "{", "Cli", ":", "conn", ".", "GetClient", "(", ")", "}", "\n", "c", ".", "CryptoClient", ".", "shutdownFn", "=", "conn", ".", "Shutdown", "\n", "return", "c", "\n", "}" ]

[ "NewCryptoClientRPC", "constructs", "a", "new", "RPC", "based", "Crypto", "implementation", "." ]

[ "func", "newCryptoClientWithClient", "(", "codec", "kbfscodec", ".", "Codec", ",", "log", "logger", ".", "Logger", ",", "client", "rpc", ".", "GenericClient", ")", "*", "CryptoClientRPC", "{", "deferLog", ":=", "log", ".", "CloneWithAddedDepth", "(", "1", ")", "\n", "return", "&", "CryptoClientRPC", "{", "CryptoClient", ":", "CryptoClient", "{", "CryptoCommon", ":", "MakeCryptoCommon", "(", "codec", ",", "nil", ")", ",", "log", ":", "log", ",", "deferLog", ":", "deferLog", ",", "client", ":", "keybase1", ".", "CryptoClient", "{", "Cli", ":", "client", "}", ",", "teamsClient", ":", "keybase1", ".", "TeamsClient", "{", "Cli", ":", "client", "}", ",", "}", ",", "}", "\n", "}" ]

[ "newCryptoClientWithClient", "should", "only", "be", "used", "for", "testing", "." ]

[ "func", "NewOwnAccountLookupCache", "(", "mctx", "libkb", ".", "MetaContext", ")", "OwnAccountLookupCache", "{", "c", ":=", "&", "ownAccountLookupCacheImpl", "{", "accounts", ":", "make", "(", "map", "[", "stellar1", ".", "AccountID", "]", "*", "string", ")", ",", "}", "\n", "c", ".", "Lock", "(", ")", "\n", "go", "c", ".", "fetch", "(", "mctx", ")", "\n", "return", "c", "\n", "}" ]

[ "NewOwnAccountLookupCache", "fetches", "the", "list", "of", "accounts", "in", "the", "background", "and", "stores", "them", "." ]

[ "func", "(", "c", "*", "ownAccountLookupCacheImpl", ")", "fetch", "(", "mctx", "libkb", ".", "MetaContext", ")", "{", "go", "func", "(", ")", "{", "mc", ":=", "mctx", ".", "BackgroundWithLogTags", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "bundle", ",", "err", ":=", "remote", ".", "FetchSecretlessBundle", "(", "mc", ")", "\n", "c", ".", "loadErr", "=", "err", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "for", "_", ",", "account", ":=", "range", "bundle", ".", "Accounts", "{", "name", ":=", "account", ".", "Name", "\n", "c", ".", "accounts", "[", "account", ".", "AccountID", "]", "=", "&", "name", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "Fetch", "populates", "the", "cache", "in", "the", "background", "." ]

[ "func", "(", "c", "*", "ownAccountLookupCacheImpl", ")", "OwnAccount", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "own", "bool", ",", "accountName", "string", ",", "err", "error", ")", "{", "c", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "RLock", "(", ")", "\n", "if", "c", ".", "loadErr", "!=", "nil", "{", "return", "false", ",", "\"", "\"", ",", "c", ".", "loadErr", "\n", "}", "\n", "name", ":=", "c", ".", "accounts", "[", "accountID", "]", "\n", "if", "name", "==", "nil", "{", "return", "false", ",", "\"", "\"", ",", "nil", "\n", "}", "\n", "return", "true", ",", "*", "name", ",", "nil", "\n", "}" ]

[ "OwnAccount", "queries", "the", "cache", ".", "Blocks", "until", "the", "populating", "RPC", "returns", "." ]

[ "func", "New", "(", ")", "(", "*", "MinTerm", ",", "error", ")", "{", "m", ":=", "&", "MinTerm", "{", "}", "\n", "if", "err", ":=", "m", ".", "open", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "new", "MinTerm", "and", "opens", "the", "terminal", "file", ".", "Any", "errors", "that", "happen", "while", "opening", "or", "getting", "the", "terminal", "size", "are", "returned", "." ]

[ "func", "(", "m", "*", "MinTerm", ")", "Shutdown", "(", ")", "error", "{", "m", ".", "restore", "(", ")", "\n", "// this can hang waiting for newline, so do it in a goroutine.", "// application shutting down, so will get closed by os anyway...", "if", "m", ".", "termIn", "!=", "nil", "{", "go", "m", ".", "termIn", ".", "Close", "(", ")", "\n", "}", "\n", "if", "m", ".", "termOut", "!=", "nil", "&&", "m", ".", "closeTermOut", "{", "go", "m", ".", "termOut", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Shutdown", "closes", "the", "terminal", "." ]

[ "func", "(", "m", "*", "MinTerm", ")", "Prompt", "(", "prompt", "string", ")", "(", "string", ",", "error", ")", "{", "return", "m", ".", "readLine", "(", "prompt", ")", "\n", "}" ]

[ "Prompt", "gets", "a", "line", "of", "input", "from", "the", "terminal", ".", "It", "displays", "the", "text", "in", "the", "prompt", "parameter", "first", "." ]

[ "func", "(", "m", "*", "MinTerm", ")", "PromptPassword", "(", "prompt", "string", ")", "(", "string", ",", "error", ")", "{", "if", "!", "strings", ".", "HasSuffix", "(", "prompt", ",", "\"", "\"", ")", "{", "prompt", "+=", "\"", "\"", "\n", "}", "\n", "return", "m", ".", "readSecret", "(", "prompt", ")", "\n", "}" ]

[ "PromptPassword", "gets", "a", "line", "of", "input", "from", "the", "terminal", "but", "nothing", "is", "echoed", "to", "the", "terminal", "to", "hide", "the", "text", "." ]

[ "func", "(", "h", "*", "KBFSHandler", ")", "checkConversationRekey", "(", "arg", "keybase1", ".", "FSNotification", ")", "{", "if", "arg", ".", "NotificationType", "!=", "keybase1", ".", "FSNotificationType_REKEYING", "{", "return", "\n", "}", "\n", "h", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "arg", ".", "Filename", ",", "arg", ".", "StatusCode", ")", "\n", "if", "arg", ".", "StatusCode", "!=", "keybase1", ".", "FSStatusCode_FINISH", "{", "return", "\n", "}", "\n\n", "uid", ":=", "h", ".", "G", "(", ")", ".", "Env", ".", "GetUID", "(", ")", "\n", "if", "uid", ".", "IsNil", "(", ")", "{", "h", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "arg", ".", "Filename", ")", "\n", "return", "\n", "}", "\n\n", "h", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "arg", ".", "Filename", ")", "\n\n", "h", ".", "notifyConversation", "(", "uid", ",", "arg", ".", "Filename", ")", "\n", "}" ]

[ "checkConversationRekey", "looks", "for", "rekey", "finished", "notifications", "and", "tries", "to", "find", "any", "conversations", "associated", "with", "the", "rekeyed", "TLF", ".", "If", "it", "finds", "any", "it", "will", "send", "ChatThreadsStale", "notifications", "for", "them", "." ]

[ "func", "(", "h", "*", "KBFSHandler", ")", "getKeyFn", "(", ")", "func", "(", "context", ".", "Context", ")", "(", "[", "32", "]", "byte", ",", "error", ")", "{", "keyFn", ":=", "func", "(", "ctx", "context", ".", "Context", ")", "(", "[", "32", "]", "byte", ",", "error", ")", "{", "return", "teams", ".", "GetLocalStorageSecretBoxKeyGeneric", "(", "ctx", ",", "h", ".", "G", "(", ")", ",", "favoritesEncryptionReason", ")", "\n", "}", "\n", "return", "keyFn", "\n", "}" ]

[ "getKeyFn", "returns", "a", "function", "that", "gets", "an", "encryption", "key", "for", "storing", "favorites", "." ]

[ "func", "(", "h", "*", "KBFSHandler", ")", "EncryptFavorites", "(", "ctx", "context", ".", "Context", ",", "dataToDecrypt", "[", "]", "byte", ")", "(", "res", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "encrypteddb", ".", "EncodeBox", "(", "ctx", ",", "dataToDecrypt", ",", "h", ".", "getKeyFn", "(", ")", ")", "\n", "}" ]

[ "EncryptFavorites", "encrypts", "cached", "favorites", "to", "store", "on", "disk", "." ]

[ "func", "(", "id", "TLFID", ")", "Eq", "(", "other", "TLFID", ")", "bool", "{", "return", "bytes", ".", "Equal", "(", "[", "]", "byte", "(", "id", ")", ",", "[", "]", "byte", "(", "other", ")", ")", "\n", "}" ]

[ "Eq", "compares", "two", "TLFIDs" ]

[ "func", "(", "id", "TLFID", ")", "EqString", "(", "other", "fmt", ".", "Stringer", ")", "bool", "{", "return", "hex", ".", "EncodeToString", "(", "id", ")", "==", "other", ".", "String", "(", ")", "\n", "}" ]

[ "EqString", "is", "like", "EqualsTo", "except", "that", "it", "accepts", "a", "fmt", ".", "Stringer", ".", "This", "can", "be", "useful", "for", "comparing", "keybase1", ".", "TLFID", "and", "chat1", ".", "TLFID", "." ]

[ "func", "(", "m", "MessageUnboxedError", ")", "ParseableVersion", "(", ")", "bool", "{", "switch", "m", ".", "ErrType", "{", "case", "MessageUnboxedErrorType_BADVERSION", ",", "MessageUnboxedErrorType_BADVERSION_CRITICAL", ":", "// only applies to these types", "default", ":", "return", "false", "\n", "}", "\n\n", "kind", ":=", "m", ".", "VersionKind", "\n", "version", ":=", "m", ".", "VersionNumber", "\n", "// This error was stored from an old client, we have parse out the info we", "// need from the error message.", "// TODO remove this check once it has be live for a few cycles.", "if", "kind", "==", "\"", "\"", "&&", "version", "==", "0", "{", "re", ":=", "regexp", ".", "MustCompile", "(", "`.* Chat version error: \\[ unhandled: (\\w+) version: (\\d+) .*\\]`", ")", "\n", "matches", ":=", "re", ".", "FindStringSubmatch", "(", "m", ".", "ErrMsg", ")", "\n", "if", "len", "(", "matches", ")", "!=", "3", "{", "return", "false", "\n", "}", "\n", "kind", "=", "VersionKind", "(", "matches", "[", "1", "]", ")", "\n", "var", "err", "error", "\n", "version", ",", "err", "=", "strconv", ".", "Atoi", "(", "matches", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "var", "maxVersion", "int", "\n", "switch", "kind", "{", "case", "VersionErrorMessageBoxed", ":", "maxVersion", "=", "int", "(", "MaxMessageBoxedVersion", ")", "\n", "case", "VersionErrorHeader", ":", "maxVersion", "=", "int", "(", "MaxHeaderVersion", ")", "\n", "case", "VersionErrorBody", ":", "maxVersion", "=", "int", "(", "MaxBodyVersion", ")", "\n", "default", ":", "return", "false", "\n", "}", "\n", "return", "maxVersion", ">=", "version", "\n", "}" ]

[ "ParseableVersion", "checks", "if", "this", "error", "has", "a", "version", "that", "is", "now", "able", "to", "be", "understood", "by", "our", "client", "." ]

[ "func", "(", "c", "ConversationInfoLocal", ")", "TLFNameExpandedSummary", "(", ")", "string", "{", "if", "c", ".", "FinalizeInfo", "==", "nil", "{", "return", "c", ".", "TlfName", "\n", "}", "\n", "return", "c", ".", "TlfName", "+", "\"", "\"", "+", "c", ".", "FinalizeInfo", ".", "BeforeSummary", "(", ")", "\n", "}" ]

[ "TLFNameExpandedSummary", "returns", "a", "TLF", "name", "with", "a", "summary", "of", "the", "account", "reset", "if", "there", "was", "one", ".", "This", "version", "is", "for", "display", "purposes", "only", "and", "cannot", "be", "used", "to", "lookup", "the", "TLF", "." ]

[ "func", "ExpandTLFName", "(", "name", "string", ",", "finalizeInfo", "*", "ConversationFinalizeInfo", ")", "string", "{", "if", "finalizeInfo", "==", "nil", "{", "return", "name", "\n", "}", "\n", "if", "len", "(", "finalizeInfo", ".", "ResetFull", ")", "==", "0", "{", "return", "name", "\n", "}", "\n", "if", "strings", ".", "Contains", "(", "name", ",", "\"", "\"", ")", "{", "return", "name", "\n", "}", "\n", "return", "name", "+", "\"", "\"", "+", "finalizeInfo", ".", "ResetFull", "\n", "}" ]

[ "ExpandTLFName", "returns", "a", "TLF", "name", "with", "a", "reset", "suffix", "if", "it", "exists", ".", "This", "version", "can", "be", "used", "in", "requests", "to", "lookup", "the", "TLF", "." ]

[ "func", "(", "p", "*", "Pagination", ")", "FirstPage", "(", ")", "bool", "{", "return", "p", "==", "nil", "||", "p", ".", "ForceFirstPage", "||", "(", "len", "(", "p", ".", "Next", ")", "==", "0", "&&", "len", "(", "p", ".", "Previous", ")", "==", "0", ")", "\n", "}" ]

[ "FirstPage", "returns", "true", "if", "the", "pagination", "object", "is", "not", "pointing", "in", "any", "direction" ]

[ "func", "(", "*", "DiskBlockCacheLocal", ")", "tlfKey", "(", "tlfID", "tlf", ".", "ID", ",", "blockKey", "[", "]", "byte", ")", "[", "]", "byte", "{", "return", "append", "(", "tlfID", ".", "Bytes", "(", ")", ",", "blockKey", "...", ")", "\n", "}" ]

[ "tlfKey", "generates", "a", "TLF", "cache", "key", "from", "a", "tlf", ".", "ID", "and", "a", "binary", "-", "encoded", "block", "ID", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "updateMetadataLocked", "(", "ctx", "context", ".", "Context", ",", "blockKey", "[", "]", "byte", ",", "metadata", "DiskBlockCacheMetadata", ",", "metered", "bool", ")", "error", "{", "metadata", ".", "LRUTime", ".", "Time", "=", "cache", ".", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", "\n", "encodedMetadata", ",", "err", ":=", "cache", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "&", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "var", "putMeter", "*", "CountMeter", "\n", "if", "metered", "{", "putMeter", "=", "cache", ".", "updateMeter", "\n", "}", "\n", "err", "=", "cache", ".", "metaDb", ".", "PutWithMeter", "(", "blockKey", ",", "encodedMetadata", ",", "putMeter", ")", "\n", "if", "err", "!=", "nil", "{", "cache", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "updateMetadataLocked", "updates", "the", "LRU", "time", "of", "a", "block", "in", "the", "LRU", "cache", "to", "the", "current", "time", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "getLRULocked", "(", "blockID", "kbfsblock", ".", "ID", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "metadata", ",", "err", ":=", "cache", ".", "getMetadataLocked", "(", "blockID", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "return", "metadata", ".", "LRUTime", ".", "Time", ",", "nil", "\n", "}" ]

[ "getLRULocked", "retrieves", "the", "LRU", "time", "for", "a", "block", "in", "the", "cache", "or", "returns", "leveldb", ".", "ErrNotFound", "and", "a", "zero", "-", "valued", "time", ".", "Time", "otherwise", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "decodeBlockCacheEntry", "(", "buf", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "error", ")", "{", "entry", ":=", "diskBlockCacheEntry", "{", "}", "\n", "err", ":=", "cache", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "buf", ",", "&", "entry", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n", "return", "entry", ".", "Buf", ",", "entry", ".", "ServerHalf", ",", "nil", "\n", "}" ]

[ "decodeBlockCacheEntry", "decodes", "a", "disk", "block", "cache", "entry", "buffer", "into", "an", "encoded", "block", "and", "server", "half", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "encodeBlockCacheEntry", "(", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "entry", ":=", "diskBlockCacheEntry", "{", "Buf", ":", "buf", ",", "ServerHalf", ":", "serverHalf", ",", "}", "\n", "return", "cache", ".", "config", ".", "Codec", "(", ")", ".", "Encode", "(", "&", "entry", ")", "\n", "}" ]

[ "encodeBlockCacheEntry", "encodes", "an", "encoded", "block", "and", "serverHalf", "into", "a", "single", "buffer", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "blockID", "kbfsblock", ".", "ID", ")", "(", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "prefetchStatus", "PrefetchStatus", ",", "err", "error", ")", "{", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n", "err", "=", "cache", ".", "checkCacheLocked", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "NoPrefetch", ",", "err", "\n", "}", "\n\n", "blockKey", ":=", "blockID", ".", "Bytes", "(", ")", "\n", "entry", ",", "err", ":=", "cache", ".", "blockDb", ".", "Get", "(", "blockKey", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "NoPrefetch", ",", "data", ".", "NoSuchBlockError", "{", "ID", ":", "blockID", "}", "\n", "}", "\n", "md", ",", "err", ":=", "cache", ".", "getMetadataLocked", "(", "blockID", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "NoPrefetch", ",", "err", "\n", "}", "\n", "err", "=", "cache", ".", "updateMetadataLocked", "(", "ctx", ",", "blockKey", ",", "md", ",", "unmetered", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "NoPrefetch", ",", "err", "\n", "}", "\n", "buf", ",", "serverHalf", ",", "err", "=", "cache", ".", "decodeBlockCacheEntry", "(", "entry", ")", "\n", "return", "buf", ",", "serverHalf", ",", "md", ".", "PrefetchStatus", "(", ")", ",", "err", "\n", "}" ]

[ "Get", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "GetMetadata", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ")", "(", "DiskBlockCacheMetadata", ",", "error", ")", "{", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n", "err", ":=", "cache", ".", "checkCacheLocked", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "DiskBlockCacheMetadata", "{", "}", ",", "err", "\n", "}", "\n", "return", "cache", ".", "getMetadataLocked", "(", "blockID", ",", "false", ")", "\n", "}" ]

[ "GetMetadata", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "UpdateMetadata", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ",", "prefetchStatus", "PrefetchStatus", ")", "(", "err", "error", ")", "{", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "err", "=", "cache", ".", "checkCacheLocked", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "md", ",", "err", ":=", "cache", ".", "getMetadataLocked", "(", "blockID", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "data", ".", "NoSuchBlockError", "{", "ID", ":", "blockID", "}", "\n", "}", "\n", "if", "md", ".", "FinishedPrefetch", "{", "// Don't update md that's already completed.", "return", "nil", "\n", "}", "\n", "md", ".", "TriggeredPrefetch", "=", "false", "\n", "md", ".", "FinishedPrefetch", "=", "false", "\n", "switch", "prefetchStatus", "{", "case", "TriggeredPrefetch", ":", "md", ".", "TriggeredPrefetch", "=", "true", "\n", "case", "FinishedPrefetch", ":", "md", ".", "TriggeredPrefetch", "=", "true", "\n", "md", ".", "FinishedPrefetch", "=", "true", "\n", "}", "\n", "return", "cache", ".", "updateMetadataLocked", "(", "ctx", ",", "blockID", ".", "Bytes", "(", ")", ",", "md", ",", "metered", ")", "\n", "}" ]

[ "UpdateMetadata", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "deleteLocked", "(", "ctx", "context", ".", "Context", ",", "blockEntries", "[", "]", "kbfsblock", ".", "ID", ")", "(", "numRemoved", "int", ",", "sizeRemoved", "int64", ",", "err", "error", ")", "{", "if", "len", "(", "blockEntries", ")", "==", "0", "{", "return", "0", ",", "0", ",", "nil", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "cache", ".", "deleteCountMeter", ".", "Mark", "(", "int64", "(", "numRemoved", ")", ")", "\n", "cache", ".", "deleteSizeMeter", ".", "Mark", "(", "sizeRemoved", ")", "\n", "}", "\n", "}", "(", ")", "\n", "blockBatch", ":=", "new", "(", "leveldb", ".", "Batch", ")", "\n", "metadataBatch", ":=", "new", "(", "leveldb", ".", "Batch", ")", "\n", "tlfBatch", ":=", "new", "(", "leveldb", ".", "Batch", ")", "\n", "removalCounts", ":=", "make", "(", "map", "[", "tlf", ".", "ID", "]", "int", ")", "\n", "removalSizes", ":=", "make", "(", "map", "[", "tlf", ".", "ID", "]", "uint64", ")", "\n", "for", "_", ",", "entry", ":=", "range", "blockEntries", "{", "blockKey", ":=", "entry", ".", "Bytes", "(", ")", "\n", "metadataBytes", ",", "err", ":=", "cache", ".", "metaDb", ".", "Get", "(", "blockKey", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "// If we can't retrieve the block, don't try to delete it, and", "// don't account for its non-presence.", "continue", "\n", "}", "\n", "metadata", ":=", "DiskBlockCacheMetadata", "{", "}", "\n", "err", "=", "cache", ".", "config", ".", "Codec", "(", ")", ".", "Decode", "(", "metadataBytes", ",", "&", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n", "blockBatch", ".", "Delete", "(", "blockKey", ")", "\n", "metadataBatch", ".", "Delete", "(", "blockKey", ")", "\n", "tlfDbKey", ":=", "cache", ".", "tlfKey", "(", "metadata", ".", "TlfID", ",", "blockKey", ")", "\n", "tlfBatch", ".", "Delete", "(", "tlfDbKey", ")", "\n", "removalCounts", "[", "metadata", ".", "TlfID", "]", "++", "\n", "removalSizes", "[", "metadata", ".", "TlfID", "]", "+=", "uint64", "(", "metadata", ".", "BlockSize", ")", "\n", "sizeRemoved", "+=", "int64", "(", "metadata", ".", "BlockSize", ")", "\n", "numRemoved", "++", "\n", "}", "\n", "// TODO: more gracefully handle non-atomic failures here.", "if", "err", ":=", "cache", ".", "metaDb", ".", "Write", "(", "metadataBatch", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n", "if", "err", ":=", "cache", ".", "tlfDb", ".", "Write", "(", "tlfBatch", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n", "if", "err", ":=", "cache", ".", "blockDb", ".", "Write", "(", "blockBatch", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "// Update the cache's totals.", "for", "k", ",", "v", ":=", "range", "removalCounts", "{", "cache", ".", "tlfCounts", "[", "k", "]", "-=", "v", "\n", "cache", ".", "priorityBlockCounts", "[", "cache", ".", "homeDirs", "[", "k", "]", "]", "-=", "v", "\n", "cache", ".", "priorityTlfMap", "[", "cache", ".", "homeDirs", "[", "k", "]", "]", "[", "k", "]", "-=", "v", "\n", "cache", ".", "numBlocks", "-=", "v", "\n", "cache", ".", "tlfSizes", "[", "k", "]", "-=", "removalSizes", "[", "k", "]", "\n", "cache", ".", "subCurrBytes", "(", "removalSizes", "[", "k", "]", ")", "\n", "}", "\n", "if", "cache", ".", "useLimiter", "(", ")", "{", "cache", ".", "config", ".", "DiskLimiter", "(", ")", ".", "release", "(", "ctx", ",", "cache", ".", "cacheType", ",", "sizeRemoved", ",", "0", ")", "\n", "}", "\n\n", "return", "numRemoved", ",", "sizeRemoved", ",", "nil", "\n", "}" ]

[ "deleteLocked", "deletes", "a", "set", "of", "blocks", "from", "the", "disk", "block", "cache", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "Delete", "(", "ctx", "context", ".", "Context", ",", "blockIDs", "[", "]", "kbfsblock", ".", "ID", ")", "(", "numRemoved", "int", ",", "sizeRemoved", "int64", ",", "err", "error", ")", "{", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "err", "=", "cache", ".", "checkCacheLocked", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "blockIDs", ")", ")", "\n", "defer", "func", "(", ")", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "blockIDs", ")", ",", "numRemoved", ",", "sizeRemoved", ",", "err", ")", "\n", "}", "(", ")", "\n", "if", "cache", ".", "config", ".", "IsTestMode", "(", ")", "{", "for", "_", ",", "bID", ":=", "range", "blockIDs", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "cache", ".", "cacheType", ",", "bID", ")", "\n", "}", "\n", "}", "\n", "return", "cache", ".", "deleteLocked", "(", "ctx", ",", "blockIDs", ")", "\n", "}" ]

[ "Delete", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "evictSomeBlocks", "(", "ctx", "context", ".", "Context", ",", "numBlocks", "int", ",", "blockIDs", "blockIDsByTime", ")", "(", "numRemoved", "int", ",", "sizeRemoved", "int64", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "numBlocks", ",", "numRemoved", ",", "sizeRemoved", ",", "err", ")", "\n", "}", "(", ")", "\n", "if", "len", "(", "blockIDs", ")", "<=", "numBlocks", "{", "numBlocks", "=", "len", "(", "blockIDs", ")", "\n", "}", "else", "{", "// Only sort if we need to grab a subset of blocks.", "sort", ".", "Sort", "(", "blockIDs", ")", "\n", "}", "\n\n", "blocksToDelete", ":=", "blockIDs", ".", "ToBlockIDSlice", "(", "numBlocks", ")", "\n", "return", "cache", ".", "deleteLocked", "(", "ctx", ",", "blocksToDelete", ")", "\n", "}" ]

[ "evictSomeBlocks", "tries", "to", "evict", "numBlocks", "blocks", "from", "the", "cache", ".", "If", "blockIDs", "doesn", "t", "have", "enough", "blocks", "we", "evict", "them", "all", "and", "report", "how", "many", "we", "evicted", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "shuffleTLFsAtPriorityWeighted", "(", "priority", "evictionPriority", ")", "[", "]", "weightedByCount", "{", "weightedSlice", ":=", "make", "(", "[", "]", "weightedByCount", ",", "0", ",", "len", "(", "cache", ".", "priorityTlfMap", "[", "priority", "]", ")", ")", "\n", "idx", ":=", "0", "\n", "// Use an exponential distribution to ensure the weights are", "// correctly used.", "// See http://utopia.duth.gr/~pefraimi/research/data/2007EncOfAlg.pdf", "for", "tlfID", ",", "count", ":=", "range", "cache", ".", "priorityTlfMap", "[", "priority", "]", "{", "if", "count", "==", "0", "{", "continue", "\n", "}", "\n", "weightedSlice", "=", "append", "(", "weightedSlice", ",", "weightedByCount", "{", "key", ":", "math", ".", "Pow", "(", "rand", ".", "Float64", "(", ")", ",", "1.0", "/", "float64", "(", "count", ")", ")", ",", "value", ":", "tlfID", ",", "}", ")", "\n", "idx", "++", "\n", "}", "\n", "sort", ".", "Slice", "(", "weightedSlice", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "weightedSlice", "[", "i", "]", ".", "key", ">", "weightedSlice", "[", "j", "]", ".", "key", "\n", "}", ")", "\n", "return", "weightedSlice", "\n", "}" ]

[ "shuffleTLFsAtPriorityWeighted", "shuffles", "the", "TLFs", "at", "a", "given", "priority", "weighting", "by", "per", "-", "TLF", "block", "count", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "evictLocked", "(", "ctx", "context", ".", "Context", ",", "numBlocks", "int", ")", "(", "numRemoved", "int", ",", "sizeRemoved", "int64", ",", "err", "error", ")", "{", "numRemoved", "=", "0", "\n", "sizeRemoved", "=", "0", "\n", "defer", "func", "(", ")", "{", "cache", ".", "evictCountMeter", ".", "Mark", "(", "int64", "(", "numRemoved", ")", ")", "\n", "cache", ".", "evictSizeMeter", ".", "Mark", "(", "sizeRemoved", ")", "\n", "}", "(", ")", "\n", "for", "priorityToEvict", ":=", "priorityNotHome", ";", "(", "priorityToEvict", "<=", "priorityPrivateHome", ")", "&&", "(", "numRemoved", "<", "numBlocks", ")", ";", "priorityToEvict", "++", "{", "// Shuffle the TLFs of this priority, weighting by block count.", "shuffledSlice", ":=", "cache", ".", "shuffleTLFsAtPriorityWeighted", "(", "priorityToEvict", ")", "\n", "// Select some TLFs to evict from.", "numElements", ":=", "(", "numBlocks", "-", "numRemoved", ")", "*", "evictionConsiderationFactor", "\n\n", "// blockIDs is a slice of blocks from which evictions will be selected.", "blockIDs", ":=", "make", "(", "blockIDsByTime", ",", "0", ",", "numElements", ")", "\n\n", "// For each TLF until we get enough elements to select among,", "// add its blocks to the eviction slice.", "for", "_", ",", "tlfIDStruct", ":=", "range", "shuffledSlice", "{", "tlfID", ":=", "tlfIDStruct", ".", "value", "\n", "if", "cache", ".", "tlfCounts", "[", "tlfID", "]", "==", "0", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "continue", "\n", "}", "\n", "tlfBytes", ":=", "tlfID", ".", "Bytes", "(", ")", "\n\n", "blockID", ",", "err", ":=", "cache", ".", "getRandomBlockID", "(", "numElements", ",", "cache", ".", "tlfCounts", "[", "tlfID", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n", "rng", ":=", "&", "util", ".", "Range", "{", "Start", ":", "append", "(", "tlfBytes", ",", "blockID", ".", "Bytes", "(", ")", "...", ")", ",", "Limit", ":", "append", "(", "tlfBytes", ",", "cache", ".", "maxBlockID", "...", ")", ",", "}", "\n\n", "// Extra func exists to make defers work.", "func", "(", ")", "{", "iter", ":=", "cache", ".", "tlfDb", ".", "NewIterator", "(", "rng", ",", "nil", ")", "\n", "defer", "iter", ".", "Release", "(", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "numElements", ";", "i", "++", "{", "if", "!", "iter", ".", "Next", "(", ")", "{", "break", "\n", "}", "\n", "key", ":=", "iter", ".", "Key", "(", ")", "\n\n", "blockIDBytes", ":=", "key", "[", "len", "(", "tlfBytes", ")", ":", "]", "\n", "blockID", ",", "err", ":=", "kbfsblock", ".", "IDFromBytes", "(", "blockIDBytes", ")", "\n", "if", "err", "!=", "nil", "{", "cache", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "blockIDBytes", ")", "\n", "continue", "\n", "}", "\n", "lru", ",", "err", ":=", "cache", ".", "getLRULocked", "(", "blockID", ")", "\n", "if", "err", "!=", "nil", "{", "cache", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "blockID", ")", "\n", "continue", "\n", "}", "\n", "blockIDs", "=", "append", "(", "blockIDs", ",", "lruEntry", "{", "blockID", ",", "lru", "}", ")", "\n", "}", "\n", "}", "(", ")", "\n", "if", "len", "(", "blockIDs", ")", "==", "numElements", "{", "break", "\n", "}", "\n", "}", "\n", "// Evict some of the selected blocks.", "currNumRemoved", ",", "currSizeRemoved", ",", "err", ":=", "cache", ".", "evictSomeBlocks", "(", "ctx", ",", "numBlocks", "-", "numRemoved", ",", "blockIDs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "numRemoved", ",", "sizeRemoved", ",", "err", "\n", "}", "\n", "// Update the evicted count.", "numRemoved", "+=", "currNumRemoved", "\n", "sizeRemoved", "+=", "currSizeRemoved", "\n", "}", "\n\n", "return", "numRemoved", ",", "sizeRemoved", ",", "nil", "\n", "}" ]

[ "evictLocked", "evicts", "a", "number", "of", "blocks", "from", "the", "cache", ".", "We", "search", "the", "lowest", "eviction", "priority", "level", "for", "blocks", "to", "evict", "first", "then", "the", "next", "highest", "priority", "and", "so", "on", "until", "enough", "blocks", "have", "been", "evicted", ".", "Within", "each", "priority", "we", "first", "shuffle", "the", "TLFs", "weighting", "by", "how", "many", "blocks", "they", "contain", "and", "then", "we", "take", "the", "top", "TLFs", "from", "that", "shuffle", "and", "evict", "the", "least", "recently", "used", "blocks", "from", "them", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "ClearAllTlfBlocks", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "// Delete the blocks in batches, so we don't keep the lock for too", "// long.", "for", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "numLeft", ",", "err", ":=", "cache", ".", "deleteNextBatchFromClearedTlf", "(", "ctx", ",", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "numLeft", "==", "0", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tlfID", ")", "\n", "return", "nil", "\n", "}", "\n", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "numLeft", ",", "tlfID", ")", "\n\n", "c", ":=", "time", ".", "After", "(", "cache", ".", "clearTickerDuration", ")", "\n", "select", "{", "case", "<-", "c", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ClearAllTlfBlocks", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "GetLastUnrefRev", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "(", "kbfsmd", ".", "Revision", ",", "error", ")", "{", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n", "err", ":=", "cache", ".", "checkCacheLocked", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "err", "\n", "}", "\n\n", "rev", ",", "ok", ":=", "cache", ".", "tlfLastUnrefs", "[", "tlfID", "]", "\n", "if", "!", "ok", "{", "// No known unref'd revision.", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "nil", "\n", "}", "\n", "return", "rev", ",", "nil", "\n", "}" ]

[ "GetLastUnrefRev", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "PutLastUnrefRev", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "rev", "kbfsmd", ".", "Revision", ")", "error", "{", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "err", ":=", "cache", ".", "checkCacheLocked", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "currRev", ",", "ok", ":=", "cache", ".", "tlfLastUnrefs", "[", "tlfID", "]", ";", "ok", "{", "if", "rev", "<=", "currRev", "{", "// A later revision has already been unref'd, so ignore this.", "return", "nil", "\n", "}", "\n", "}", "\n\n", "buf", ",", "err", ":=", "cache", ".", "encodeLastUnref", "(", "rev", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "cache", ".", "lastUnrefDb", ".", "Put", "(", "tlfID", ".", "Bytes", "(", ")", ",", "buf", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "cache", ".", "tlfLastUnrefs", "[", "tlfID", "]", "=", "rev", "\n", "return", "nil", "\n", "}" ]

[ "PutLastUnrefRev", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "Status", "(", "ctx", "context", ".", "Context", ")", "map", "[", "string", "]", "DiskBlockCacheStatus", "{", "var", "name", "string", "\n", "var", "maxLimit", "uint64", "\n", "limiterStatus", ":=", "cache", ".", "config", ".", "DiskLimiter", "(", ")", ".", "getStatus", "(", "ctx", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ")", ".", "(", "backpressureDiskLimiterStatus", ")", "\n", "switch", "cache", ".", "cacheType", "{", "case", "syncCacheLimitTrackerType", ":", "name", "=", "syncCacheName", "\n", "maxLimit", "=", "uint64", "(", "limiterStatus", ".", "SyncCacheByteStatus", ".", "Max", ")", "\n", "case", "workingSetCacheLimitTrackerType", ":", "name", "=", "workingSetCacheName", "\n", "maxLimit", "=", "uint64", "(", "limiterStatus", ".", "DiskCacheByteStatus", ".", "Max", ")", "\n", "case", "crDirtyBlockCacheLimitTrackerType", ":", "name", "=", "crDirtyBlockCacheName", "\n", "}", "\n", "select", "{", "case", "<-", "cache", ".", "startedCh", ":", "case", "<-", "cache", ".", "startErrCh", ":", "return", "map", "[", "string", "]", "DiskBlockCacheStatus", "{", "name", ":", "{", "StartState", ":", "DiskBlockCacheStartStateFailed", "}", "}", "\n", "default", ":", "return", "map", "[", "string", "]", "DiskBlockCacheStatus", "{", "name", ":", "{", "StartState", ":", "DiskBlockCacheStartStateStarting", "}", "}", "\n", "}", "\n", "availableBytes", ",", "totalBytes", ":=", "uint64", "(", "math", ".", "MaxInt64", ")", ",", "uint64", "(", "math", ".", "MaxInt64", ")", "\n", "if", "cache", ".", "dirPath", "!=", "\"", "\"", "{", "var", "err", "error", "\n", "availableBytes", ",", "totalBytes", ",", "_", ",", "_", ",", "err", "=", "getDiskLimits", "(", "cache", ".", "dirPath", ")", "\n", "if", "err", "!=", "nil", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n", "// The disk cache status doesn't depend on the chargedTo ID, and", "// we don't have easy access to the UID here, so pass in a dummy.", "return", "map", "[", "string", "]", "DiskBlockCacheStatus", "{", "name", ":", "{", "StartState", ":", "DiskBlockCacheStartStateStarted", ",", "NumBlocks", ":", "uint64", "(", "cache", ".", "numBlocks", ")", ",", "BlockBytes", ":", "cache", ".", "getCurrBytes", "(", ")", ",", "CurrByteLimit", ":", "maxLimit", ",", "LastUnrefCount", ":", "uint64", "(", "len", "(", "cache", ".", "tlfLastUnrefs", ")", ")", ",", "Hits", ":", "rateMeterToStatus", "(", "cache", ".", "hitMeter", ")", ",", "Misses", ":", "rateMeterToStatus", "(", "cache", ".", "missMeter", ")", ",", "Puts", ":", "rateMeterToStatus", "(", "cache", ".", "putMeter", ")", ",", "MetadataUpdates", ":", "rateMeterToStatus", "(", "cache", ".", "updateMeter", ")", ",", "NumEvicted", ":", "rateMeterToStatus", "(", "cache", ".", "evictCountMeter", ")", ",", "SizeEvicted", ":", "rateMeterToStatus", "(", "cache", ".", "evictSizeMeter", ")", ",", "NumDeleted", ":", "rateMeterToStatus", "(", "cache", ".", "deleteCountMeter", ")", ",", "SizeDeleted", ":", "rateMeterToStatus", "(", "cache", ".", "deleteSizeMeter", ")", ",", "LocalDiskBytesAvailable", ":", "availableBytes", ",", "LocalDiskBytesTotal", ":", "totalBytes", ",", "}", ",", "}", "\n", "}" ]

[ "Status", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "DoesCacheHaveSpace", "(", "ctx", "context", ".", "Context", ")", "bool", "{", "limiterStatus", ":=", "cache", ".", "config", ".", "DiskLimiter", "(", ")", ".", "getStatus", "(", "ctx", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ")", ".", "(", "backpressureDiskLimiterStatus", ")", "\n", "switch", "cache", ".", "cacheType", "{", "case", "syncCacheLimitTrackerType", ":", "return", "limiterStatus", ".", "SyncCacheByteStatus", ".", "UsedFrac", "<=", ".99", "\n", "case", "workingSetCacheLimitTrackerType", ":", "return", "limiterStatus", ".", "DiskCacheByteStatus", ".", "UsedFrac", "<=", ".99", "\n", "case", "crDirtyBlockCacheLimitTrackerType", ":", "return", "true", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cache", ".", "cacheType", ")", ")", "\n", "}", "\n", "}" ]

[ "DoesCacheHaveSpace", "returns", "true", "if", "we", "have", "more", "than", "1%", "of", "space", "left", "in", "the", "cache", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "Mark", "(", "ctx", "context", ".", "Context", ",", "blockID", "kbfsblock", ".", "ID", ",", "tag", "string", ")", "error", "{", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "err", ":=", "cache", ".", "checkCacheLocked", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "md", ",", "err", ":=", "cache", ".", "getMetadataLocked", "(", "blockID", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "data", ".", "NoSuchBlockError", "{", "ID", ":", "blockID", "}", "\n", "}", "\n", "md", ".", "Tag", "=", "tag", "\n", "return", "cache", ".", "updateMetadataLocked", "(", "ctx", ",", "blockID", ".", "Bytes", "(", ")", ",", "md", ",", "false", ")", "\n", "}" ]

[ "Mark", "updates", "the", "metadata", "of", "the", "given", "block", "with", "the", "tag", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "DeleteUnmarked", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "tag", "string", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tag", ",", "tlfID", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "// Delete the blocks in batches, so we don't keep the lock for too", "// long.", "startingKey", ":=", "cache", ".", "tlfKey", "(", "tlfID", ",", "nil", ")", "\n", "for", "{", "cache", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tag", ",", "tlfID", ")", "\n", "startingKey", ",", "err", "=", "cache", ".", "deleteNextUnmarkedBatchFromTlf", "(", "ctx", ",", "tlfID", ",", "tag", ",", "startingKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "startingKey", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "c", ":=", "time", ".", "After", "(", "cache", ".", "clearTickerDuration", ")", "\n", "select", "{", "case", "<-", "c", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "DeleteUnmarked", "deletes", "all", "the", "blocks", "without", "the", "given", "tag", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "AddHomeTLF", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "error", "{", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "cache", ".", "priorityBlockCounts", "[", "cache", ".", "homeDirs", "[", "tlfID", "]", "]", "-=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n", "cache", ".", "priorityTlfMap", "[", "cache", ".", "homeDirs", "[", "tlfID", "]", "]", "[", "tlfID", "]", "-=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n\n", "switch", "tlfID", ".", "Type", "(", ")", "{", "case", "tlf", ".", "Private", ":", "cache", ".", "homeDirs", "[", "tlfID", "]", "=", "priorityPrivateHome", "\n", "case", "tlf", ".", "Public", ":", "cache", ".", "homeDirs", "[", "tlfID", "]", "=", "priorityPublicHome", "\n", "default", ":", "return", "errTeamOrUnknownTLFAddedAsHome", "\n", "}", "\n", "cache", ".", "priorityBlockCounts", "[", "cache", ".", "homeDirs", "[", "tlfID", "]", "]", "+=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n", "cache", ".", "priorityTlfMap", "[", "cache", ".", "homeDirs", "[", "tlfID", "]", "]", "[", "tlfID", "]", "+=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n\n", "return", "nil", "\n", "}" ]

[ "AddHomeTLF", "implements", "this", "DiskBlockCache", "interace", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "ClearHomeTLFs", "(", "ctx", "context", ".", "Context", ")", "error", "{", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "for", "tlfID", ",", "priority", ":=", "range", "cache", ".", "homeDirs", "{", "cache", ".", "priorityBlockCounts", "[", "priority", "]", "-=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n", "cache", ".", "priorityTlfMap", "[", "priority", "]", "[", "tlfID", "]", "-=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n", "cache", ".", "priorityBlockCounts", "[", "priorityNotHome", "]", "+=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n", "cache", ".", "priorityTlfMap", "[", "priorityNotHome", "]", "[", "tlfID", "]", "+=", "cache", ".", "tlfCounts", "[", "tlfID", "]", "\n", "}", "\n", "cache", ".", "homeDirs", "=", "make", "(", "map", "[", "tlf", ".", "ID", "]", "evictionPriority", ")", "\n", "return", "nil", "\n", "}" ]

[ "ClearHomeTLFs", "implements", "this", "DiskBlockCache", "interace", "for", "DiskBlockCacheLocal", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "GetTlfSize", "(", "_", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "(", "uint64", ",", "error", ")", "{", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "cache", ".", "tlfSizes", "[", "tlfID", "]", ",", "nil", "\n", "}" ]

[ "GetTlfSize", "returns", "the", "number", "of", "bytes", "stored", "for", "the", "given", "TLF", "in", "the", "cache", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "GetTlfIDs", "(", "_", "context", ".", "Context", ")", "(", "tlfIDs", "[", "]", "tlf", ".", "ID", ",", "err", "error", ")", "{", "cache", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "RUnlock", "(", ")", "\n", "tlfIDs", "=", "make", "(", "[", "]", "tlf", ".", "ID", ",", "0", ",", "len", "(", "cache", ".", "tlfSizes", ")", ")", "\n", "for", "id", ":=", "range", "cache", ".", "tlfSizes", "{", "tlfIDs", "=", "append", "(", "tlfIDs", ",", "id", ")", "\n", "}", "\n", "return", "tlfIDs", ",", "nil", "\n", "}" ]

[ "GetTlfIDs", "returns", "the", "IDs", "of", "all", "the", "TLFs", "with", "blocks", "stored", "in", "the", "cache", "." ]