Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "(", "d", "*", "DirtyBlockCacheStandard", ")", "ShouldForceSync", "(", "_", "tlf", ".", "ID", ")", "bool", "{", "d", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "d", ".", "lock", ".", "RUnlock", "(", ")", "\n", "// TODO: Fill up to likely block boundaries?", "return", "d", ".", "waitBufBytes", ">=", "d", ".", "syncBufferCap", "\n", "}" ]

[ "ShouldForceSync", "implements", "the", "DirtyBlockCache", "interface", "for", "DirtyBlockCacheStandard", "." ]

[ "func", "(", "d", "*", "DirtyBlockCacheStandard", ")", "Size", "(", ")", "int", "{", "d", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "d", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "len", "(", "d", ".", "cache", ")", "\n", "}" ]

[ "Size", "returns", "the", "number", "of", "blocks", "currently", "in", "the", "cache", "." ]

[ "func", "(", "d", "*", "DirtyBlockCacheStandard", ")", "Shutdown", "(", ")", "error", "{", "func", "(", ")", "{", "d", ".", "shutdownLock", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "shutdownLock", ".", "Unlock", "(", ")", "\n", "d", ".", "isShutdown", "=", "true", "\n", "close", "(", "d", ".", "shutdownChan", ")", "\n", "}", "(", ")", "\n\n", "d", ".", "reqWg", ".", "Wait", "(", ")", "\n", "close", "(", "d", ".", "requestsChan", ")", "\n", "d", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "lock", ".", "Unlock", "(", ")", "\n", "// Clear out the remaining requests", "for", "req", ":=", "range", "d", ".", "requestsChan", "{", "d", ".", "updateWaitBufLocked", "(", "req", ".", "bytes", ")", "\n", "}", "\n", "if", "d", ".", "syncBufBytes", "!=", "0", "||", "d", ".", "waitBufBytes", "!=", "0", "||", "d", ".", "ignoreSyncBytes", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "d", ".", "syncBufBytes", ",", "d", ".", "waitBufBytes", ",", "d", ".", "ignoreSyncBytes", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Shutdown", "implements", "the", "DirtyBlockCache", "interface", "for", "DirtyBlockCacheStandard", "." ]

[ "func", "NewCmdUpdate", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "HideHelp", ":", "true", ",", "Subcommands", ":", "[", "]", "cli", ".", "Command", "{", "newCmdUpdateCheck", "(", "cl", ",", "g", ")", ",", "// Deprecated", "newCmdUpdateCheckInUse", "(", "cl", ",", "g", ")", ",", "newCmdUpdateNotify", "(", "cl", ",", "g", ")", ",", "}", ",", "}", "\n", "}" ]

[ "NewCmdUpdate", "are", "commands", "for", "supporting", "the", "updater" ]

[ "func", "newCmdUpdateCheckInUse", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Action", ":", "func", "(", "c", "*", "cli", ".", "Context", ")", "{", "cl", ".", "SetLogForward", "(", "libcmdline", ".", "LogForwardNone", ")", "\n", "cl", ".", "SetForkCmd", "(", "libcmdline", ".", "NoFork", ")", "\n", "cl", ".", "ChooseCommand", "(", "newCmdUpdateCheckInUseRunner", "(", "g", ")", ",", "\"", "\"", ",", "c", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "newCmdUpdateCheckInUse", "is", "called", "by", "updater", "to", "see", "if", "Keybase", "is", "currently", "in", "use" ]

[ "func", "NewCmdSimpleFSPs", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Action", ":", "func", "(", "c", "*", "cli", ".", "Context", ")", "{", "cl", ".", "ChooseCommand", "(", "&", "CmdSimpleFSPs", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", "}", ",", "\"", "\"", ",", "c", ")", "\n", "cl", ".", "SetNoStandalone", "(", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewCmdSimpleFSPs", "creates", "a", "new", "cli", ".", "Command", "." ]

[ "func", "(", "fbm", "*", "folderBlockManager", ")", "archiveUnrefBlocksNoWait", "(", "md", "ReadOnlyRootMetadata", ")", "{", "// Don't archive for unmerged revisions, because conflict", "// resolution might undo some of the unreferences.", "if", "md", ".", "MergedStatus", "(", ")", "!=", "kbfsmd", ".", "Merged", "{", "return", "\n", "}", "\n\n", "if", "err", ":=", "isArchivableMDOrError", "(", "md", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "fbm", ".", "archiveGroup", ".", "Add", "(", "1", ")", "\n\n", "// Don't block if the channel is full; instead do the send in a", "// background goroutine. We've already done the Add above, so the", "// wait calls should all work just fine.", "select", "{", "case", "fbm", ".", "archiveChan", "<-", "md", ":", "return", "\n", "default", ":", "go", "func", "(", ")", "{", "fbm", ".", "archiveChan", "<-", "md", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "archiveUnrefBlocksNoWait", "enqueues", "the", "MD", "for", "archiving", "without", "blocking", ".", "By", "the", "time", "it", "returns", "the", "archive", "group", "has", "been", "incremented", "so", "future", "waits", "will", "block", "on", "this", "archive", ".", "This", "method", "is", "for", "internal", "use", "within", "folderBlockManager", "only", "." ]

[ "func", "(", "fbm", "*", "folderBlockManager", ")", "doChunkedDowngrades", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "ptrs", "[", "]", "data", ".", "BlockPointer", ",", "archive", "bool", ")", "(", "[", "]", "kbfsblock", ".", "ID", ",", "error", ")", "{", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "ptrs", ")", ",", "archive", ")", "\n", "bops", ":=", "fbm", ".", "config", ".", "BlockOps", "(", ")", "\n\n", "// Round up to find the number of chunks.", "numChunks", ":=", "(", "len", "(", "ptrs", ")", "+", "numPointersToDowngradePerChunk", "-", "1", ")", "/", "numPointersToDowngradePerChunk", "\n", "numWorkers", ":=", "numChunks", "\n", "if", "numWorkers", ">", "maxParallelBlockPuts", "{", "numWorkers", "=", "maxParallelBlockPuts", "\n", "}", "\n", "chunks", ":=", "make", "(", "chan", "[", "]", "data", ".", "BlockPointer", ",", "numChunks", ")", "\n\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "defer", "wg", ".", "Wait", "(", ")", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "type", "workerResult", "struct", "{", "zeroRefCounts", "[", "]", "kbfsblock", ".", "ID", "\n", "err", "error", "\n", "}", "\n\n", "chunkResults", ":=", "make", "(", "chan", "workerResult", ",", "numChunks", ")", "\n", "worker", ":=", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "for", "chunk", ":=", "range", "chunks", "{", "var", "res", "workerResult", "\n", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "chunk", ")", ")", "\n", "if", "archive", "{", "res", ".", "err", "=", "bops", ".", "Archive", "(", "ctx", ",", "tlfID", ",", "chunk", ")", "\n", "}", "else", "{", "var", "liveCounts", "map", "[", "kbfsblock", ".", "ID", "]", "int", "\n", "liveCounts", ",", "res", ".", "err", "=", "bops", ".", "Delete", "(", "ctx", ",", "tlfID", ",", "chunk", ")", "\n", "if", "res", ".", "err", "==", "nil", "{", "for", "id", ",", "count", ":=", "range", "liveCounts", "{", "if", "count", "==", "0", "{", "res", ".", "zeroRefCounts", "=", "append", "(", "res", ".", "zeroRefCounts", ",", "id", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "chunkResults", "<-", "res", "\n", "select", "{", "// return early if the context has been canceled", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "default", ":", "}", "\n", "}", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "numWorkers", ";", "i", "++", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "worker", "(", ")", "\n", "}", "\n\n", "for", "start", ":=", "0", ";", "start", "<", "len", "(", "ptrs", ")", ";", "start", "+=", "numPointersToDowngradePerChunk", "{", "end", ":=", "start", "+", "numPointersToDowngradePerChunk", "\n", "if", "end", ">", "len", "(", "ptrs", ")", "{", "end", "=", "len", "(", "ptrs", ")", "\n", "}", "\n", "chunks", "<-", "ptrs", "[", "start", ":", "end", "]", "\n", "}", "\n", "close", "(", "chunks", ")", "\n\n", "var", "zeroRefCounts", "[", "]", "kbfsblock", ".", "ID", "\n", "for", "i", ":=", "0", ";", "i", "<", "numChunks", ";", "i", "++", "{", "result", ":=", "<-", "chunkResults", "\n", "if", "result", ".", "err", "!=", "nil", "{", "// deferred cancel will stop the other workers.", "return", "nil", ",", "result", ".", "err", "\n", "}", "\n", "zeroRefCounts", "=", "append", "(", "zeroRefCounts", ",", "result", ".", "zeroRefCounts", "...", ")", "\n", "}", "\n", "return", "zeroRefCounts", ",", "nil", "\n", "}" ]

[ "doChunkedDowngrades", "sends", "batched", "archive", "or", "delete", "messages", "to", "the", "block", "server", "for", "the", "given", "block", "pointers", ".", "For", "deletes", "it", "returns", "a", "list", "of", "block", "IDs", "that", "no", "longer", "have", "any", "references", "." ]

[ "func", "(", "fbm", "*", "folderBlockManager", ")", "deleteBlockRefs", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "ptrs", "[", "]", "data", ".", "BlockPointer", ")", "(", "[", "]", "kbfsblock", ".", "ID", ",", "error", ")", "{", "return", "fbm", ".", "doChunkedDowngrades", "(", "ctx", ",", "tlfID", ",", "ptrs", ",", "false", ")", "\n", "}" ]

[ "deleteBlockRefs", "sends", "batched", "delete", "messages", "to", "the", "block", "server", "for", "the", "given", "block", "pointers", ".", "It", "returns", "a", "list", "of", "block", "IDs", "that", "no", "longer", "have", "any", "references", "." ]

[ "func", "(", "fbm", "*", "folderBlockManager", ")", "getUnrefPointersFromMD", "(", "rmd", "ReadOnlyRootMetadata", ",", "includeGC", "bool", ",", "iter", "*", "unrefIterator", ")", "(", "ptrs", "[", "]", "data", ".", "BlockPointer", ",", "nextIter", "*", "unrefIterator", ")", "{", "currPtr", ":=", "0", "\n", "complete", ":=", "true", "\n", "nextPtr", ":=", "0", "\n", "if", "iter", "!=", "nil", "{", "nextPtr", "=", "iter", ".", "nextPtr", "\n", "}", "\n", "ptrMap", ":=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "bool", ")", "\n", "max", ":=", "fbm", ".", "config", ".", "Mode", "(", ")", ".", "MaxBlockPtrsToManageAtOnce", "(", ")", "\n", "opLoop", ":", "for", "_", ",", "op", ":=", "range", "rmd", ".", "data", ".", "Changes", ".", "Ops", "{", "if", "_", ",", "ok", ":=", "op", ".", "(", "*", "GCOp", ")", ";", "!", "includeGC", "&&", "ok", "{", "continue", "\n", "}", "\n", "for", "_", ",", "ptr", ":=", "range", "op", ".", "Unrefs", "(", ")", "{", "currPtr", "++", "\n", "// Skip past any ptrs we've already processed.", "if", "currPtr", "<=", "nextPtr", "{", "continue", "\n", "}", "\n\n", "// Can be zeroPtr in weird failed sync scenarios.", "// See syncInfo.replaceRemovedBlock for an example", "// of how this can happen.", "if", "ptr", "!=", "data", ".", "ZeroPtr", "&&", "!", "ptrMap", "[", "ptr", "]", "{", "ptrMap", "[", "ptr", "]", "=", "true", "\n", "}", "\n", "nextPtr", "++", "\n", "if", "max", ">=", "0", "&&", "len", "(", "ptrMap", ")", ">=", "max", "{", "complete", "=", "false", "\n", "break", "opLoop", "\n", "}", "\n", "}", "\n", "for", "_", ",", "update", ":=", "range", "op", ".", "allUpdates", "(", ")", "{", "currPtr", "++", "\n", "// Skip past any ptrs we've already processed.", "if", "currPtr", "<=", "nextPtr", "{", "continue", "\n", "}", "\n\n", "// It's legal for there to be an \"update\" between", "// two identical pointers (usually because of", "// conflict resolution), so ignore that for quota", "// reclamation purposes.", "if", "update", ".", "Ref", "!=", "update", ".", "Unref", "&&", "!", "ptrMap", "[", "update", ".", "Unref", "]", "{", "ptrMap", "[", "update", ".", "Unref", "]", "=", "true", "\n", "}", "\n", "nextPtr", "++", "\n", "if", "max", ">=", "0", "&&", "len", "(", "ptrMap", ")", ">=", "max", "{", "complete", "=", "false", "\n", "break", "opLoop", "\n", "}", "\n", "}", "\n", "}", "\n", "ptrs", "=", "make", "(", "[", "]", "data", ".", "BlockPointer", ",", "0", ",", "len", "(", "ptrMap", ")", ")", "\n", "for", "ptr", ":=", "range", "ptrMap", "{", "ptrs", "=", "append", "(", "ptrs", ",", "ptr", ")", "\n", "}", "\n", "if", "!", "complete", "{", "nextIter", "=", "&", "unrefIterator", "{", "nextPtr", "}", "\n", "}", "\n", "return", "ptrs", ",", "nextIter", "\n", "}" ]

[ "getUnrefPointersFromMD", "returns", "a", "slice", "of", "BlockPointers", "that", "were", "unreferenced", "by", "the", "given", "rmd", ".", "If", "there", "are", "too", "many", "pointers", "to", "process", "given", "the", "current", "mode", "then", "it", "will", "return", "a", "partial", "list", "plus", "a", "non", "-", "nil", "iter", "parameter", "that", "can", "be", "passed", "into", "a", "subsequent", "call", "to", "get", "the", "next", "set", "of", "unreferenced", "BlockPointers", "from", "the", "same", "MD", ".", "If", "a", "nil", "iter", "is", "given", "pointers", "are", "returned", "from", "the", "beginning", "of", "the", "list", "." ]

[ "func", "(", "fbm", "*", "folderBlockManager", ")", "getMostRecentGCRevision", "(", "ctx", "context", ".", "Context", ",", "head", "ReadOnlyRootMetadata", ")", "(", "lastGCRev", "kbfsmd", ".", "Revision", ",", "err", "error", ")", "{", "if", "head", ".", "data", ".", "LastGCRevision", ">=", "kbfsmd", ".", "RevisionInitial", "{", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "head", ".", "data", ".", "LastGCRevision", ",", "head", ".", "Revision", "(", ")", ")", "\n", "return", "head", ".", "data", ".", "LastGCRevision", ",", "nil", "\n", "}", "\n\n", "// Very old TLFs might not have a filled-in `LastGCRevision`, so", "// we need to walk backwards to find the latest gcOp.", "endRev", ":=", "head", ".", "Revision", "(", ")", "\n", "for", "{", "startRev", ":=", "endRev", "-", "maxMDsAtATime", "+", "1", "// (kbfsmd.Revision is signed)", "\n", "if", "startRev", "<", "kbfsmd", ".", "RevisionInitial", "{", "startRev", "=", "kbfsmd", ".", "RevisionInitial", "\n", "}", "\n\n", "rmds", ",", "err", ":=", "getMDRange", "(", "ctx", ",", "fbm", ".", "config", ",", "fbm", ".", "id", ",", "kbfsmd", ".", "NullBranchID", ",", "startRev", ",", "endRev", ",", "kbfsmd", ".", "Merged", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "err", "\n", "}", "\n\n", "numNew", ":=", "len", "(", "rmds", ")", "\n", "for", "i", ":=", "len", "(", "rmds", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "rmd", ":=", "rmds", "[", "i", "]", "\n", "if", "rmd", ".", "data", ".", "LastGCRevision", ">=", "kbfsmd", ".", "RevisionInitial", "{", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "rmd", ".", "data", ".", "LastGCRevision", ",", "rmd", ".", "Revision", "(", ")", ")", "\n", "return", "rmd", ".", "data", ".", "LastGCRevision", ",", "nil", "\n", "}", "\n", "for", "j", ":=", "len", "(", "rmd", ".", "data", ".", "Changes", ".", "Ops", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", "{", "GCOp", ",", "ok", ":=", "rmd", ".", "data", ".", "Changes", ".", "Ops", "[", "j", "]", ".", "(", "*", "GCOp", ")", "\n", "if", "!", "ok", "||", "GCOp", ".", "LatestRev", "==", "kbfsmd", ".", "RevisionUninitialized", "{", "continue", "\n", "}", "\n", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "GCOp", ")", "\n", "return", "GCOp", ".", "LatestRev", ",", "nil", "\n", "}", "\n", "}", "\n\n", "if", "numNew", ">", "0", "{", "endRev", "=", "rmds", "[", "0", "]", ".", "Revision", "(", ")", "-", "1", "\n", "}", "\n\n", "if", "numNew", "<", "maxMDsAtATime", "||", "endRev", "<", "kbfsmd", ".", "RevisionInitial", "{", "// Never been GC'd.", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "getMostRecentGCRevision", "returns", "the", "latest", "revision", "that", "was", "scrubbed", "by", "the", "previous", "gc", "op", "." ]

[ "func", "(", "fbm", "*", "folderBlockManager", ")", "getUnreferencedBlocks", "(", "ctx", "context", ".", "Context", ",", "earliestRev", ",", "mostRecentRev", "kbfsmd", ".", "Revision", ")", "(", "ptrs", "[", "]", "data", ".", "BlockPointer", ",", "lastRev", "kbfsmd", ".", "Revision", ",", "complete", "bool", ",", "err", "error", ")", "{", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "earliestRev", ",", "mostRecentRev", ")", "\n", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "len", "(", "ptrs", ")", ",", "earliestRev", ",", "lastRev", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Walk forward, starting from just after earliestRev, until we", "// get enough pointers or until we reach the head or a revision", "// that's not old enough, gathering pointers to GC.", "startRev", ":=", "earliestRev", "+", "1", "\n", "outer", ":", "for", "{", "endRev", ":=", "startRev", "+", "maxMDsAtATime", "\n", "if", "endRev", ">", "mostRecentRev", "{", "endRev", "=", "mostRecentRev", "\n", "}", "\n\n", "rmds", ",", "err", ":=", "getMDRange", "(", "ctx", ",", "fbm", ".", "config", ",", "fbm", ".", "id", ",", "kbfsmd", ".", "NullBranchID", ",", "startRev", ",", "endRev", ",", "kbfsmd", ".", "Merged", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfsmd", ".", "RevisionUninitialized", ",", "false", ",", "err", "\n", "}", "\n\n", "numNew", ":=", "len", "(", "rmds", ")", "\n", "for", "_", ",", "rmd", ":=", "range", "rmds", "{", "if", "!", "fbm", ".", "isOldEnough", "(", "rmd", ")", "{", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "rmd", ".", "Revision", "(", ")", ")", "\n", "complete", "=", "true", "\n", "break", "outer", "\n", "}", "\n", "lastRev", "=", "rmd", ".", "Revision", "(", ")", "\n", "// A garbage-collection op *must* contain all pointers in", "// its respective op. If this device can't handle it,", "// error the process and let another device take care of", "// it.", "newPtrs", ",", "iter", ":=", "fbm", ".", "getUnrefPointersFromMD", "(", "rmd", ".", "ReadOnlyRootMetadata", ",", "false", ",", "&", "unrefIterator", "{", "0", "}", ")", "\n", "if", "iter", "!=", "nil", "{", "return", "nil", ",", "kbfsmd", ".", "RevisionUninitialized", ",", "false", ",", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "lastRev", ")", ")", "\n", "}", "\n", "ptrs", "=", "append", "(", "ptrs", ",", "newPtrs", "...", ")", "\n", "// TODO: when can we clean up the MD's unembedded block", "// changes pointer? It's not safe until we know for sure", "// that all existing clients have received the latest", "// update (and also that there are no outstanding staged", "// branches). Let's do that as part of the bigger issue", "// KBFS-793 -- for now we have to leak those blocks.", "if", "len", "(", "ptrs", ")", ">", "fbm", ".", "numPointersPerGCThreshold", "{", "fbm", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "earliestRev", ",", "rmd", ".", "Revision", "(", ")", ")", "\n", "break", "outer", "\n", "}", "\n", "}", "\n\n", "if", "numNew", ">", "0", "{", "startRev", "=", "rmds", "[", "len", "(", "rmds", ")", "-", "1", "]", ".", "Revision", "(", ")", "+", "1", "\n", "}", "\n\n", "if", "numNew", "<", "maxMDsAtATime", "||", "startRev", ">", "mostRecentRev", "{", "complete", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "return", "ptrs", ",", "lastRev", ",", "complete", ",", "nil", "\n", "}" ]

[ "getUnrefBlocks", "returns", "a", "slice", "containing", "all", "the", "block", "pointers", "that", "were", "unreferenced", "after", "the", "earliestRev", "up", "to", "and", "including", "those", "in", "latestRev", ".", "If", "the", "number", "of", "pointers", "is", "too", "large", "it", "will", "shorten", "the", "range", "of", "the", "revisions", "being", "reclaimed", "and", "return", "the", "latest", "revision", "represented", "in", "the", "returned", "slice", "of", "pointers", "." ]

[ "func", "(", "k", "*", "KeyOpsStandard", ")", "GetTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ")", "(", "kbfscrypto", ".", "TLFCryptKeyServerHalf", ",", "error", ")", "{", "// get the key half from the server", "serverHalf", ",", "err", ":=", "k", ".", "config", ".", "KeyServer", "(", ")", ".", "GetTLFCryptKeyServerHalf", "(", "ctx", ",", "serverHalfID", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n", "// get current uid and deviceKID", "session", ",", "err", ":=", "k", ".", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "// verify we got the expected key", "err", "=", "kbfscrypto", ".", "VerifyTLFCryptKeyServerHalfID", "(", "serverHalfID", ",", "session", ".", "UID", ",", "key", ",", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n", "return", "serverHalf", ",", "nil", "\n", "}" ]

[ "GetTLFCryptKeyServerHalf", "is", "an", "implementation", "of", "the", "KeyOps", "interface", "." ]

[ "func", "(", "k", "*", "KeyOpsStandard", ")", "PutTLFCryptKeyServerHalves", "(", "ctx", "context", ".", "Context", ",", "keyServerHalves", "kbfsmd", ".", "UserDeviceKeyServerHalves", ")", "error", "{", "// upload the keys", "return", "k", ".", "config", ".", "KeyServer", "(", ")", ".", "PutTLFCryptKeyServerHalves", "(", "ctx", ",", "keyServerHalves", ")", "\n", "}" ]

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

[ "func", "(", "k", "*", "KeyOpsStandard", ")", "DeleteTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ")", "error", "{", "return", "k", ".", "config", ".", "KeyServer", "(", ")", ".", "DeleteTLFCryptKeyServerHalf", "(", "ctx", ",", "uid", ",", "key", ",", "serverHalfID", ")", "\n", "}" ]

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

[ "func", "(", "m", "*", "CachedFullSelf", ")", "WithSelfForcePoll", "(", "ctx", "context", ".", "Context", ",", "f", "func", "(", "u", "*", "User", ")", "error", ")", "error", "{", "arg", ":=", "NewLoadUserArg", "(", "m", ".", "G", "(", ")", ")", ".", "WithPublicKeyOptional", "(", ")", ".", "WithSelf", "(", "true", ")", ".", "WithNetContext", "(", "ctx", ")", ".", "WithForcePoll", "(", "true", ")", "\n", "return", "m", ".", "WithUser", "(", "arg", ",", "f", ")", "\n", "}" ]

[ "WithSelfForcePoll", "is", "like", "WithSelf", "but", "forces", "a", "poll", ".", "I", ".", "e", ".", "it", "will", "always", "go", "to", "the", "server", "for", "a", "merkle", "check", "regardless", "of", "when", "the", "existing", "self", "was", "cached", "." ]

[ "func", "(", "m", "*", "CachedFullSelf", ")", "WithUser", "(", "arg", "LoadUserArg", ",", "f", "func", "(", "u", "*", "User", ")", "error", ")", "(", "err", "error", ")", "{", "ctx", ":=", "arg", ".", "GetNetContext", "(", ")", "\n", "ctx", "=", "WithLogTag", "(", "ctx", ",", "\"", "\"", ")", "\n", "arg", "=", "arg", ".", "WithNetContext", "(", "ctx", ")", "\n\n", "m", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ")", "\n", "m", ".", "Lock", "(", ")", "\n\n", "defer", "func", "(", ")", "{", "m", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "m", ".", "Unlock", "(", ")", "\n", "}", "(", ")", "\n\n", "var", "u", "*", "User", "\n\n", "if", "m", ".", "me", "!=", "nil", "&&", "m", ".", "isSelfLoad", "(", "arg", ")", "{", "m", ".", "maybeClearCache", "(", "ctx", ",", "&", "arg", ")", "\n", "}", "\n\n", "if", "m", ".", "me", "==", "nil", "||", "!", "m", ".", "isSelfLoad", "(", "arg", ")", "{", "if", "m", ".", "TestDeadlocker", "!=", "nil", "{", "m", ".", "TestDeadlocker", "(", ")", "\n", "}", "\n\n", "u", ",", "err", "=", "LoadUser", "(", "arg", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// WARNING! You can't call m.G().GetMyUID() if this function is called from", "// within the Account/LoginState inner loop. Because m.G().GetMyUID() calls", "// back into Account, it will deadlock.", "if", "arg", ".", "self", "||", "u", ".", "GetUID", "(", ")", ".", "Equal", "(", "m", ".", "G", "(", ")", ".", "GetMyUID", "(", ")", ")", "{", "m", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "m", ".", "cacheMe", "(", "u", ")", "\n", "if", "ldr", ":=", "m", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ";", "ldr", "!=", "nil", "{", "if", "err", ":=", "ldr", ".", "PutUserToCache", "(", "ctx", ",", "u", ")", ";", "err", "!=", "nil", "{", "m", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "m", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "{", "m", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "u", "=", "m", ".", "me", "\n", "}", "\n", "return", "f", "(", "u", ")", "\n", "}" ]

[ "WithUser", "loads", "any", "old", "user", ".", "If", "it", "happens", "to", "be", "the", "self", "user", "then", "it", "behaves", "as", "in", "WithSelf", ".", "Otherwise", "it", "will", "just", "load", "the", "user", "and", "throw", "it", "out", "when", "done", ".", "WithUser", "supports", "other", "so", "that", "code", "doesn", "t", "need", "to", "change", "if", "we", "re", "doing", "the", "operation", "for", "the", "user", "or", "someone", "else", "." ]

[ "func", "(", "m", "*", "CachedFullSelf", ")", "HandleUserChanged", "(", "u", "keybase1", ".", "UID", ")", "error", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n", "if", "m", ".", "me", "!=", "nil", "&&", "m", ".", "me", ".", "GetUID", "(", ")", ".", "Equal", "(", "u", ")", "{", "m", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "u", ")", "\n", "m", ".", "me", "=", "nil", "\n", "}", "else", "{", "m", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "u", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "HandleUserChanged", "clears", "the", "cached", "self", "user", "if", "it", "s", "the", "UID", "of", "the", "self", "user", "." ]

[ "func", "(", "m", "*", "CachedFullSelf", ")", "OnLogin", "(", "mctx", "MetaContext", ")", "error", "{", "m", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "Unlock", "(", ")", "\n", "if", "m", ".", "me", "!=", "nil", "&&", "!", "m", ".", "me", ".", "GetUID", "(", ")", ".", "Equal", "(", "m", ".", "G", "(", ")", ".", "GetMyUID", "(", ")", ")", "{", "m", ".", "me", "=", "nil", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "OnLogin", "clears", "the", "cached", "self", "user", "if", "it", "differs", "from", "what", "s", "already", "cached", "." ]

[ "func", "(", "f", "*", "FSNotifications", ")", "QueueNotification", "(", "fn", "func", "(", ")", ")", "{", "f", ".", "notificationMutex", ".", "RLock", "(", ")", "\n", "defer", "f", ".", "notificationMutex", ".", "RUnlock", "(", ")", "\n", "if", "f", ".", "notifications", "==", "nil", "{", "f", ".", "log", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "f", ".", "notificationGroup", ".", "Add", "(", "1", ")", "\n", "f", ".", "notifications", ".", "In", "(", ")", "<-", "fn", "\n", "}" ]

[ "QueueNotification", "queues", "a", "notification", "which", "must", "be", "goroutine", "-", "safe", "." ]

[ "func", "(", "f", "*", "FSNotifications", ")", "LaunchProcessor", "(", "ctx", "context", ".", "Context", ")", "{", "f", ".", "notificationMutex", ".", "Lock", "(", ")", "\n", "defer", "f", ".", "notificationMutex", ".", "Unlock", "(", ")", "\n\n", "f", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "// The notifications channel needs to have \"infinite\" capacity,", "// because otherwise we risk a deadlock between libkbfs and", "// libfs. The notification processor sends invalidates to the", "// kernel. In osxfuse 3.X, the kernel can call back into userland", "// during an invalidate (a GetAttr()) call, which in turn takes", "// locks within libkbfs. So if libkbfs ever gets blocked while", "// trying to enqueue a notification (while it is holding locks),", "// we could have a deadlock. Yes, if there are too many", "// outstanding notifications we'll run out of memory and crash,", "// but otherwise we risk deadlock. Which is worse?", "f", ".", "notifications", "=", "channels", ".", "NewInfiniteChannel", "(", ")", "\n\n", "// start the notification processor", "go", "f", ".", "processNotifications", "(", "ctx", ")", "\n", "}" ]

[ "LaunchProcessor", "launches", "the", "notification", "processor", "." ]

[ "func", "VerifyPhoneNumber", "(", "mctx", "libkb", ".", "MetaContext", ",", "phoneNumber", "keybase1", ".", "PhoneNumber", ",", "code", "string", ")", "error", "{", "payload", ":=", "make", "(", "libkb", ".", "JSONPayload", ")", "\n", "payload", "[", "\"", "\"", "]", "=", "phoneNumber", "\n", "payload", "[", "\"", "\"", "]", "=", "code", "\n\n", "arg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "JSONPayload", ":", "payload", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "}", "\n\n", "_", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "API", ".", "PostJSON", "(", "mctx", ",", "arg", ")", "\n", "return", "err", "\n", "}" ]

[ "VerifyPhoneNumber", "calls", "API", "to", "verify", "previously", "added", "phone", "number", "using", "verification", "code", "." ]

[ "func", "GetPhoneNumbers", "(", "mctx", "libkb", ".", "MetaContext", ")", "(", "[", "]", "keybase1", ".", "UserPhoneNumber", ",", "error", ")", "{", "arg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "}", "\n", "var", "resp", "phoneNumbersResponse", "\n", "err", ":=", "mctx", ".", "G", "(", ")", ".", "API", ".", "GetDecode", "(", "mctx", ",", "arg", ",", "&", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "resp", ".", "PhoneNumbers", ",", "nil", "\n", "}" ]

[ "GetPhoneNumbers", "calls", "API", "to", "fetch", "list", "of", "phone", "numbers", "attached", "to", "currently", "logged", "user", "." ]

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

[ "Performs", "paper", "provision", ".", "If", "the", "current", "device", "isn", "t", "provisioned", "this", "function", "will", "provision", "it", "." ]

[ "func", "AppBundleForPath", "(", ")", "(", "string", ",", "error", ")", "{", "path", ",", "err", ":=", "utils", ".", "BinPath", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "path", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "paths", ":=", "strings", ".", "SplitN", "(", "path", ",", "\"", "\"", ",", "2", ")", "\n", "// If no match, return \"\"", "if", "len", "(", "paths", ")", "<=", "1", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n\n", "appPath", ":=", "paths", "[", "0", "]", "+", "\"", "\"", "\n", "if", "exists", ",", "_", ":=", "libkb", ".", "FileExists", "(", "appPath", ")", ";", "!", "exists", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "appPath", ")", "\n", "}", "\n\n", "return", "appPath", ",", "nil", "\n", "}" ]

[ "AppBundleForPath", "returns", "path", "to", "app", "bundle" ]

[ "func", "NewReporterKBPKI", "(", "config", "Config", ",", "maxErrors", ",", "bufSize", "int", ")", "*", "ReporterKBPKI", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "r", ":=", "&", "ReporterKBPKI", "{", "ReporterSimple", ":", "NewReporterSimple", "(", "config", ".", "Clock", "(", ")", ",", "maxErrors", ")", ",", "config", ":", "config", ",", "log", ":", "log", ",", "vlog", ":", "config", ".", "MakeVLogger", "(", "log", ")", ",", "notifyBuffer", ":", "make", "(", "chan", "*", "keybase1", ".", "FSNotification", ",", "bufSize", ")", ",", "onlineStatusBuffer", ":", "make", "(", "chan", "bool", ",", "bufSize", ")", ",", "notifyPathBuffer", ":", "make", "(", "chan", "string", ",", "1", ")", ",", "notifySyncBuffer", ":", "make", "(", "chan", "*", "keybase1", ".", "FSPathSyncStatus", ",", "1", ")", ",", "notifyOverallSyncBuffer", ":", "make", "(", "chan", "keybase1", ".", "FolderSyncStatus", ",", "1", ")", ",", "shutdownCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "var", "ctx", "context", ".", "Context", "\n", "ctx", ",", "r", ".", "canceler", "=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "go", "r", ".", "send", "(", "ctx", ")", "\n", "return", "r", "\n", "}" ]

[ "NewReporterKBPKI", "creates", "a", "new", "ReporterKBPKI", "." ]

[ "func", "(", "r", "*", "ReporterKBPKI", ")", "NotifyOverallSyncStatus", "(", "ctx", "context", ".", "Context", ",", "status", "keybase1", ".", "FolderSyncStatus", ")", "{", "select", "{", "case", "r", ".", "notifyOverallSyncBuffer", "<-", "status", ":", "default", ":", "// If this represents a \"complete\" status, we can't drop it.", "// Instead launch a goroutine to make sure it gets sent", "// eventually.", "if", "status", ".", "PrefetchStatus", "==", "keybase1", ".", "PrefetchStatus_COMPLETE", "{", "go", "func", "(", ")", "{", "select", "{", "case", "r", ".", "notifyOverallSyncBuffer", "<-", "status", ":", "case", "<-", "r", ".", "shutdownCh", ":", "}", "\n", "}", "(", ")", "\n", "}", "else", "{", "r", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "status", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "NotifyOverallSyncStatus", "implements", "the", "Reporter", "interface", "for", "ReporterKBPKI", "." ]

[ "func", "(", "r", "*", "ReporterKBPKI", ")", "Shutdown", "(", ")", "{", "r", ".", "canceler", "(", ")", "\n", "close", "(", "r", ".", "shutdownCh", ")", "\n", "close", "(", "r", ".", "notifyBuffer", ")", "\n", "close", "(", "r", ".", "onlineStatusBuffer", ")", "\n", "close", "(", "r", ".", "notifySyncBuffer", ")", "\n", "close", "(", "r", ".", "notifyOverallSyncBuffer", ")", "\n", "}" ]

[ "Shutdown", "implements", "the", "Reporter", "interface", "for", "ReporterKBPKI", "." ]

[ "func", "(", "r", "*", "ReporterKBPKI", ")", "send", "(", "ctx", "context", ".", "Context", ")", "{", "sendTicker", ":=", "time", ".", "NewTicker", "(", "reporterSendInterval", ")", "\n", "defer", "sendTicker", ".", "Stop", "(", ")", "\n\n", "for", "{", "select", "{", "case", "notification", ",", "ok", ":=", "<-", "r", ".", "notifyBuffer", ":", "if", "!", "ok", "{", "return", "\n", "}", "\n", "nt", ":=", "notification", ".", "NotificationType", "\n", "st", ":=", "notification", ".", "StatusCode", "\n", "// Only these notifications are used in frontend:", "// https://github.com/keybase/client/blob/0d63795105f64289ba4ef20fbefe56aad91bc7e9/shared/util/kbfs-notifications.js#L142-L154", "if", "nt", "!=", "keybase1", ".", "FSNotificationType_REKEYING", "&&", "nt", "!=", "keybase1", ".", "FSNotificationType_INITIALIZED", "&&", "nt", "!=", "keybase1", ".", "FSNotificationType_CONNECTION", "&&", "st", "!=", "keybase1", ".", "FSStatusCode_ERROR", "{", "continue", "\n", "}", "\n", "// Send them right away rather than staging it and waiting for the", "// ticker, since each of them can be distinct from each other.", "if", "err", ":=", "r", ".", "config", ".", "KeybaseService", "(", ")", ".", "Notify", "(", "ctx", ",", "notification", ")", ";", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "case", "online", ",", "ok", ":=", "<-", "r", ".", "onlineStatusBuffer", ":", "if", "!", "ok", "{", "return", "\n", "}", "\n", "if", "err", ":=", "r", ".", "config", ".", "KeybaseService", "(", ")", ".", "NotifyOnlineStatusChanged", "(", "ctx", ",", "online", ")", ";", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "case", "<-", "sendTicker", ".", "C", ":", "select", "{", "case", "path", ",", "ok", ":=", "<-", "r", ".", "notifyPathBuffer", ":", "if", "!", "ok", "{", "return", "\n", "}", "\n", "if", "err", ":=", "r", ".", "config", ".", "KeybaseService", "(", ")", ".", "NotifyPathUpdated", "(", "ctx", ",", "path", ")", ";", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "default", ":", "}", "\n\n", "select", "{", "case", "status", ",", "ok", ":=", "<-", "r", ".", "notifySyncBuffer", ":", "if", "!", "ok", "{", "return", "\n", "}", "\n", "if", "err", ":=", "r", ".", "config", ".", "KeybaseService", "(", ")", ".", "NotifySyncStatus", "(", "ctx", ",", "status", ")", ";", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "default", ":", "}", "\n\n", "select", "{", "case", "status", ",", "ok", ":=", "<-", "r", ".", "notifyOverallSyncBuffer", ":", "if", "!", "ok", "{", "return", "\n", "}", "\n", "if", "err", ":=", "r", ".", "config", ".", "KeybaseService", "(", ")", ".", "NotifyOverallSyncStatus", "(", "ctx", ",", "status", ")", ";", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "default", ":", "}", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "send", "takes", "notifications", "out", "of", "notifyBuffer", "notifyPathBuffer", "and", "notifySyncBuffer", "and", "sends", "them", "to", "the", "keybase", "daemon", "." ]

[ "func", "writeNotification", "(", "file", "data", ".", "Path", ",", "finish", "bool", ")", "*", "keybase1", ".", "FSNotification", "{", "n", ":=", "baseNotification", "(", "file", ",", "finish", ")", "\n", "if", "file", ".", "Tlf", ".", "Type", "(", ")", "==", "tlf", ".", "Public", "{", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_SIGNING", "\n", "}", "else", "{", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_ENCRYPTING", "\n", "}", "\n", "return", "n", "\n", "}" ]

[ "writeNotification", "creates", "FSNotifications", "from", "paths", "for", "file", "write", "events", "." ]

[ "func", "readNotification", "(", "file", "data", ".", "Path", ",", "finish", "bool", ")", "*", "keybase1", ".", "FSNotification", "{", "n", ":=", "baseNotification", "(", "file", ",", "finish", ")", "\n", "if", "file", ".", "Tlf", ".", "Type", "(", ")", "==", "tlf", ".", "Public", "{", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_VERIFYING", "\n", "}", "else", "{", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_DECRYPTING", "\n", "}", "\n", "return", "n", "\n", "}" ]

[ "readNotification", "creates", "FSNotifications", "from", "paths", "for", "file", "read", "events", "." ]

[ "func", "rekeyNotification", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ",", "handle", "*", "tlfhandle", ".", "Handle", ",", "finish", "bool", ")", "*", "keybase1", ".", "FSNotification", "{", "code", ":=", "keybase1", ".", "FSStatusCode_START", "\n", "if", "finish", "{", "code", "=", "keybase1", ".", "FSStatusCode_FINISH", "\n", "}", "\n\n", "return", "&", "keybase1", ".", "FSNotification", "{", "FolderType", ":", "handle", ".", "Type", "(", ")", ".", "FolderType", "(", ")", ",", "Filename", ":", "string", "(", "handle", ".", "GetCanonicalPath", "(", ")", ")", ",", "StatusCode", ":", "code", ",", "NotificationType", ":", "keybase1", ".", "FSNotificationType_REKEYING", ",", "}", "\n", "}" ]

[ "rekeyNotification", "creates", "FSNotifications", "from", "TlfHandles", "for", "rekey", "events", "." ]

[ "func", "fileCreateNotification", "(", "file", "data", ".", "Path", ",", "writer", "keybase1", ".", "UID", ",", "localTime", "time", ".", "Time", ")", "*", "keybase1", ".", "FSNotification", "{", "n", ":=", "baseFileEditNotification", "(", "file", ",", "writer", ",", "localTime", ")", "\n", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_FILE_CREATED", "\n", "return", "n", "\n", "}" ]

[ "fileCreateNotification", "creates", "FSNotifications", "from", "paths", "for", "file", "create", "events", "." ]

[ "func", "fileModifyNotification", "(", "file", "data", ".", "Path", ",", "writer", "keybase1", ".", "UID", ",", "localTime", "time", ".", "Time", ")", "*", "keybase1", ".", "FSNotification", "{", "n", ":=", "baseFileEditNotification", "(", "file", ",", "writer", ",", "localTime", ")", "\n", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_FILE_MODIFIED", "\n", "return", "n", "\n", "}" ]

[ "fileModifyNotification", "creates", "FSNotifications", "from", "paths", "for", "file", "modification", "events", "." ]

[ "func", "fileDeleteNotification", "(", "file", "data", ".", "Path", ",", "writer", "keybase1", ".", "UID", ",", "localTime", "time", ".", "Time", ")", "*", "keybase1", ".", "FSNotification", "{", "n", ":=", "baseFileEditNotification", "(", "file", ",", "writer", ",", "localTime", ")", "\n", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_FILE_DELETED", "\n", "return", "n", "\n", "}" ]

[ "fileDeleteNotification", "creates", "FSNotifications", "from", "paths", "for", "file", "delete", "events", "." ]

[ "func", "fileRenameNotification", "(", "oldFile", "data", ".", "Path", ",", "newFile", "data", ".", "Path", ",", "writer", "keybase1", ".", "UID", ",", "localTime", "time", ".", "Time", ")", "*", "keybase1", ".", "FSNotification", "{", "n", ":=", "baseFileEditNotification", "(", "newFile", ",", "writer", ",", "localTime", ")", "\n", "n", ".", "NotificationType", "=", "keybase1", ".", "FSNotificationType_FILE_RENAMED", "\n", "n", ".", "Params", "=", "map", "[", "string", "]", "string", "{", "errorParamRenameOldFilename", ":", "oldFile", ".", "CanonicalPathString", "(", ")", "}", "\n", "return", "n", "\n", "}" ]

[ "fileRenameNotification", "creates", "FSNotifications", "from", "paths", "for", "file", "rename", "events", "." ]

[ "func", "connectionNotification", "(", "status", "keybase1", ".", "FSStatusCode", ")", "*", "keybase1", ".", "FSNotification", "{", "// TODO finish placeholder", "return", "&", "keybase1", ".", "FSNotification", "{", "NotificationType", ":", "keybase1", ".", "FSNotificationType_CONNECTION", ",", "StatusCode", ":", "status", ",", "}", "\n", "}" ]

[ "connectionNotification", "creates", "FSNotifications", "based", "on", "whether", "or", "not", "KBFS", "is", "online", "." ]

[ "func", "baseNotification", "(", "file", "data", ".", "Path", ",", "finish", "bool", ")", "*", "keybase1", ".", "FSNotification", "{", "code", ":=", "keybase1", ".", "FSStatusCode_START", "\n", "if", "finish", "{", "code", "=", "keybase1", ".", "FSStatusCode_FINISH", "\n", "}", "\n\n", "return", "&", "keybase1", ".", "FSNotification", "{", "Filename", ":", "file", ".", "CanonicalPathString", "(", ")", ",", "StatusCode", ":", "code", ",", "}", "\n", "}" ]

[ "baseNotification", "creates", "a", "basic", "FSNotification", "without", "a", "NotificationType", "from", "a", "path", "." ]

[ "func", "errorNotification", "(", "err", "error", ",", "errType", "keybase1", ".", "FSErrorType", ",", "tlfName", "tlf", ".", "CanonicalName", ",", "t", "tlf", ".", "Type", ",", "mode", "ErrorModeType", ",", "filename", "string", ",", "params", "map", "[", "string", "]", "string", ")", "*", "keybase1", ".", "FSNotification", "{", "if", "tlfName", "!=", "\"", "\"", "{", "params", "[", "errorParamTlf", "]", "=", "string", "(", "tlfName", ")", "\n", "}", "\n", "var", "nType", "keybase1", ".", "FSNotificationType", "\n", "switch", "mode", "{", "case", "ReadMode", ":", "params", "[", "errorParamMode", "]", "=", "errorModeRead", "\n", "if", "t", "==", "tlf", ".", "Public", "{", "nType", "=", "keybase1", ".", "FSNotificationType_VERIFYING", "\n", "}", "else", "{", "nType", "=", "keybase1", ".", "FSNotificationType_DECRYPTING", "\n", "}", "\n", "case", "WriteMode", ":", "params", "[", "errorParamMode", "]", "=", "errorModeWrite", "\n", "if", "t", "==", "tlf", ".", "Public", "{", "nType", "=", "keybase1", ".", "FSNotificationType_SIGNING", "\n", "}", "else", "{", "nType", "=", "keybase1", ".", "FSNotificationType_ENCRYPTING", "\n", "}", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "mode", ")", ")", "\n", "}", "\n", "return", "&", "keybase1", ".", "FSNotification", "{", "FolderType", ":", "t", ".", "FolderType", "(", ")", ",", "Filename", ":", "filename", ",", "StatusCode", ":", "keybase1", ".", "FSStatusCode_ERROR", ",", "Status", ":", "err", ".", "Error", "(", ")", ",", "ErrorType", ":", "errType", ",", "Params", ":", "params", ",", "NotificationType", ":", "nType", ",", "}", "\n", "}" ]

[ "errorNotification", "creates", "FSNotifications", "for", "errors", "." ]

[ "func", "NewKeyFinder", "(", "g", "*", "globals", ".", "Context", ")", "types", ".", "KeyFinder", "{", "return", "&", "KeyFinderImpl", "{", "Contextified", ":", "globals", ".", "NewContextified", "(", "g", ")", ",", "DebugLabeler", ":", "utils", ".", "NewDebugLabeler", "(", "g", ".", "GetLog", "(", ")", ",", "\"", "\"", ",", "false", ")", ",", "keys", ":", "make", "(", "map", "[", "string", "]", "*", "types", ".", "NameInfo", ")", ",", "decKeys", ":", "make", "(", "map", "[", "string", "]", "types", ".", "CryptKey", ")", ",", "encKeys", ":", "make", "(", "map", "[", "string", "]", "encItem", ")", ",", "}", "\n", "}" ]

[ "NewKeyFinder", "creates", "a", "KeyFinder", "." ]

[ "func", "(", "k", "*", "KeyFinderImpl", ")", "FindForEncryption", "(", "ctx", "context", ".", "Context", ",", "tlfName", "string", ",", "tlfID", "chat1", ".", "TLFID", ",", "membersType", "chat1", ".", "ConversationMembersType", ",", "public", "bool", ")", "(", "res", "types", ".", "CryptKey", ",", "ni", "types", ".", "NameInfo", ",", "err", "error", ")", "{", "ckey", ":=", "k", ".", "encCacheKey", "(", "tlfName", ",", "tlfID", ",", "membersType", ",", "public", ")", "\n", "existing", ",", "ok", ":=", "k", ".", "lookupEncKey", "(", "ckey", ")", "\n", "if", "ok", "{", "return", "existing", ".", "key", ",", "existing", ".", "ni", ",", "nil", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "k", ".", "writeEncKey", "(", "ckey", ",", "encItem", "{", "key", ":", "res", ",", "ni", ":", "ni", ",", "}", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "k", ".", "createNameInfoSource", "(", "ctx", ",", "membersType", ")", ".", "EncryptionKey", "(", "ctx", ",", "tlfName", ",", "tlfID", ",", "membersType", ",", "public", ")", "\n", "}" ]

[ "FindForEncryption", "finds", "keys", "up", "-", "to", "-", "date", "enough", "for", "encrypting", ".", "Ignores", "tlfName", "or", "teamID", "based", "on", "membersType", "." ]

[ "func", "(", "k", "*", "KeyFinderImpl", ")", "FindForDecryption", "(", "ctx", "context", ".", "Context", ",", "tlfName", "string", ",", "tlfID", "chat1", ".", "TLFID", ",", "membersType", "chat1", ".", "ConversationMembersType", ",", "public", "bool", ",", "keyGeneration", "int", ",", "kbfsEncrypted", "bool", ")", "(", "res", "types", ".", "CryptKey", ",", "err", "error", ")", "{", "ckey", ":=", "k", ".", "decCacheKey", "(", "tlfName", ",", "tlfID", ",", "membersType", ",", "keyGeneration", ",", "public", ",", "kbfsEncrypted", ")", "\n", "existing", ",", "ok", ":=", "k", ".", "lookupDecKey", "(", "ckey", ")", "\n", "if", "ok", "{", "return", "existing", ",", "nil", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "k", ".", "writeDecKey", "(", "ckey", ",", "res", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "k", ".", "createNameInfoSource", "(", "ctx", ",", "membersType", ")", ".", "DecryptionKey", "(", "ctx", ",", "tlfName", ",", "tlfID", ",", "membersType", ",", "public", ",", "keyGeneration", ",", "kbfsEncrypted", ")", "\n", "}" ]

[ "FindForDecryption", "ignores", "tlfName", "or", "teamID", "based", "on", "membersType", "." ]

[ "func", "(", "r", "*", "decodingReadSeeker", ")", "getChunksFromCache", "(", "chunks", "[", "]", "chunkSpec", ")", "(", "res", "[", "]", "byte", ",", "ok", "bool", ")", "{", "for", "_", ",", "c", ":=", "range", "chunks", "{", "if", "pt", ",", "ok", ":=", "r", ".", "chunks", ".", "Get", "(", "c", ".", "index", ")", ";", "ok", "{", "res", "=", "append", "(", "res", ",", "pt", ".", "(", "[", "]", "byte", ")", "...", ")", "\n", "r", ".", "Debug", "(", "r", ".", "ctx", ",", "\"", "\"", ",", "c", ".", "index", ",", "len", "(", "pt", ".", "(", "[", "]", "byte", ")", ")", ")", "\n", "}", "else", "{", "r", ".", "Debug", "(", "r", ".", "ctx", ",", "\"", "\"", ",", "c", ".", "index", ")", "\n", "return", "res", ",", "false", "\n", "}", "\n", "}", "\n", "return", "res", ",", "true", "\n", "}" ]

[ "getChunksFromCache", "returns", "the", "plaintext", "bytes", "for", "a", "set", "of", "chunks", "iff", "we", "have", "each", "chunk", "in", "our", "cache" ]

[ "func", "(", "r", "*", "decodingReadSeeker", ")", "getReadaheadFactor", "(", ")", "int64", "{", "mb", ":=", "int64", "(", "1", "<<", "20", ")", "\n", "switch", "{", "case", "r", ".", "size", ">=", "1000", "*", "mb", ":", "return", "16", "\n", "case", "r", ".", "size", ">=", "500", "*", "mb", ":", "return", "8", "\n", "default", ":", "return", "4", "\n", "}", "\n", "}" ]

[ "getReadaheadFactor", "gives", "the", "number", "of", "chunks", "we", "should", "read", "at", "minimum", "from", "the", "source", ".", "For", "larger", "files", "we", "try", "to", "read", "more", "so", "we", "don", "t", "make", "too", "many", "underlying", "requests", "." ]

[ "func", "(", "s", "*", "DeviceEKStorage", ")", "ekLogf", "(", "mctx", "libkb", ".", "MetaContext", ",", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "mctx", ".", "Debug", "(", "format", ",", "args", "...", ")", "\n", "if", "s", ".", "logger", "!=", "nil", "{", "s", ".", "logger", ".", "Printf", "(", "format", ",", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Log", "sensitive", "deletion", "actions", "to", "a", "separate", "log", "file", "so", "we", "don", "t", "lose", "the", "logs", "during", "normal", "rotation", "." ]

[ "func", "(", "s", "*", "DeviceEKStorage", ")", "keyToEldestSeqno", "(", "mctx", "libkb", ".", "MetaContext", ",", "key", "string", ")", "keybase1", ".", "Seqno", "{", "if", "!", "strings", ".", "HasPrefix", "(", "key", ",", "deviceEKPrefix", ")", "{", "return", "-", "1", "\n", "}", "\n", "parts", ":=", "strings", ".", "Split", "(", "key", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "!=", "4", "{", "return", "-", "1", "\n", "}", "\n", "// Make sure this key is for our current user and not a different one.", "username", ":=", "mctx", ".", "ActiveDevice", "(", ")", ".", "Username", "(", "mctx", ")", "\n", "if", "parts", "[", "1", "]", "!=", "username", ".", "String", "(", ")", "{", "return", "-", "1", "\n", "}", "\n", "e", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "parts", "[", "2", "]", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", "\n", "}", "\n", "return", "keybase1", ".", "Seqno", "(", "e", ")", "\n", "}" ]

[ "keyToEldestSeqno", "parses", "out", "the", "eldestSeqno", "from", "a", "key", "of", "the", "form", "deviceEKPrefix", "-", "username", "-", "eldestSeqno", "-", "generation", ".", "ek", ".", "If", "we", "have", "a", "key", "for", "a", "eldestSeqno", "that", "is", "not", "our", "current", "we", "purge", "it", "since", "we", "don", "t", "want", "the", "ephemeral", "key", "to", "stick", "around", "if", "we", "ve", "reset", ".", "If", "we", "are", "unable", "to", "parse", "out", "the", "value", "the", "key", "is", "not", "valid", "or", "not", "for", "the", "logged", "in", "user", "we", "return", "-", "1" ]

[ "func", "(", "s", "*", "DeviceEKStorage", ")", "keyToGeneration", "(", "mctx", "libkb", ".", "MetaContext", ",", "key", "string", ")", "keybase1", ".", "EkGeneration", "{", "prefix", ",", "err", ":=", "s", ".", "keyPrefix", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "-", "1", "\n", "}", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "key", ",", "prefix", ")", "||", "!", "strings", ".", "HasSuffix", "(", "key", ",", "deviceEKSuffix", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "prefix", ",", "deviceEKSuffix", ")", "\n", "return", "-", "1", "\n", "}", "\n\n", "key", "=", "strings", ".", "TrimSuffix", "(", "key", ",", "deviceEKSuffix", ")", "\n", "parts", ":=", "strings", ".", "Split", "(", "key", ",", "prefix", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "parts", ")", "\n", "return", "-", "1", "\n", "}", "\n", "g", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "parts", "[", "1", "]", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "-", "1", "\n", "}", "\n", "return", "keybase1", ".", "EkGeneration", "(", "g", ")", "\n", "}" ]

[ "keyToEldestSeqno", "parses", "out", "the", "generation", "from", "a", "key", "of", "the", "form", "deviceEKPrefix", "-", "username", "-", "eldestSeqno", "-", "generation", ".", "ek", ".", "Unparseable", "keys", "return", "a", "generation", "of", "-", "1", "and", "should", "be", "ignored", "." ]

[ "func", "(", "s", "*", "DeviceEKStorage", ")", "ListAllForUser", "(", "mctx", "libkb", ".", "MetaContext", ")", "(", "all", "[", "]", "string", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "return", "s", ".", "listAllForUser", "(", "mctx", ",", "mctx", ".", "ActiveDevice", "(", ")", ".", "Username", "(", "mctx", ")", ")", "\n", "}" ]

[ "ListAllForUser", "lists", "the", "internal", "storage", "name", "of", "deviceEKs", "of", "the", "logged", "in", "user", ".", "This", "is", "used", "for", "logsend", "purposes", "to", "debug", "ek", "state", "." ]

[ "func", "RecursiveDelete", "(", "ctx", "context", ".", "Context", ",", "fs", "billy", ".", "Filesystem", ",", "fi", "os", ".", "FileInfo", ")", "error", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n\n", "if", "!", "fi", ".", "IsDir", "(", ")", "{", "// Delete regular files and symlinks directly.", "return", "fs", ".", "Remove", "(", "fi", ".", "Name", "(", ")", ")", "\n", "}", "\n\n", "subdirFS", ",", "err", ":=", "fs", ".", "Chroot", "(", "fi", ".", "Name", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "children", ",", "err", ":=", "subdirFS", ".", "ReadDir", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "childFI", ":=", "range", "children", "{", "if", "childFI", ".", "Name", "(", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "err", ":=", "RecursiveDelete", "(", "ctx", ",", "subdirFS", ",", "childFI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "fs", ".", "Remove", "(", "fi", ".", "Name", "(", ")", ")", "\n", "}" ]

[ "RecursiveDelete", "deletes", "the", "given", "entry", "from", "the", "given", "filesystem", ".", "If", "it", "s", "a", "directory", "first", "all", "the", "items", "in", "the", "directory", "are", "deleted", "recursively", "." ]

[ "func", "process", "(", "h", "*", "handler", ",", "in", "nativemessaging", ".", "JSONDecoder", ",", "out", "nativemessaging", ".", "JSONEncoder", ")", "error", "{", "var", "resp", "Response", "\n", "var", "req", "Request", "\n\n", "// If input fails to parse, we can't guarantee future inputs will", "// get into a parseable state so we abort after sending an error", "// response.", "abortErr", ":=", "in", ".", "Decode", "(", "&", "req", ")", "\n\n", "var", "err", "error", "\n", "if", "abortErr", "==", "nil", "{", "resp", ".", "Result", ",", "err", "=", "h", ".", "Handle", "(", "&", "req", ")", "\n", "}", "\n\n", "if", "err", "==", "io", ".", "EOF", "{", "// Closed", "return", "err", "\n", "}", "else", "if", "err", "!=", "nil", "{", "resp", ".", "Status", "=", "\"", "\"", "\n", "resp", ".", "Message", "=", "err", ".", "Error", "(", ")", "\n", "}", "else", "{", "// Success", "resp", ".", "Status", "=", "\"", "\"", "\n", "}", "\n", "resp", ".", "Client", "=", "req", ".", "Client", "\n\n", "err", "=", "out", ".", "Encode", "(", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "// TODO: Log this somewhere?", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n\n", "return", "abortErr", "\n", "}" ]

[ "process", "consumes", "a", "single", "message" ]

[ "func", "Params", "(", "kbCtx", "libkbfs", ".", "Context", ",", "storageRoot", "string", ",", "paramsBase", "*", "libkbfs", ".", "InitParams", ")", "(", "params", "libkbfs", ".", "InitParams", ",", "tempDir", "string", ",", "err", "error", ")", "{", "tempDir", ",", "err", "=", "ioutil", ".", "TempDir", "(", "storageRoot", ",", "libkbfs", ".", "GitStorageRootPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "libkbfs", ".", "InitParams", "{", "}", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "paramsBase", "!=", "nil", "{", "params", "=", "*", "paramsBase", "\n", "}", "else", "{", "params", "=", "libkbfs", ".", "DefaultInitParams", "(", "kbCtx", ")", "\n", "}", "\n", "params", ".", "LogToFile", "=", "true", "\n", "// Set the debug default to true only if the env variable isn't", "// explicitly set to a false option.", "envDebug", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "envDebug", "!=", "\"", "\"", "&&", "envDebug", "!=", "\"", "\"", "&&", "envDebug", "!=", "\"", "\"", "{", "params", ".", "Debug", "=", "true", "\n", "}", "\n", "// This is set to false in docker tests for now, but we need it. So", "// override it to true here.", "params", ".", "EnableJournal", "=", "true", "\n", "params", ".", "DiskCacheMode", "=", "libkbfs", ".", "DiskCacheModeRemote", "\n", "params", ".", "StorageRoot", "=", "tempDir", "\n", "params", ".", "Mode", "=", "libkbfs", ".", "InitSingleOpString", "\n", "params", ".", "TLFJournalBackgroundWorkStatus", "=", "libkbfs", ".", "TLFJournalSingleOpBackgroundWorkEnabled", "\n\n", "if", "baddr", ":=", "os", ".", "Getenv", "(", "paramKeybaseGitBServerAddr", ")", ";", "len", "(", "baddr", ")", ">", "0", "{", "params", ".", "BServerAddr", "=", "baddr", "\n", "}", "\n", "if", "mdaddr", ":=", "os", ".", "Getenv", "(", "paramKeybaseGitMDServerAddr", ")", ";", "len", "(", "mdaddr", ")", ">", "0", "{", "params", ".", "MDServerAddr", "=", "mdaddr", "\n", "}", "\n\n", "return", "params", ",", "tempDir", ",", "nil", "\n", "}" ]

[ "Params", "returns", "a", "set", "of", "default", "parameters", "for", "git", "-", "related", "operations", "along", "with", "a", "temp", "directory", "that", "should", "be", "cleaned", "after", "the", "git", "work", "is", "complete", "." ]

[ "func", "Init", "(", "ctx", "context", ".", "Context", ",", "gitKBFSParams", "libkbfs", ".", "InitParams", ",", "kbCtx", "libkbfs", ".", "Context", ",", "keybaseServiceCn", "libkbfs", ".", "KeybaseServiceCn", ",", "defaultLogPath", "string", ",", "vlogLevel", "string", ")", "(", "context", ".", "Context", ",", "libkbfs", ".", "Config", ",", "error", ")", "{", "log", ",", "err", ":=", "libkbfs", ".", "InitLogWithPrefix", "(", "gitKBFSParams", ",", "kbCtx", ",", "\"", "\"", ",", "defaultLogPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ctx", ",", "nil", ",", "err", "\n", "}", "\n\n", "// Assign a unique ID to each remote-helper instance, since", "// they'll all share the same log.", "ctx", ",", "err", "=", "libcontext", ".", "NewContextWithCancellationDelayer", "(", "libkbfs", ".", "CtxWithRandomIDReplayable", "(", "ctx", ",", "ctxGitIDKey", ",", "ctxGitOpID", ",", "log", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ctx", ",", "nil", ",", "err", "\n", "}", "\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "config", ",", "err", ":=", "libkbfs", ".", "InitWithLogPrefix", "(", "ctx", ",", "kbCtx", ",", "gitKBFSParams", ",", "keybaseServiceCn", ",", "nil", ",", "log", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ctx", ",", "nil", ",", "err", "\n", "}", "\n", "config", ".", "SetVLogLevel", "(", "vlogLevel", ")", "\n\n", "// Make any blocks written by via this config charged to the git", "// quota.", "config", ".", "SetDefaultBlockType", "(", "keybase1", ".", "BlockType_GIT", ")", "\n\n", "config", ".", "MakeDiskBlockCacheIfNotExists", "(", ")", "\n\n", "return", "ctx", ",", "config", ",", "nil", "\n", "}" ]

[ "Init", "initializes", "a", "context", "and", "a", "libkbfs", ".", "Config", "for", "git", "operations", ".", "The", "config", "should", "be", "shutdown", "when", "it", "is", "done", "being", "used", "." ]

[ "func", "ProfileGet", "(", "name", "string", ")", "func", "(", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "p", ":=", "pprof", ".", "Lookup", "(", "name", ")", "\n", "if", "p", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// See https://golang.org/pkg/runtime/pprof/#Profile.WriteTo", "// for the meaning of debug.", "debug", ":=", "1", "\n", "if", "name", "==", "\"", "\"", "{", "debug", "=", "2", "\n", "}", "\n", "return", "profileRead", "(", "p", ",", "debug", ")", "\n", "}" ]

[ "ProfileGet", "gets", "the", "relevant", "read", "function", "for", "the", "profile", "or", "nil", "if", "it", "doesn", "t", "exist", "." ]

[ "func", "profileRead", "(", "p", "*", "pprof", ".", "Profile", ",", "debug", "int", ")", "func", "(", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "return", "func", "(", "_", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "var", "b", "bytes", ".", "Buffer", "\n", "err", ":=", "p", ".", "WriteTo", "(", "&", "b", ",", "debug", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "b", ".", "Bytes", "(", ")", ",", "time", ".", "Now", "(", ")", ",", "nil", "\n", "}", "\n", "}" ]

[ "profileRead", "reads", "from", "a", "Profile", "." ]

[ "func", "tokenize", "(", "msgText", "string", ")", "tokenMap", "{", "if", "msgText", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "// split the message text up on basic punctuation/spaces", "tokens", ":=", "splitExpr", ".", "Split", "(", "msgText", ",", "-", "1", ")", "\n", "tokenMap", ":=", "tokenMap", "{", "}", "\n", "for", "_", ",", "token", ":=", "range", "tokens", "{", "if", "len", "(", "token", ")", "<", "MinTokenLength", "{", "continue", "\n", "}", "\n\n", "token", "=", "strings", ".", "ToLower", "(", "token", ")", "\n", "if", "_", ",", "ok", ":=", "tokenMap", "[", "token", "]", ";", "!", "ok", "{", "tokenMap", "[", "token", "]", "=", "map", "[", "string", "]", "chat1", ".", "EmptyStruct", "{", "}", "\n", "}", "\n\n", "// strip separators to raw tokens which we count as an alias to the", "// original token", "stripped", ":=", "stripExpr", ".", "Split", "(", "token", ",", "-", "1", ")", "\n", "for", "_", ",", "s", ":=", "range", "stripped", "{", "if", "s", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "tokenMap", "[", "token", "]", "[", "s", "]", "=", "chat1", ".", "EmptyStruct", "{", "}", "\n\n", "// add the stem as an alias", "stemmed", ":=", "porterstemmer", ".", "StemWithoutLowerCasing", "(", "[", "]", "rune", "(", "s", ")", ")", "\n", "tokenMap", "[", "token", "]", "[", "string", "(", "stemmed", ")", "]", "=", "chat1", ".", "EmptyStruct", "{", "}", "\n\n", "// calculate prefixes to alias to the token", "for", "_", ",", "prefix", ":=", "range", "prefixes", "(", "s", ")", "{", "tokenMap", "[", "token", "]", "[", "prefix", "]", "=", "chat1", ".", "EmptyStruct", "{", "}", "\n", "}", "\n", "}", "\n", "// drop the original token from the set of aliases", "delete", "(", "tokenMap", "[", "token", "]", ",", "token", ")", "\n", "}", "\n", "return", "tokenMap", "\n", "}" ]

[ "getIndexTokens", "splits", "the", "content", "of", "the", "given", "message", "on", "whitespace", "and", "special", "characters", "returning", "a", "map", "of", "tokens", "to", "aliases", "normalized", "to", "lowercase", "." ]

[ "func", "getUIMsgs", "(", "ctx", "context", ".", "Context", ",", "g", "*", "globals", ".", "Context", ",", "convID", "chat1", ".", "ConversationID", ",", "uid", "gregor1", ".", "UID", ",", "msgs", "[", "]", "chat1", ".", "MessageUnboxed", ")", "(", "uiMsgs", "[", "]", "chat1", ".", "UIMessage", ")", "{", "for", "i", ":=", "len", "(", "msgs", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "msg", ":=", "msgs", "[", "i", "]", "\n", "uiMsg", ":=", "utils", ".", "PresentMessageUnboxed", "(", "ctx", ",", "g", ",", "msg", ",", "uid", ",", "convID", ")", "\n", "uiMsgs", "=", "append", "(", "uiMsgs", ",", "uiMsg", ")", "\n", "}", "\n", "return", "uiMsgs", "\n", "}" ]

[ "Order", "messages", "ascending", "by", "ID", "for", "presentation" ]

[ "func", "HumanizeGitErrors", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "err", "error", ")", "error", "{", "switch", "e", ":=", "err", ".", "(", "type", ")", "{", "case", "libkb", ".", "RepoAlreadyExistsError", ":", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "ExistingName", ")", "\n", "case", "libkb", ".", "InvalidRepoNameError", ":", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "Name", ")", "\n", "default", ":", "return", "err", "\n", "}", "\n", "}" ]

[ "For", "errors", "that", "expect", "replace", "them", "with", "nice", "strings", "for", "the", "user", ".", "The", "GUI", "will", "show", "these", "directly", "." ]

[ "func", "(", "ps", "*", "PassphraseStream", ")", "Clone", "(", ")", "*", "PassphraseStream", "{", "if", "ps", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "arr", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "ps", ".", "stream", ")", ")", "\n", "copy", "(", "arr", ",", "ps", ".", "stream", ")", "\n", "return", "&", "PassphraseStream", "{", "stream", ":", "arr", ",", "gen", ":", "ps", ".", "gen", ",", "}", "\n", "}" ]

[ "Clone", "a", "passphrase", "stream", "and", "return", "a", "copy", "." ]

[ "func", "NewEphemeralStorageAndInstall", "(", "mctx", "libkb", ".", "MetaContext", ")", "{", "mctx", ".", "G", "(", ")", ".", "SetDeviceEKStorage", "(", "NewDeviceEKStorage", "(", "mctx", ")", ")", "\n", "mctx", ".", "G", "(", ")", ".", "SetUserEKBoxStorage", "(", "NewUserEKBoxStorage", "(", ")", ")", "\n", "mctx", ".", "G", "(", ")", ".", "SetTeamEKBoxStorage", "(", "NewTeamEKBoxStorage", "(", ")", ")", "\n", "ekLib", ":=", "NewEKLib", "(", "mctx", ")", "\n", "mctx", ".", "G", "(", ")", ".", "SetEKLib", "(", "ekLib", ")", "\n", "mctx", ".", "G", "(", ")", ".", "AddLoginHook", "(", "ekLib", ")", "\n", "mctx", ".", "G", "(", ")", ".", "AddLogoutHook", "(", "ekLib", ",", "\"", "\"", ")", "\n", "mctx", ".", "G", "(", ")", ".", "AddDbNukeHook", "(", "ekLib", ",", "\"", "\"", ")", "\n", "mctx", ".", "G", "(", ")", ".", "PushShutdownHook", "(", "func", "(", ")", "error", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "ekLib", ".", "Shutdown", "(", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "Creates", "a", "ephemeral", "key", "storage", "and", "installs", "it", "into", "G", "." ]

[ "func", "(", "p", "BlockPointer", ")", "Ref", "(", ")", "BlockRef", "{", "return", "BlockRef", "{", "ID", ":", "p", ".", "ID", ",", "RefNonce", ":", "p", ".", "RefNonce", ",", "}", "\n", "}" ]

[ "Ref", "returns", "the", "BlockRef", "equivalent", "of", "this", "pointer", "." ]

[ "func", "EntryInfoFromFileInfo", "(", "fi", "os", ".", "FileInfo", ")", "EntryInfo", "{", "t", ":=", "File", "\n", "if", "fi", ".", "IsDir", "(", ")", "{", "t", "=", "Dir", "\n", "}", "else", "if", "fi", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "!=", "0", "{", "t", "=", "Sym", "\n", "}", "else", "if", "fi", ".", "Mode", "(", ")", "&", "0100", "!=", "0", "{", "t", "=", "Exec", "\n", "}", "\n", "mtime", ":=", "fi", ".", "ModTime", "(", ")", ".", "UnixNano", "(", ")", "\n", "return", "EntryInfo", "{", "Type", ":", "t", ",", "Size", ":", "uint64", "(", "fi", ".", "Size", "(", ")", ")", ",", "// TODO: deal with negatives?", "Mtime", ":", "mtime", ",", "Ctime", ":", "mtime", ",", "// Leave TeamWriter and PrevRevisions empty", "}", "\n", "}" ]

[ "EntryInfoFromFileInfo", "converts", "an", "os", ".", "FileInfo", "into", "an", "EntryInfo", "to", "the", "best", "of", "our", "ability", "to", "do", "so", ".", "The", "caller", "is", "responsible", "for", "filling", "in", "EntryInfo", ".", "SymPath", "if", "needed", "." ]

[ "func", "(", "ei", "EntryInfo", ")", "Eq", "(", "other", "EntryInfo", ")", "bool", "{", "eq", ":=", "ei", ".", "Type", "==", "other", ".", "Type", "&&", "ei", ".", "Size", "==", "other", ".", "Size", "&&", "ei", ".", "SymPath", "==", "other", ".", "SymPath", "&&", "ei", ".", "Mtime", "==", "other", ".", "Mtime", "&&", "ei", ".", "Ctime", "==", "other", ".", "Ctime", "&&", "ei", ".", "TeamWriter", "==", "other", ".", "TeamWriter", "&&", "len", "(", "ei", ".", "PrevRevisions", ")", "==", "len", "(", "other", ".", "PrevRevisions", ")", "\n", "if", "!", "eq", "{", "return", "false", "\n", "}", "\n", "for", "i", ",", "pr", ":=", "range", "ei", ".", "PrevRevisions", "{", "otherPR", ":=", "other", ".", "PrevRevisions", "[", "i", "]", "\n", "if", "pr", ".", "Revision", "!=", "otherPR", ".", "Revision", "||", "pr", ".", "Count", "!=", "otherPR", ".", "Count", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Eq", "returns", "true", "if", "other", "is", "equal", "to", "ei", "." ]

[ "func", "MakeRevBranchName", "(", "rev", "kbfsmd", ".", "Revision", ")", "BranchName", "{", "return", "BranchName", "(", "branchRevPrefix", "+", "strconv", ".", "FormatInt", "(", "int64", "(", "rev", ")", ",", "10", ")", ")", "\n", "}" ]

[ "MakeRevBranchName", "returns", "a", "branch", "name", "specifying", "an", "archive", "branch", "pinned", "to", "the", "given", "revision", "number", "." ]

[ "func", "(", "bn", "BranchName", ")", "RevisionIfSpecified", "(", ")", "(", "kbfsmd", ".", "Revision", ",", "bool", ")", "{", "if", "!", "bn", ".", "IsArchived", "(", ")", "{", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "false", "\n", "}", "\n\n", "i", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "string", "(", "bn", "[", "len", "(", "branchRevPrefix", ")", ":", "]", ")", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "false", "\n", "}", "\n\n", "return", "kbfsmd", ".", "Revision", "(", "i", ")", ",", "true", "\n", "}" ]

[ "RevisionIfSpecified", "returns", "a", "valid", "revision", "number", "and", "true", "if", "bn", "is", "a", "revision", "branch", "." ]

[ "func", "(", "k", "*", "KeyBundleCacheStandard", ")", "GetTLFReaderKeyBundle", "(", "bundleID", "TLFReaderKeyBundleID", ")", "(", "*", "TLFReaderKeyBundleV3", ",", "error", ")", "{", "if", "entry", ",", "ok", ":=", "k", ".", "cache", ".", "Get", "(", "bundleID", ")", ";", "ok", "{", "if", "rkb", ",", "ok", ":=", "entry", ".", "(", "TLFReaderKeyBundleV3", ")", ";", "ok", "{", "return", "&", "rkb", ",", "nil", "\n", "}", "\n", "// Shouldn't be possible.", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "GetTLFReaderKeyBundle", "implements", "the", "KeyBundleCache", "interface", "for", "KeyBundleCacheStandard", "." ]

[ "func", "(", "k", "*", "KeyBundleCacheStandard", ")", "GetTLFWriterKeyBundle", "(", "bundleID", "TLFWriterKeyBundleID", ")", "(", "*", "TLFWriterKeyBundleV3", ",", "error", ")", "{", "if", "entry", ",", "ok", ":=", "k", ".", "cache", ".", "Get", "(", "bundleID", ")", ";", "ok", "{", "if", "wkb", ",", "ok", ":=", "entry", ".", "(", "TLFWriterKeyBundleV3", ")", ";", "ok", "{", "return", "&", "wkb", ",", "nil", "\n", "}", "\n", "// Shouldn't be possible.", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "GetTLFWriterKeyBundle", "implements", "the", "KeyBundleCache", "interface", "for", "KeyBundleCacheStandard", "." ]

[ "func", "(", "k", "*", "KeyBundleCacheStandard", ")", "PutTLFReaderKeyBundle", "(", "bundleID", "TLFReaderKeyBundleID", ",", "rkb", "TLFReaderKeyBundleV3", ")", "{", "k", ".", "cache", ".", "Add", "(", "bundleID", ",", "rkb", ")", "\n", "}" ]

[ "PutTLFReaderKeyBundle", "implements", "the", "KeyBundleCache", "interface", "for", "KeyBundleCacheStandard", "." ]

[ "func", "(", "k", "*", "KeyBundleCacheStandard", ")", "PutTLFWriterKeyBundle", "(", "bundleID", "TLFWriterKeyBundleID", ",", "wkb", "TLFWriterKeyBundleV3", ")", "{", "k", ".", "cache", ".", "Add", "(", "bundleID", ",", "wkb", ")", "\n", "}" ]

[ "PutTLFWriterKeyBundle", "implements", "the", "KeyBundleCache", "interface", "for", "KeyBundleCacheStandard", "." ]

[ "func", "Update", "(", "c", "Codec", ",", "dstPtr", "interface", "{", "}", ",", "src", "interface", "{", "}", ")", "error", "{", "buf", ",", "err", ":=", "c", ".", "Encode", "(", "src", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "c", ".", "Decode", "(", "buf", ",", "dstPtr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Update", "encodes", "src", "into", "a", "byte", "string", "and", "then", "decode", "it", "into", "the", "object", "pointed", "to", "by", "dstPtr", "." ]

[ "func", "SerializeToFile", "(", "c", "Codec", ",", "obj", "interface", "{", "}", ",", "path", "string", ")", "error", "{", "err", ":=", "ioutil", ".", "MkdirAll", "(", "filepath", ".", "Dir", "(", "path", ")", ",", "0700", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "buf", ",", "err", ":=", "c", ".", "Encode", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "ioutil", ".", "WriteSerializedFile", "(", "path", ",", "buf", ",", "0600", ")", "\n", "}" ]

[ "SerializeToFile", "serializes", "the", "given", "object", "and", "writes", "it", "to", "the", "given", "file", "making", "its", "parent", "directory", "first", "if", "necessary", "." ]

[ "func", "SerializeToFileIfNotExist", "(", "c", "Codec", ",", "obj", "interface", "{", "}", ",", "path", "string", ")", "error", "{", "_", ",", "err", ":=", "ioutil", ".", "Stat", "(", "path", ")", "\n", "if", "ioutil", ".", "IsExist", "(", "err", ")", "{", "return", "nil", "\n", "}", "else", "if", "ioutil", ".", "IsNotExist", "(", "err", ")", "{", "// Continue.", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "SerializeToFile", "(", "c", ",", "obj", ",", "path", ")", "\n", "}" ]

[ "SerializeToFileIfNotExist", "is", "like", "SerializeToFile", "but", "does", "nothing", "if", "the", "file", "already", "exists", "." ]

[ "func", "(", "m", "*", "FlipManager", ")", "LoadFlip", "(", "ctx", "context", ".", "Context", ",", "uid", "gregor1", ".", "UID", ",", "hostConvID", "chat1", ".", "ConversationID", ",", "hostMsgID", "chat1", ".", "MessageID", ",", "flipConvID", "chat1", ".", "ConversationID", ",", "gameID", "chat1", ".", "FlipGameID", ")", "{", "defer", "m", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ",", "\"", "\"", ")", "(", ")", "\n", "stored", ",", "ok", ":=", "m", ".", "games", ".", "Get", "(", "gameID", ".", "String", "(", ")", ")", "\n", "if", "ok", "{", "switch", "stored", ".", "(", "chat1", ".", "UICoinFlipStatus", ")", ".", "Phase", "{", "case", "chat1", ".", "UICoinFlipPhase_ERROR", ":", "// do nothing here, just replay if we are storing an error", "default", ":", "m", ".", "queueDirtyGameID", "(", "ctx", ",", "gameID", ",", "true", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "// If we miss the in-memory game storage, attempt to replay the game", "job", ":=", "loadGameJob", "{", "uid", ":", "uid", ",", "hostConvID", ":", "hostConvID", ",", "hostMsgID", ":", "hostMsgID", ",", "flipConvID", ":", "flipConvID", ",", "gameID", ":", "gameID", ",", "}", "\n", "select", "{", "case", "m", ".", "loadGameCh", "<-", "job", ":", "default", ":", "m", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "gameID", ",", "hostConvID", ",", "flipConvID", ")", "\n", "}", "\n", "}" ]

[ "LoadFlip", "implements", "the", "types", ".", "CoinFlipManager", "interface" ]

[ "func", "(", "m", "*", "FlipManager", ")", "CLogf", "(", "ctx", "context", ".", "Context", ",", "fmt", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "m", ".", "Debug", "(", "ctx", ",", "fmt", ",", "args", "...", ")", "\n", "}" ]

[ "CLogf", "implements", "the", "flip", ".", "DealersHelper", "interface" ]

[ "func", "(", "m", "*", "FlipManager", ")", "ServerTime", "(", "ctx", "context", ".", "Context", ")", "(", "res", "time", ".", "Time", ",", "err", "error", ")", "{", "ctx", "=", "globals", ".", "ChatCtx", "(", "ctx", ",", "m", ".", "G", "(", ")", ",", "keybase1", ".", "TLFIdentifyBehavior_CHAT_SKIP", ",", "nil", ",", "nil", ")", "\n", "defer", "m", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "if", "m", ".", "testingServerClock", "!=", "nil", "{", "return", "m", ".", "testingServerClock", ".", "Now", "(", ")", ",", "nil", "\n", "}", "\n", "sres", ",", "err", ":=", "m", ".", "ri", "(", ")", ".", "ServerNow", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "return", "sres", ".", "Now", ".", "Time", "(", ")", ",", "nil", "\n", "}" ]

[ "ServerTime", "implements", "the", "flip", ".", "DealersHelper", "interface" ]

[ "func", "(", "m", "*", "FlipManager", ")", "SendChat", "(", "ctx", "context", ".", "Context", ",", "convID", "chat1", ".", "ConversationID", ",", "gameID", "chat1", ".", "FlipGameID", ",", "msg", "flip", ".", "GameMessageEncoded", ")", "(", "err", "error", ")", "{", "ctx", "=", "globals", ".", "ChatCtx", "(", "ctx", ",", "m", ".", "G", "(", ")", ",", "keybase1", ".", "TLFIdentifyBehavior_CHAT_SKIP", ",", "nil", ",", "nil", ")", "\n", "defer", "m", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ",", "convID", ")", "(", ")", "\n", "uid", ",", "err", ":=", "utils", ".", "AssertLoggedInUID", "(", "ctx", ",", "m", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "conv", ",", "err", ":=", "utils", ".", "GetVerifiedConv", "(", "ctx", ",", "m", ".", "G", "(", ")", ",", "uid", ",", "convID", ",", "types", ".", "InboxSourceDataSourceAll", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "outboxID", ",", "err", ":=", "storage", ".", "NewOutboxID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "m", ".", "registerSentOutboxID", "(", "ctx", ",", "gameID", ",", "outboxID", ")", "\n", "return", "m", ".", "sendNonblock", "(", "ctx", ",", "convID", ",", "msg", ".", "String", "(", ")", ",", "conv", ".", "Info", ".", "TlfName", ",", "outboxID", ",", "gameID", ",", "chat1", ".", "TopicType_DEV", ")", "\n", "}" ]

[ "SendChat", "implements", "the", "flip", ".", "DealersHelper", "interface" ]

[ "func", "(", "m", "*", "FlipManager", ")", "Me", "(", ")", "flip", ".", "UserDevice", "{", "ad", ":=", "m", ".", "G", "(", ")", ".", "ActiveDevice", "\n", "did", ":=", "ad", ".", "DeviceID", "(", ")", "\n", "hdid", ":=", "make", "(", "[", "]", "byte", ",", "libkb", ".", "DeviceIDLen", ")", "\n", "if", "err", ":=", "did", ".", "ToBytes", "(", "hdid", ")", ";", "err", "!=", "nil", "{", "return", "flip", ".", "UserDevice", "{", "}", "\n", "}", "\n", "return", "flip", ".", "UserDevice", "{", "U", ":", "gregor1", ".", "UID", "(", "ad", ".", "UID", "(", ")", ".", "ToBytes", "(", ")", ")", ",", "D", ":", "gregor1", ".", "DeviceID", "(", "hdid", ")", ",", "}", "\n", "}" ]

[ "Me", "implements", "the", "flip", ".", "DealersHelper", "interface" ]

[ "func", "KeybaseFuseStatus", "(", "bundleVersion", "string", ",", "log", "Log", ")", "keybase1", ".", "FuseStatus", "{", "st", ":=", "keybase1", ".", "FuseStatus", "{", "BundleVersion", ":", "bundleVersion", ",", "InstallStatus", ":", "keybase1", ".", "InstallStatus_UNKNOWN", ",", "InstallAction", ":", "keybase1", ".", "InstallAction_UNKNOWN", ",", "}", "\n\n", "var", "kextInfo", "*", "kext", ".", "Info", "\n\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "installPath", ")", ";", "err", "==", "nil", "{", "st", ".", "Path", "=", "installPath", "\n", "kextID", ":=", "\"", "\"", "\n", "var", "loadErr", "error", "\n", "kextInfo", ",", "loadErr", "=", "kext", ".", "LoadInfo", "(", "kextID", ")", "\n", "if", "loadErr", "!=", "nil", "{", "st", ".", "InstallStatus", "=", "keybase1", ".", "InstallStatus_ERROR", "\n", "st", ".", "InstallAction", "=", "keybase1", ".", "InstallAction_REINSTALL", "\n", "st", ".", "Status", "=", "keybase1", ".", "Status", "{", "Code", ":", "libkb", ".", "SCGeneric", ",", "Name", ":", "\"", "\"", ",", "Desc", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "loadErr", ")", "}", "\n", "return", "st", "\n", "}", "\n", "if", "kextInfo", "==", "nil", "{", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "// This means the kext isn't loaded, which is ok, kbfs will call", "// load_kbfuse when it starts up.", "// We have to get the version from the installed plist.", "installedVersion", ",", "fivErr", ":=", "fuseInstallVersion", "(", "log", ")", "\n", "if", "fivErr", "!=", "nil", "{", "st", ".", "InstallStatus", "=", "keybase1", ".", "InstallStatus_ERROR", "\n", "st", ".", "InstallAction", "=", "keybase1", ".", "InstallAction_REINSTALL", "\n", "st", ".", "Status", "=", "keybase1", ".", "Status", "{", "Code", ":", "libkb", ".", "SCGeneric", ",", "Name", ":", "\"", "\"", ",", "Desc", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fivErr", ")", "}", "\n", "return", "st", "\n", "}", "\n", "if", "installedVersion", "!=", "\"", "\"", "{", "kextInfo", "=", "&", "kext", ".", "Info", "{", "Version", ":", "installedVersion", ",", "Started", ":", "false", ",", "}", "\n", "}", "\n", "}", "\n\n", "// Installed", "st", ".", "KextID", "=", "kextID", "\n", "}", "\n\n", "// If neither is found, we have no install", "if", "st", ".", "KextID", "==", "\"", "\"", "||", "kextInfo", "==", "nil", "{", "st", ".", "InstallStatus", "=", "keybase1", ".", "InstallStatus_NOT_INSTALLED", "\n", "st", ".", "InstallAction", "=", "keybase1", ".", "InstallAction_INSTALL", "\n", "return", "st", "\n", "}", "\n\n", "// Try to get mount info, it's non-critical if we fail though.", "mountInfos", ",", "err", ":=", "mountInfo", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "st", ".", "MountInfos", "=", "mountInfos", "\n\n", "st", ".", "Version", "=", "kextInfo", ".", "Version", "\n", "st", ".", "KextStarted", "=", "kextInfo", ".", "Started", "\n\n", "installStatus", ",", "installAction", ",", "status", ":=", "ResolveInstallStatus", "(", "st", ".", "Version", ",", "st", ".", "BundleVersion", ",", "\"", "\"", ",", "log", ")", "\n", "st", ".", "InstallStatus", "=", "installStatus", "\n", "st", ".", "InstallAction", "=", "installAction", "\n", "st", ".", "Status", "=", "status", "\n\n", "return", "st", "\n", "}" ]

[ "KeybaseFuseStatus", "returns", "Fuse", "status" ]

[ "func", "(", "fi", "*", "FileInfo", ")", "Mode", "(", ")", "os", ".", "FileMode", "{", "mode", ",", "err", ":=", "WritePermMode", "(", "fi", ".", "fs", ".", "ctx", ",", "fi", ".", "node", ",", "os", ".", "FileMode", "(", "0", ")", ",", "fi", ".", "fs", ".", "config", ".", "KBPKI", "(", ")", ",", "fi", ".", "fs", ".", "config", ",", "fi", ".", "fs", ".", "h", ")", "\n", "if", "err", "!=", "nil", "{", "fi", ".", "fs", ".", "log", ".", "CWarningf", "(", "fi", ".", "fs", ".", "ctx", ",", "\"", "\"", ",", "fi", ".", "Name", "(", ")", ",", "err", ")", "\n", "mode", "=", "os", ".", "FileMode", "(", "0", ")", "\n", "}", "\n\n", "mode", "|=", "0400", "\n", "switch", "fi", ".", "ei", ".", "Type", "{", "case", "data", ".", "Dir", ":", "mode", "|=", "os", ".", "ModeDir", "|", "0100", "\n", "case", "data", ".", "Sym", ":", "mode", "|=", "os", ".", "ModeSymlink", "\n", "case", "data", ".", "Exec", ":", "mode", "|=", "0100", "\n", "}", "\n", "return", "mode", "\n", "}" ]

[ "Mode", "implements", "the", "os", ".", "FileInfo", "interface", "for", "FileInfo", "." ]

[ "func", "(", "fi", "*", "FileInfo", ")", "ModTime", "(", ")", "time", ".", "Time", "{", "return", "time", ".", "Unix", "(", "0", ",", "fi", ".", "ei", ".", "Mtime", ")", "\n", "}" ]

[ "ModTime", "implements", "the", "os", ".", "FileInfo", "interface", "for", "FileInfo", "." ]

[ "func", "(", "fif", "*", "FileInfoFast", ")", "Mode", "(", ")", "os", ".", "FileMode", "{", "mode", ":=", "os", ".", "FileMode", "(", "0400", ")", "\n", "switch", "fif", ".", "ei", ".", "Type", "{", "case", "data", ".", "Dir", ":", "mode", "|=", "os", ".", "ModeDir", "|", "0100", "\n", "case", "data", ".", "Sym", ":", "mode", "|=", "os", ".", "ModeSymlink", "\n", "case", "data", ".", "Exec", ":", "mode", "|=", "0100", "\n", "}", "\n", "return", "mode", "\n", "}" ]

[ "Mode", "implements", "the", "os", ".", "FileInfo", "interface", "." ]

[ "func", "(", "fif", "*", "FileInfoFast", ")", "ModTime", "(", ")", "time", ".", "Time", "{", "return", "time", ".", "Unix", "(", "0", ",", "fif", ".", "ei", ".", "Mtime", ")", "\n", "}" ]

[ "ModTime", "implements", "the", "os", ".", "FileInfo", "interface", "." ]

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

[ "EnableFastMode", "returns", "a", "context", ".", "Context", "based", "on", "ctx", "that", "will", "test", "to", "true", "with", "IsFastModeEnabled", "." ]

[ "func", "(", "r", "*", "runner", ")", "getElapsedStr", "(", "ctx", "context", ".", "Context", ",", "startTime", "time", ".", "Time", ",", "profName", "string", ",", "cpuProfFullPath", "string", ")", "string", "{", "if", "r", ".", "verbosity", "<", "2", "{", "return", "\"", "\"", "\n", "}", "\n", "elapsed", ":=", "r", ".", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "Sub", "(", "startTime", ")", "\n", "elapsedStr", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "elapsed", ")", "\n\n", "if", "r", ".", "verbosity", ">=", "3", "{", "profName", "=", "filepath", ".", "Join", "(", "os", ".", "TempDir", "(", ")", ",", "profName", ")", "\n", "f", ",", "err", ":=", "os", ".", "Create", "(", "profName", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "else", "{", "runtime", ".", "GC", "(", ")", "\n", "pprof", ".", "WriteHeapProfile", "(", "f", ")", "\n", "f", ".", "Close", "(", ")", "\n", "}", "\n", "elapsedStr", "+=", "\"", "\"", "+", "profName", "+", "\"", "\"", "\n", "}", "\n\n", "if", "cpuProfFullPath", "!=", "\"", "\"", "{", "pprof", ".", "StopCPUProfile", "(", ")", "\n", "elapsedStr", "+=", "\"", "\"", "+", "cpuProfFullPath", "+", "\"", "\"", "\n", "}", "\n\n", "return", "elapsedStr", "\n", "}" ]

[ "getElapsedStr", "gets", "an", "additional", "string", "to", "append", "to", "the", "errput", "message", "at", "the", "end", "of", "a", "phase", ".", "It", "includes", "the", "measured", "time", "of", "the", "phase", "and", "if", "verbosity", "is", "high", "enough", "it", "includes", "the", "location", "of", "a", "memory", "profile", "taken", "at", "the", "end", "of", "the", "phase", "." ]

[ "func", "(", "r", "*", "runner", ")", "printStageEndIfNeeded", "(", "ctx", "context", ".", "Context", ")", "{", "r", ".", "printStageLock", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "printStageLock", ".", "Unlock", "(", ")", "\n", "// go-git grabs the lock right after plumbing.StatusIndexOffset, but before", "// sending the Done status update. As a result, it would look like we are", "// flushing the journal before plumbing.StatusIndexOffset is done. So", "// instead, print \"done.\" only if it's not printed yet.", "if", "r", ".", "needPrintDone", "{", "elapsedStr", ":=", "r", ".", "getElapsedStr", "(", "ctx", ",", "r", ".", "stageStartTime", ",", "r", ".", "stageMemProfName", ",", "r", ".", "stageCPUProfPath", ")", "\n", "r", ".", "errput", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", "+", "elapsedStr", "+", "\"", "\\n", "\"", ")", ")", "\n", "r", ".", "needPrintDone", "=", "false", "\n", "}", "\n", "}" ]

[ "printStageEndIfNeeded", "should", "only", "be", "used", "to", "end", "stages", "started", "with", "printStageStart", "." ]

[ "func", "(", "r", "*", "runner", ")", "printJournalStatus", "(", "ctx", "context", ".", "Context", ",", "jManager", "*", "libkbfs", ".", "JournalManager", ",", "tlfID", "tlf", ".", "ID", ",", "doneCh", "<-", "chan", "struct", "{", "}", ")", "{", "r", ".", "printStageEndIfNeeded", "(", "ctx", ")", "\n", "// Note: the \"first\" status here gets us the number of unflushed", "// bytes left at the time we started printing. However, we don't", "// have the total number of bytes being flushed to the server", "// throughout the whole operation, which would be more", "// informative. It would be better to have that as the", "// denominator, but there's no easy way to get it right now.", "firstStatus", ",", "err", ":=", "jManager", ".", "JournalStatus", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "firstStatus", ".", "UnflushedBytes", "==", "0", "{", "return", "\n", "}", "\n", "adj", ":=", "\"", "\"", "\n", "if", "r", ".", "h", ".", "Type", "(", ")", "==", "tlf", ".", "Public", "{", "adj", "=", "\"", "\"", "\n", "}", "\n", "if", "r", ".", "verbosity", ">=", "1", "{", "r", ".", "printStageStart", "(", "ctx", ",", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "adj", ")", ")", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "firstStatus", ".", "UnflushedBytes", ")", "\n\n", "bytesFmt", ":=", "\"", "\"", "\n", "str", ":=", "fmt", ".", "Sprintf", "(", "bytesFmt", ",", "float64", "(", "0", ")", ",", "humanizeBytes", "(", "0", ",", "firstStatus", ".", "UnflushedBytes", ")", ")", "\n", "lastByteCount", ":=", "len", "(", "str", ")", "\n", "if", "r", ".", "progress", "{", "r", ".", "errput", ".", "Write", "(", "[", "]", "byte", "(", "str", ")", ")", "\n", "}", "\n\n", "ticker", ":=", "time", ".", "NewTicker", "(", "1", "*", "time", ".", "Second", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "ticker", ".", "C", ":", "status", ",", "err", ":=", "jManager", ".", "JournalStatus", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "if", "r", ".", "verbosity", ">=", "1", "&&", "r", ".", "progress", "{", "eraseStr", ":=", "strings", ".", "Repeat", "(", "\"", "\\b", "\"", ",", "lastByteCount", ")", "\n", "flushed", ":=", "firstStatus", ".", "UnflushedBytes", "-", "status", ".", "UnflushedBytes", "\n", "str", ":=", "fmt", ".", "Sprintf", "(", "bytesFmt", ",", "percent", "(", "flushed", ",", "firstStatus", ".", "UnflushedBytes", ")", ",", "humanizeBytes", "(", "flushed", ",", "firstStatus", ".", "UnflushedBytes", ")", ")", "\n", "lastByteCount", "=", "len", "(", "str", ")", "\n", "r", ".", "errput", ".", "Write", "(", "[", "]", "byte", "(", "eraseStr", "+", "str", ")", ")", "\n", "}", "\n", "case", "<-", "doneCh", ":", "if", "r", ".", "verbosity", ">=", "1", "&&", "r", ".", "progress", "{", "eraseStr", ":=", "strings", ".", "Repeat", "(", "\"", "\\b", "\"", ",", "lastByteCount", ")", "\n", "// doneCh is closed. So assume journal flushing is done and", "// take the shortcut.", "flushed", ":=", "firstStatus", ".", "UnflushedBytes", "\n", "str", ":=", "fmt", ".", "Sprintf", "(", "bytesFmt", ",", "percent", "(", "flushed", ",", "firstStatus", ".", "UnflushedBytes", ")", ",", "humanizeBytes", "(", "flushed", ",", "firstStatus", ".", "UnflushedBytes", ")", ")", "\n", "lastByteCount", "=", "len", "(", "str", ")", "\n", "r", ".", "errput", ".", "Write", "(", "[", "]", "byte", "(", "eraseStr", "+", "str", ")", ")", "\n", "}", "\n\n", "if", "r", ".", "verbosity", ">=", "1", "{", "r", ".", "printStageEndIfNeeded", "(", "ctx", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "caller", "should", "make", "sure", "doneCh", "is", "closed", "when", "journal", "is", "all", "flushed", "." ]

[ "func", "(", "r", "*", "runner", ")", "recursiveByteCount", "(", "ctx", "context", ".", "Context", ",", "fs", "billy", ".", "Filesystem", ",", "totalSoFar", "int64", ",", "toErase", "int", ")", "(", "bytes", "int64", ",", "toEraseRet", "int", ",", "err", "error", ")", "{", "fileInfos", ",", "err", ":=", "fs", ".", "ReadDir", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "fi", ":=", "range", "fileInfos", "{", "if", "fi", ".", "IsDir", "(", ")", "{", "if", "fi", ".", "Name", "(", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "chrootFS", ",", "err", ":=", "fs", ".", "Chroot", "(", "fi", ".", "Name", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n", "var", "chrootBytes", "int64", "\n", "chrootBytes", ",", "toErase", ",", "err", "=", "r", ".", "recursiveByteCount", "(", "ctx", ",", "chrootFS", ",", "totalSoFar", "+", "bytes", ",", "toErase", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n", "bytes", "+=", "chrootBytes", "\n", "}", "else", "{", "bytes", "+=", "fi", ".", "Size", "(", ")", "\n", "if", "r", ".", "progress", "{", "// This function only runs if r.verbosity >= 1.", "eraseStr", ":=", "strings", ".", "Repeat", "(", "\"", "\\b", "\"", ",", "toErase", ")", "\n", "newStr", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "humanizeBytes", "(", "totalSoFar", "+", "bytes", ",", "1", ")", ")", "\n", "toErase", "=", "len", "(", "newStr", ")", "\n", "r", ".", "errput", ".", "Write", "(", "[", "]", "byte", "(", "eraseStr", "+", "newStr", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "bytes", ",", "toErase", ",", "nil", "\n", "}" ]

[ "recursiveByteCount", "returns", "a", "sum", "of", "the", "size", "of", "all", "files", "under", "the", "directory", "represented", "by", "fs", ".", "It", "also", "returns", "the", "length", "of", "the", "last", "string", "it", "printed", "to", "r", ".", "errput", "as", "toErase", "to", "aid", "in", "overwriting", "the", "text", "on", "the", "next", "update", "." ]

[ "func", "(", "r", "*", "runner", ")", "recursiveCopy", "(", "ctx", "context", ".", "Context", ",", "from", "billy", ".", "Filesystem", ",", "to", "billy", ".", "Filesystem", ",", "sw", "*", "statusWriter", ")", "(", "err", "error", ")", "{", "fileInfos", ",", "err", ":=", "from", ".", "ReadDir", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "fi", ":=", "range", "fileInfos", "{", "if", "fi", ".", "IsDir", "(", ")", "{", "if", "fi", ".", "Name", "(", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "err", ":=", "to", ".", "MkdirAll", "(", "fi", ".", "Name", "(", ")", ",", "0775", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "chrootFrom", ",", "err", ":=", "from", ".", "Chroot", "(", "fi", ".", "Name", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "chrootTo", ",", "err", ":=", "to", ".", "Chroot", "(", "fi", ".", "Name", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "r", ".", "recursiveCopy", "(", "ctx", ",", "chrootFrom", ",", "chrootTo", ",", "sw", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "err", ":=", "r", ".", "copyFile", "(", "ctx", ",", "from", ",", "to", ",", "fi", ".", "Name", "(", ")", ",", "sw", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "recursiveCopy", "copies", "the", "entire", "subdirectory", "rooted", "at", "fs", "to", "localFS", "." ]

[ "func", "(", "r", "*", "runner", ")", "parentCommitsForRef", "(", "ctx", "context", ".", "Context", ",", "localStorer", "gogitstor", ".", "Storer", ",", "remoteStorer", "gogitstor", ".", "Storer", ",", "refs", "map", "[", "gogitcfg", ".", "RefSpec", "]", "bool", ")", "(", "libgit", ".", "RefDataByName", ",", "error", ")", "{", "commitsByRef", ":=", "make", "(", "libgit", ".", "RefDataByName", ",", "len", "(", "refs", ")", ")", "\n", "haves", ":=", "make", "(", "map", "[", "plumbing", ".", "Hash", "]", "bool", ")", "\n\n", "for", "refspec", ":=", "range", "refs", "{", "if", "refspec", ".", "IsDelete", "(", ")", "{", "commitsByRef", "[", "refspec", ".", "Dst", "(", "\"", "\"", ")", "]", "=", "&", "libgit", ".", "RefData", "{", "IsDelete", ":", "true", ",", "}", "\n", "continue", "\n", "}", "\n", "refName", ":=", "plumbing", ".", "ReferenceName", "(", "refspec", ".", "Src", "(", ")", ")", "\n", "resolved", ",", "err", ":=", "gogitstor", ".", "ResolveReference", "(", "localStorer", ",", "refName", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "refName", ")", "\n", "}", "\n", "if", "resolved", "!=", "nil", "{", "refName", "=", "resolved", ".", "Name", "(", ")", "\n", "}", "\n\n", "ref", ",", "err", ":=", "localStorer", ".", "Reference", "(", "refName", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "refName", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "hash", ":=", "ref", ".", "Hash", "(", ")", "\n\n", "// Get the HEAD commit for the ref from the local repository.", "commit", ",", "err", ":=", "gogitobj", ".", "GetCommit", "(", "localStorer", ",", "hash", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "string", "(", "hash", "[", ":", "]", ")", ",", "refName", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "// Iterate through the commits backward, until we experience any of the", "// following:", "// 1. Find a commit that the remote knows about,", "// 2. Reach our maximum number of commits to check,", "// 3. Run out of commits.", "walker", ":=", "gogitobj", ".", "NewCommitPreorderIter", "(", "commit", ",", "haves", ",", "nil", ")", "\n", "toVisit", ":=", "maxCommitsToVisitPerRef", "\n", "dstRefName", ":=", "refspec", ".", "Dst", "(", "\"", "\"", ")", "\n", "commitsByRef", "[", "dstRefName", "]", "=", "&", "libgit", ".", "RefData", "{", "IsDelete", ":", "refspec", ".", "IsDelete", "(", ")", ",", "Commits", ":", "make", "(", "[", "]", "*", "gogitobj", ".", "Commit", ",", "0", ",", "maxCommitsToVisitPerRef", ")", ",", "}", "\n", "err", "=", "walker", ".", "ForEach", "(", "func", "(", "c", "*", "gogitobj", ".", "Commit", ")", "error", "{", "haves", "[", "c", ".", "Hash", "]", "=", "true", "\n", "toVisit", "--", "\n", "// If toVisit starts out at 0 (indicating there is no", "// max), then it will be negative here and we won't stop", "// early.", "if", "toVisit", "==", "0", "{", "// Append a sentinel value to communicate that there would be", "// more commits.", "commitsByRef", "[", "dstRefName", "]", ".", "Commits", "=", "append", "(", "commitsByRef", "[", "dstRefName", "]", ".", "Commits", ",", "libgit", ".", "CommitSentinelValue", ")", "\n", "return", "gogitstor", ".", "ErrStop", "\n", "}", "\n", "hasEncodedObjectErr", ":=", "remoteStorer", ".", "HasEncodedObject", "(", "c", ".", "Hash", ")", "\n", "if", "hasEncodedObjectErr", "==", "nil", "{", "return", "gogitstor", ".", "ErrStop", "\n", "}", "\n", "commitsByRef", "[", "dstRefName", "]", ".", "Commits", "=", "append", "(", "commitsByRef", "[", "dstRefName", "]", ".", "Commits", ",", "c", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "commitsByRef", ",", "nil", "\n", "}" ]

[ "parentCommitsForRef", "returns", "a", "map", "of", "refs", "with", "a", "list", "of", "commits", "for", "each", "ref", "newest", "first", ".", "It", "only", "includes", "commits", "that", "exist", "in", "localStorer", "but", "not", "in", "remoteStorer", "." ]

[ "func", "(", "e", "*", "Env", ")", "GetNegBool", "(", "def", "bool", ",", "flist", "[", "]", "NegBoolFunc", ")", "bool", "{", "for", "_", ",", "f", ":=", "range", "flist", "{", "if", "val", ",", "isSet", ":=", "f", ".", "f", "(", ")", ";", "isSet", "{", "return", "(", "val", "!=", "f", ".", "neg", ")", "\n", "}", "\n", "}", "\n", "return", "def", "\n", "}" ]

[ "GetNegBool", "gets", "a", "negatable", "bool", ".", "You", "can", "give", "it", "a", "list", "of", "functions", "and", "also", "possible", "negations", "for", "those", "functions", "." ]

[ "func", "(", "e", "*", "Env", ")", "GetChatMemberType", "(", ")", "string", "{", "return", "e", ".", "GetString", "(", "func", "(", ")", "string", "{", "return", "os", ".", "Getenv", "(", "\"", "\"", ")", "}", ",", "func", "(", ")", "string", "{", "return", "\"", "\"", "}", ",", ")", "\n", "}" ]

[ "GetChatMemberType", "returns", "the", "default", "member", "type", "for", "new", "conversations", "." ]

[ "func", "Encode58", "(", "inp", "[", "]", "byte", ")", "string", "{", "num", ":=", "new", "(", "big", ".", "Int", ")", ".", "SetBytes", "(", "inp", ")", "\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "len", "(", "inp", ")", ")", "\n", "base", ":=", "big", ".", "NewInt", "(", "int64", "(", "58", ")", ")", "\n", "rem", ":=", "new", "(", "big", ".", "Int", ")", "\n", "quo", ":=", "new", "(", "big", ".", "Int", ")", "\n\n", "for", "num", ".", "Sign", "(", ")", "!=", "0", "{", "num", ",", "rem", "=", "quo", ".", "QuoRem", "(", "num", ",", "base", ",", "rem", ")", "\n", "c", ":=", "alphabet", "[", "rem", ".", "Uint64", "(", ")", "]", "\n", "buf", "=", "append", "(", "buf", ",", "c", ")", "\n", "}", "\n\n", "// Pad leading zeros...", "for", "_", ",", "c", ":=", "range", "inp", "{", "if", "c", "==", "0x0", "{", "buf", "=", "append", "(", "buf", ",", "alphabet", "[", "0", "]", ")", "\n", "}", "else", "{", "// Stop adding padding after the first nonzero byte.", "break", "\n", "}", "\n", "}", "\n", "reverseBuf", "(", "buf", ")", "\n\n", "return", "string", "(", "buf", ")", "\n", "}" ]

[ "Encode58", "base58", "encodes", "the", "input", "." ]

[ "func", "Decode58", "(", "inp", "string", ")", "(", "outp", "[", "]", "byte", ",", "err", "error", ")", "{", "place", ":=", "big", ".", "NewInt", "(", "1", ")", "\n", "base", ":=", "big", ".", "NewInt", "(", "58", ")", "\n", "buf", ":=", "[", "]", "byte", "(", "inp", ")", "\n", "padlen", ":=", "0", "\n\n", "// Advance to first non-pad byte", "for", ";", "padlen", "<", "len", "(", "buf", ")", ";", "padlen", "++", "{", "if", "buf", "[", "padlen", "]", "!=", "alphabet", "[", "0", "]", "{", "break", "\n", "}", "\n", "}", "\n", "buf", "=", "buf", "[", "padlen", ":", "]", "\n", "reverseBuf", "(", "buf", ")", "\n\n", "tmp", ":=", "new", "(", "big", ".", "Int", ")", "\n", "res", ":=", "big", ".", "NewInt", "(", "0", ")", "\n\n", "for", "i", ",", "c", ":=", "range", "buf", "{", "charIndex", ":=", "alphabetMap", "[", "c", "]", "\n", "if", "charIndex", "==", "base58InvalidIndex", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ",", "i", ")", "\n", "return", "\n", "}", "\n\n", "tmp", ".", "Mul", "(", "place", ",", "big", ".", "NewInt", "(", "int64", "(", "charIndex", ")", ")", ")", "\n", "res", ".", "Add", "(", "res", ",", "tmp", ")", "\n\n", "if", "i", "!=", "len", "(", "buf", ")", "-", "1", "{", "place", ".", "Mul", "(", "place", ",", "base", ")", "\n", "}", "\n", "}", "\n", "buf", "=", "res", ".", "Bytes", "(", ")", "\n", "pad", ":=", "bytes", ".", "Repeat", "(", "[", "]", "byte", "{", "0", "}", ",", "padlen", ")", "\n", "outp", "=", "append", "(", "pad", ",", "buf", "...", ")", "\n\n", "return", "\n", "}" ]

[ "Decode58", "base58", "decodes", "the", "input", "or", "returns", "an", "error", "." ]

[ "func", "NewSaltpackEncrypt", "(", "arg", "*", "SaltpackEncryptArg", ",", "newKeyfinderHook", "func", "(", "arg", "libkb", ".", "SaltpackRecipientKeyfinderArg", ")", "libkb", ".", "SaltpackRecipientKeyfinderEngineInterface", ")", "*", "SaltpackEncrypt", "{", "return", "&", "SaltpackEncrypt", "{", "arg", ":", "arg", ",", "newKeyfinderHook", ":", "newKeyfinderHook", ",", "}", "\n", "}" ]

[ "NewSaltpackEncrypt", "creates", "a", "SaltpackEncrypt", "engine", "." ]

[ "func", "NewRekeyQueueStandard", "(", "config", "Config", ")", "(", "rkq", "*", "RekeyQueueStandard", ")", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "rkq", "=", "&", "RekeyQueueStandard", "{", "config", ":", "config", ",", "log", ":", "config", ".", "MakeLogger", "(", "\"", "\"", ")", ",", "queue", ":", "make", "(", "chan", "tlf", ".", "ID", ",", "config", ".", "Mode", "(", ")", ".", "RekeyQueueSize", "(", ")", ")", ",", "limiter", ":", "rate", ".", "NewLimiter", "(", "rekeysPerSecond", ",", "numConcurrentRekeys", ")", ",", "pendings", ":", "make", "(", "map", "[", "tlf", ".", "ID", "]", "bool", ")", ",", "cancel", ":", "cancel", ",", "}", "\n", "if", "config", ".", "Mode", "(", ")", ".", "RekeyWorkers", "(", ")", ">", "0", "{", "rkq", ".", "start", "(", "ctx", ")", "\n", "}", "\n", "return", "rkq", "\n", "}" ]

[ "NewRekeyQueueStandard", "creates", "a", "new", "rekey", "queue", "." ]

[ "func", "(", "rkq", "*", "RekeyQueueStandard", ")", "start", "(", "ctx", "context", ".", "Context", ")", "{", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "id", ":=", "<-", "rkq", ".", "queue", ":", "if", "err", ":=", "rkq", ".", "limiter", ".", "Wait", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "rkq", ".", "log", ".", "Debug", "(", "\"", "\"", ",", "id", ",", "err", ")", "\n", "return", "\n", "}", "\n", "rkq", ".", "config", ".", "KBFSOps", "(", ")", ".", "RequestRekey", "(", "context", ".", "Background", "(", ")", ",", "id", ")", "\n", "func", "(", "id", "tlf", ".", "ID", ")", "{", "rkq", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rkq", ".", "mu", ".", "Unlock", "(", ")", "\n", "delete", "(", "rkq", ".", "pendings", ",", "id", ")", "\n", "}", "(", "id", ")", "\n", "case", "err", ":=", "<-", "ctx", ".", "Done", "(", ")", ":", "rkq", ".", "log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "start", "spawns", "a", "goroutine", "that", "dispatches", "rekey", "requests", "to", "correct", "folder", "branch", "ops", "while", "conforming", "to", "the", "rater", "limiter", "." ]

[ "func", "(", "rkq", "*", "RekeyQueueStandard", ")", "Enqueue", "(", "id", "tlf", ".", "ID", ")", "{", "rkq", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rkq", ".", "mu", ".", "Unlock", "(", ")", "\n", "rkq", ".", "pendings", "[", "id", "]", "=", "true", "\n\n", "select", "{", "case", "rkq", ".", "queue", "<-", "id", ":", "default", ":", "// The queue is full; drop this one for now until the next", "// request to the server for more rekeys.", "rkq", ".", "log", ".", "Debug", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "}" ]

[ "Enqueue", "implements", "the", "RekeyQueue", "interface", "for", "RekeyQueueStandard", "." ]

[ "func", "(", "rkq", "*", "RekeyQueueStandard", ")", "IsRekeyPending", "(", "id", "tlf", ".", "ID", ")", "bool", "{", "rkq", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "rkq", ".", "mu", ".", "RUnlock", "(", ")", "\n", "return", "rkq", ".", "pendings", "[", "id", "]", "\n", "}" ]

[ "IsRekeyPending", "implements", "the", "RekeyQueue", "interface", "for", "RekeyQueueStandard", "." ]

[ "func", "(", "rkq", "*", "RekeyQueueStandard", ")", "Shutdown", "(", ")", "{", "rkq", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rkq", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "rkq", ".", "cancel", "!=", "nil", "{", "rkq", ".", "cancel", "(", ")", "\n", "rkq", ".", "cancel", "=", "nil", "\n", "}", "\n", "}" ]

[ "Shutdown", "implements", "the", "RekeyQueue", "interface", "for", "RekeyQueueStandard", "." ]

[ "func", "NewPaperKeySubmit", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "paperPhrase", "string", ")", "*", "PaperKeySubmit", "{", "return", "&", "PaperKeySubmit", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "paperPhrase", ":", "paperPhrase", ",", "}", "\n", "}" ]

[ "NewPaperKeySubmit", "creates", "a", "PaperKeySubmit", "engine", "." ]

[ "func", "(", "c", "CryptoClient", ")", "SignED25519ForKBFS", "(", "ctx", "context", ".", "Context", ",", "__arg", "SignED25519ForKBFSArg", ")", "(", "res", "ED25519SignatureInfo", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Same", "as", "the", "above", "except", "a", "KBFS", "-", "specific", "prefix", "is", "added", "to", "the", "payload", "to", "be", "signed", "." ]