Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.7k

[ "func", "(", "a", "*", "ActiveDevice", ")", "setSigningKey", "(", "g", "*", "GlobalContext", ",", "uv", "keybase1", ".", "UserVersion", ",", "deviceID", "keybase1", ".", "DeviceID", ",", "sigKey", "GenericKey", ",", "deviceName", "string", ")", "error", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n\n", "if", "err", ":=", "a", ".", "internalUpdateUserVersionDeviceID", "(", "uv", ",", "deviceID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "a", ".", "signingKey", "=", "sigKey", "\n", "if", "len", "(", "deviceName", ")", ">", "0", "{", "a", ".", "deviceName", "=", "deviceName", "\n", "}", "\n", "a", ".", "nistFactory", "=", "NewNISTFactory", "(", "g", ",", "uv", ".", "Uid", ",", "deviceID", ",", "sigKey", ")", "\n", "return", "nil", "\n", "}" ]

[ "setSigningKey", "acquires", "the", "write", "lock", "and", "sets", "the", "signing", "key", ".", "The", "acct", "parameter", "is", "not", "used", "for", "anything", "except", "to", "help", "ensure", "that", "this", "is", "called", "from", "inside", "a", "LogingState", "account", "request", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "setEncryptionKey", "(", "uv", "keybase1", ".", "UserVersion", ",", "deviceID", "keybase1", ".", "DeviceID", ",", "encKey", "GenericKey", ")", "error", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n\n", "if", "err", ":=", "a", ".", "internalUpdateUserVersionDeviceID", "(", "uv", ",", "deviceID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "a", ".", "encryptionKey", "=", "encKey", "\n", "return", "nil", "\n", "}" ]

[ "setEncryptionKey", "acquires", "the", "write", "lock", "and", "sets", "the", "encryption", "key", ".", "The", "acct", "parameter", "is", "not", "used", "for", "anything", "except", "to", "help", "ensure", "that", "this", "is", "called", "from", "inside", "a", "LogingState", "account", "request", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "setDeviceName", "(", "uv", "keybase1", ".", "UserVersion", ",", "deviceID", "keybase1", ".", "DeviceID", ",", "deviceName", "string", ")", "error", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n\n", "if", "strings", ".", "TrimSpace", "(", "deviceName", ")", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "internalUpdateUserVersionDeviceID", "(", "uv", ",", "deviceID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "a", ".", "deviceName", "=", "deviceName", "\n", "return", "nil", "\n", "}" ]

[ "setDeviceName", "acquires", "the", "write", "lock", "and", "sets", "the", "device", "name", ".", "The", "acct", "parameter", "is", "not", "used", "for", "anything", "except", "to", "help", "ensure", "that", "this", "is", "called", "from", "inside", "a", "LoginState", "account", "request", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "internalUpdateUserVersionDeviceID", "(", "uv", "keybase1", ".", "UserVersion", ",", "deviceID", "keybase1", ".", "DeviceID", ")", "error", "{", "if", "uv", ".", "IsNil", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "deviceID", ".", "IsNil", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "a", ".", "uv", ".", "IsNil", "(", ")", "&&", "a", ".", "deviceID", ".", "IsNil", "(", ")", "{", "a", ".", "uv", "=", "uv", "\n", "a", ".", "deviceID", "=", "deviceID", "\n", "}", "else", "if", "!", "a", ".", "uv", ".", "Eq", "(", "uv", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "!", "a", ".", "deviceID", ".", "Eq", "(", "deviceID", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "should", "only", "called", "by", "the", "functions", "in", "this", "type", "with", "the", "write", "lock", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "clear", "(", ")", "error", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n\n", "a", ".", "uv", "=", "keybase1", ".", "UserVersion", "{", "}", "\n", "a", ".", "deviceID", "=", "\"", "\"", "\n", "a", ".", "signingKey", "=", "nil", "\n", "a", ".", "encryptionKey", "=", "nil", "\n", "a", ".", "nistFactory", "=", "nil", "\n", "a", ".", "passphrase", "=", "nil", "\n", "a", ".", "provisioningKey", "=", "nil", "\n", "a", ".", "secretPromptCancelTimer", ".", "Reset", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Clear", "acquires", "the", "write", "lock", "and", "resets", "all", "the", "fields", "to", "zero", "values", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "UID", "(", ")", "keybase1", ".", "UID", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "return", "a", ".", "uv", ".", "Uid", "\n", "}" ]

[ "UID", "returns", "the", "user", "ID", "that", "was", "provided", "when", "the", "device", "keys", "were", "cached", ".", "Safe", "for", "use", "by", "concurrent", "goroutines", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "Username", "(", "m", "MetaContext", ")", "NormalizedUsername", "{", "return", "m", ".", "G", "(", ")", ".", "Env", ".", "GetUsernameForUID", "(", "a", ".", "UID", "(", ")", ")", "\n", "}" ]

[ "Username", "tries", "to", "get", "the", "active", "user", "s", "username", "by", "looking", "into", "the", "current", "environment", "and", "mapping", "an", "UID", "to", "a", "username", "based", "on", "our", "config", "file", ".", "It", "won", "t", "work", "halfway", "through", "a", "provisioning", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "DeviceID", "(", ")", "keybase1", ".", "DeviceID", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "return", "a", ".", "deviceID", "\n", "}" ]

[ "DeviceID", "returns", "the", "device", "ID", "that", "was", "provided", "when", "the", "device", "keys", "were", "cached", ".", "Safe", "for", "use", "by", "concurrent", "goroutines", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "SigningKey", "(", ")", "(", "GenericKey", ",", "error", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "if", "a", ".", "signingKey", "==", "nil", "{", "return", "nil", ",", "NotFoundError", "{", "Msg", ":", "\"", "\"", ",", "}", "\n", "}", "\n", "return", "a", ".", "signingKey", ",", "nil", "\n", "}" ]

[ "SigningKey", "returns", "the", "signing", "key", "for", "the", "active", "device", ".", "Safe", "for", "use", "by", "concurrent", "goroutines", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "EncryptionKey", "(", ")", "(", "GenericKey", ",", "error", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "if", "a", ".", "encryptionKey", "==", "nil", "{", "return", "nil", ",", "NotFoundError", "{", "Msg", ":", "\"", "\"", ",", "}", "\n", "}", "\n", "return", "a", ".", "encryptionKey", ",", "nil", "\n", "}" ]

[ "EncryptionKey", "returns", "the", "encryption", "key", "for", "the", "active", "device", ".", "Safe", "for", "use", "by", "concurrent", "goroutines", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "KeyByType", "(", "t", "SecretKeyType", ")", "(", "GenericKey", ",", "error", ")", "{", "switch", "t", "{", "case", "DeviceSigningKeyType", ":", "return", "a", ".", "SigningKey", "(", ")", "\n", "case", "DeviceEncryptionKeyType", ":", "return", "a", ".", "EncryptionKey", "(", ")", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "t", ")", "\n", "}", "\n", "}" ]

[ "KeyByType", "returns", "a", "cached", "key", "based", "on", "SecretKeyType", ".", "Safe", "for", "use", "by", "concurrent", "goroutines", "." ]

[ "func", "(", "a", "*", "ActiveDevice", ")", "AllFields", "(", ")", "(", "uv", "keybase1", ".", "UserVersion", ",", "deviceID", "keybase1", ".", "DeviceID", ",", "deviceName", "string", ",", "sigKey", "GenericKey", ",", "encKey", "GenericKey", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n\n", "return", "a", ".", "uv", ",", "a", ".", "deviceID", ",", "a", ".", "deviceName", ",", "a", ".", "signingKey", ",", "a", ".", "encryptionKey", "\n", "}" ]

[ "AllFields", "returns", "all", "the", "ActiveDevice", "fields", "via", "one", "lock", "for", "consistency", ".", "Safe", "for", "use", "by", "concurrent", "goroutines", "." ]

[ "func", "(", "bl", "*", "blockLock", ")", "DoRUnlockedIfPossible", "(", "lState", "*", "kbfssync", ".", "LockState", ",", "f", "func", "(", "*", "kbfssync", ".", "LockState", ")", ")", "{", "if", "!", "bl", ".", "locked", "{", "bl", ".", "RUnlock", "(", "lState", ")", "\n", "defer", "bl", ".", "RLock", "(", "lState", ")", "\n", "}", "\n\n", "f", "(", "lState", ")", "\n", "}" ]

[ "DoRUnlockedIfPossible", "must", "be", "called", "when", "r", "-", "or", "w", "-", "locked", ".", "If", "r", "-", "locked", "r", "-", "unlocks", "runs", "the", "given", "function", "and", "r", "-", "locks", "after", "it", "s", "done", ".", "Otherwise", "just", "runs", "the", "given", "function", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "markForReIdentifyIfNeeded", "(", "now", "time", ".", "Time", ",", "maxValid", "time", ".", "Duration", ")", "{", "fbo", ".", "identifyLock", ".", "Lock", "(", ")", "\n", "defer", "fbo", ".", "identifyLock", ".", "Unlock", "(", ")", "\n", "if", "fbo", ".", "identifyDone", "&&", "(", "now", ".", "Before", "(", "fbo", ".", "identifyTime", ")", "||", "fbo", ".", "identifyTime", ".", "Add", "(", "maxValid", ")", ".", "Before", "(", "now", ")", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "nil", ",", "\"", "\"", ",", "fbo", ".", "identifyTime", ")", "\n", "fbo", ".", "identifyDone", "=", "false", "\n", "}", "\n", "}" ]

[ "markForReIdentifyIfNeeded", "checks", "whether", "this", "tlf", "is", "identified", "and", "mark", "it", "for", "lazy", "reidentification", "if", "it", "exceeds", "time", "limits", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "error", "{", "if", "fbo", ".", "config", ".", "CheckStateOnShutdown", "(", ")", "{", "lState", ":=", "makeFBOLockState", "(", ")", "\n\n", "if", "fbo", ".", "blocks", ".", "GetState", "(", "lState", ")", "==", "dirtyState", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "else", "if", "fbo", ".", "isUnmerged", "(", "lState", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "else", "{", "// Make sure we're up to date first", "if", "err", ":=", "fbo", ".", "SyncFromServer", "(", "ctx", ",", "fbo", ".", "folderBranch", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Check the state for consistency before shutting down.", "sc", ":=", "NewStateChecker", "(", "fbo", ".", "config", ")", "\n", "if", "err", ":=", "sc", ".", "CheckMergedState", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "fbo", ".", "fbm", ".", "waitForArchives", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "close", "(", "fbo", ".", "shutdownChan", ")", "\n", "fbo", ".", "cr", ".", "Shutdown", "(", ")", "\n", "fbo", ".", "fbm", ".", "shutdown", "(", ")", "\n", "fbo", ".", "rekeyFSM", ".", "Shutdown", "(", ")", "\n", "// Wait for all the goroutines to finish, so that we don't have any races", "// with logging during test reporting.", "fbo", ".", "doneWg", ".", "Wait", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Shutdown", "safely", "shuts", "down", "any", "background", "goroutines", "that", "may", "have", "been", "launched", "by", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "isUnmerged", "(", "lState", "*", "kbfssync", ".", "LockState", ")", "bool", "{", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n", "return", "fbo", ".", "unmergedBID", "!=", "kbfsmd", ".", "NullBranchID", "\n", "}" ]

[ "isUnmerged", "should", "not", "be", "called", "if", "mdWriterLock", "is", "already", "taken", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "clearConflictView", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "// TODO(KBFS-3990): show the cleared conflict view under a special path,", "// so users can copy any unmerged files manually back into their synced", "// view before nuking it.", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n\n", "journalEnabled", ":=", "TLFJournalEnabled", "(", "fbo", ".", "config", ",", "fbo", ".", "id", "(", ")", ")", "\n", "if", "journalEnabled", "{", "err", "=", "fbo", ".", "unstageLocked", "(", "ctx", ",", "lState", ",", "moveJournalsAway", ")", "\n", "}", "else", "{", "err", "=", "fbo", ".", "unstageLocked", "(", "ctx", ",", "lState", ",", "doPruneBranches", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "fbo", ".", "cr", ".", "clearConflictRecords", "(", ")", "\n", "}" ]

[ "clearConflictView", "tells", "the", "journal", "to", "move", "any", "pending", "writes", "elsewhere", "resets", "the", "CR", "counter", "and", "resets", "the", "FBO", "to", "have", "a", "synced", "view", "of", "the", "TLF", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "getJournalPredecessorRevision", "(", "ctx", "context", ".", "Context", ")", "(", "kbfsmd", ".", "Revision", ",", "error", ")", "{", "jManager", ",", "err", ":=", "GetJournalManager", "(", "fbo", ".", "config", ")", "\n", "if", "err", "!=", "nil", "{", "// Journaling is disabled entirely.", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "nil", "\n", "}", "\n\n", "jStatus", ",", "err", ":=", "jManager", ".", "JournalStatus", "(", "fbo", ".", "id", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// Journaling is disabled for this TLF, so use the local head.", "// TODO: JournalStatus could return other errors (likely", "// file/disk corruption) that indicate a real problem, so it", "// might be nice to type those errors so we can distinguish", "// them.", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "nil", "\n", "}", "\n\n", "if", "jStatus", ".", "BranchID", "!=", "kbfsmd", ".", "NullBranchID", ".", "String", "(", ")", "{", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "errNoMergedRevWhileStaged", "\n", "}", "\n\n", "if", "jStatus", ".", "RevisionStart", "==", "kbfsmd", ".", "RevisionUninitialized", "{", "// The journal is empty, so the local head must be the most recent.", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "nil", "\n", "}", "else", "if", "jStatus", ".", "RevisionStart", "==", "kbfsmd", ".", "RevisionInitial", "{", "// Nothing has been flushed to the servers yet, so don't", "// return anything.", "return", "kbfsmd", ".", "RevisionUninitialized", ",", "errNoFlushedRevisions", "\n", "}", "\n\n", "return", "jStatus", ".", "RevisionStart", "-", "1", ",", "nil", "\n", "}" ]

[ "getJournalPredecessorRevision", "returns", "the", "revision", "that", "precedes", "the", "current", "journal", "head", "if", "journaling", "enabled", "and", "there", "are", "unflushed", "MD", "updates", ";", "otherwise", "it", "returns", "kbfsmd", ".", "RevisionUninitialized", ".", "If", "there", "aren", "t", "any", "flushed", "MD", "revisions", "it", "returns", "errNoFlushedRevisions", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "validateHeadLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "ImmutableRootMetadata", ")", "error", "{", "fbo", ".", "headLock", ".", "AssertLocked", "(", "lState", ")", "\n\n", "// Validate fbo against fetched md and discard the fetched one.", "if", "fbo", ".", "head", ".", "TlfID", "(", ")", "!=", "md", ".", "TlfID", "(", ")", "{", "fbo", ".", "log", ".", "CCriticalf", "(", "ctx", ",", "\"", "\"", ",", "fbo", ".", "head", ".", "TlfID", "(", ")", ",", "md", ".", "TlfID", "(", ")", ",", "fbo", ".", "head", ".", "mdID", ",", "md", ".", "mdID", ")", "\n", "return", "kbfsmd", ".", "MDTlfIDMismatch", "{", "CurrID", ":", "fbo", ".", "head", ".", "TlfID", "(", ")", ",", "NextID", ":", "md", ".", "TlfID", "(", ")", "}", "\n", "}", "\n", "fbo", ".", "headStatus", "=", "headTrusted", "\n", "return", "nil", "\n", "}" ]

[ "validateHeadLocked", "validates", "an", "untrusted", "head", "and", "sets", "it", "as", "trusted", ".", "see", "headTrustedState", "comment", "for", "more", "information", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "doPartialMarkAndSweep", "(", "ctx", "context", ".", "Context", ",", "syncConfig", "keybase1", ".", "FolderSyncConfig", ",", "latestMerged", "ImmutableRootMetadata", ")", "(", "err", "error", ")", "{", "startTime", ",", "timer", ":=", "fbo", ".", "startOp", "(", "ctx", ",", "\"", "\"", ",", "latestMerged", ".", "Revision", "(", ")", ")", "\n", "defer", "func", "(", ")", "{", "fbo", ".", "endOp", "(", "ctx", ",", "startTime", ",", "timer", ",", "\"", "\"", ",", "latestMerged", ".", "Revision", "(", ")", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "if", "syncConfig", ".", "Mode", "!=", "keybase1", ".", "FolderSyncMode_PARTIAL", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "syncConfig", ".", "Mode", ")", "\n", "}", "else", "if", "len", "(", "syncConfig", ".", "Paths", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "rootNode", ",", "_", ",", "_", ",", "err", ":=", "fbo", ".", "getRootNode", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "tag", ":=", "ctx", ".", "Value", "(", "CtxFBOIDKey", ")", ".", "(", "string", ")", "\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "cacheType", ":=", "DiskBlockSyncCache", "\n", "err", "=", "fbo", ".", "blocks", ".", "MarkNode", "(", "ctx", ",", "lState", ",", "rootNode", ",", "latestMerged", ",", "tag", ",", "cacheType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "pathLoop", ":", "for", "_", ",", "p", ":=", "range", "syncConfig", ".", "Paths", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "p", ")", "\n\n", "// Mark the parent directories.", "parentPath", ",", "syncedElem", ":=", "stdpath", ".", "Split", "(", "p", ")", "\n", "parents", ":=", "strings", ".", "Split", "(", "strings", ".", "TrimSuffix", "(", "parentPath", ",", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "currNode", ":=", "rootNode", "\n", "for", "_", ",", "parent", ":=", "range", "parents", "{", "if", "len", "(", "parent", ")", "==", "0", "{", "continue", "\n", "}", "\n", "// TODO: parallelize the parent fetches and lookups.", "currNode", ",", "_", ",", "err", "=", "fbo", ".", "Lookup", "(", "ctx", ",", "currNode", ",", "parent", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "idutil", ".", "NoSuchNameError", ":", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "p", ")", "\n", "continue", "pathLoop", "\n", "case", "nil", ":", "default", ":", "return", "err", "\n", "}", "\n\n", "err", "=", "fbo", ".", "blocks", ".", "MarkNode", "(", "ctx", ",", "lState", ",", "currNode", ",", "latestMerged", ",", "tag", ",", "cacheType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// Now mark everything rooted at this path.", "currNode", ",", "_", ",", "err", "=", "fbo", ".", "Lookup", "(", "ctx", ",", "currNode", ",", "syncedElem", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "idutil", ".", "NoSuchNameError", ":", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "p", ")", "\n", "continue", "pathLoop", "\n", "case", "nil", ":", "default", ":", "return", "err", "\n", "}", "\n\n", "err", "=", "fbo", ".", "markRecursive", "(", "ctx", ",", "lState", ",", "currNode", ",", "latestMerged", ",", "tag", ",", "cacheType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "fbo", ".", "config", ".", "DiskBlockCache", "(", ")", ".", "DeleteUnmarked", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ",", "tag", ",", "cacheType", ")", "\n", "}" ]

[ "doPartialMarkAndSweep", "runs", "a", "mark", "-", "and", "-", "sweep", "algorithm", "against", "all", "the", "currently", "-", "synced", "paths", "to", "delete", "any", "blocks", "not", "reachable", "from", "one", "of", "these", "paths", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "setNewInitialHeadLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "ImmutableRootMetadata", ")", "error", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "AssertLocked", "(", "lState", ")", "\n", "if", "fbo", ".", "head", "!=", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "md", ".", "Revision", "(", ")", "!=", "kbfsmd", ".", "RevisionInitial", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "Revision", "(", ")", ")", "\n", "}", "\n", "return", "fbo", ".", "setHeadLocked", "(", "ctx", ",", "lState", ",", "md", ",", "headTrusted", ",", "mdToCommitType", "(", "md", ")", ")", "\n", "}" ]

[ "setNewInitialHeadLocked", "is", "for", "when", "we", "re", "creating", "a", "brand", "-", "new", "TLF", ".", "This", "is", "trusted", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "setInitialHeadTrustedLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "ImmutableRootMetadata", ",", "ct", "mdCommitType", ")", "error", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "AssertLocked", "(", "lState", ")", "\n", "if", "fbo", ".", "head", "!=", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "fbo", ".", "setHeadLocked", "(", "ctx", ",", "lState", ",", "md", ",", "headTrusted", ",", "ct", ")", "\n", "}" ]

[ "setInitialHeadTrustedLocked", "is", "for", "when", "the", "given", "RootMetadata", "was", "fetched", "due", "to", "a", "user", "action", "and", "will", "be", "checked", "against", "the", "TLF", "name", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "setHeadSuccessorLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "ImmutableRootMetadata", ",", "rebased", "bool", ")", "error", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "AssertLocked", "(", "lState", ")", "\n", "if", "fbo", ".", "head", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "// This can happen in tests via SyncFromServer().", "return", "fbo", ".", "setInitialHeadTrustedLocked", "(", "ctx", ",", "lState", ",", "md", ",", "mdToCommitType", "(", "md", ")", ")", "\n", "}", "\n\n", "if", "!", "rebased", "{", "err", ":=", "fbo", ".", "head", ".", "CheckValidSuccessor", "(", "fbo", ".", "head", ".", "mdID", ",", "md", ".", "ReadOnly", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "oldHandle", ":=", "fbo", ".", "head", ".", "GetTlfHandle", "(", ")", "\n", "newHandle", ":=", "md", ".", "GetTlfHandle", "(", ")", "\n\n", "// Newer handles should be equal or more resolved over time.", "//", "// TODO: In some cases, they shouldn't, e.g. if we're on an", "// unmerged branch. Add checks for this.", "resolvesTo", ",", "partialResolvedOldHandle", ",", "err", ":=", "oldHandle", ".", "ResolvesTo", "(", "ctx", ",", "fbo", ".", "config", ".", "Codec", "(", ")", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "tlfhandle", ".", "ConstIDGetter", "{", "ID", ":", "fbo", ".", "id", "(", ")", "}", ",", "fbo", ".", "config", ",", "*", "newHandle", ")", "\n", "if", "err", "!=", "nil", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "oldHandle", ",", "newHandle", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "oldName", ":=", "oldHandle", ".", "GetCanonicalName", "(", ")", "\n", "newName", ":=", "newHandle", ".", "GetCanonicalName", "(", ")", "\n\n", "if", "!", "resolvesTo", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "oldHandle", ",", "partialResolvedOldHandle", ",", "newHandle", ")", "\n", "return", "IncompatibleHandleError", "{", "oldName", ",", "partialResolvedOldHandle", ".", "GetCanonicalName", "(", ")", ",", "newName", ",", "}", "\n", "}", "\n\n", "err", "=", "fbo", ".", "setHeadLocked", "(", "ctx", ",", "lState", ",", "md", ",", "headTrusted", ",", "mdToCommitType", "(", "md", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "oldName", "!=", "newName", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "oldName", ",", "newName", ")", "\n\n", "fbo", ".", "config", ".", "MDCache", "(", ")", ".", "ChangeHandleForID", "(", "oldHandle", ",", "newHandle", ")", "\n", "// If the handle has changed, send out a notification.", "fbo", ".", "observers", ".", "tlfHandleChange", "(", "ctx", ",", "fbo", ".", "head", ".", "GetTlfHandle", "(", ")", ")", "\n", "// Also the folder should be re-identified given the", "// newly-resolved assertions.", "func", "(", ")", "{", "fbo", ".", "identifyLock", ".", "Lock", "(", ")", "\n", "defer", "fbo", ".", "identifyLock", ".", "Unlock", "(", ")", "\n", "fbo", ".", "identifyDone", "=", "false", "\n", "}", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "setHeadSuccessorLocked", "is", "for", "when", "we", "re", "applying", "updates", "from", "the", "server", "or", "when", "we", "re", "applying", "new", "updates", "we", "created", "ourselves", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "setHeadPredecessorLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "ImmutableRootMetadata", ")", "error", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "AssertLocked", "(", "lState", ")", "\n", "if", "fbo", ".", "head", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "fbo", ".", "head", ".", "Revision", "(", ")", "<=", "kbfsmd", ".", "RevisionInitial", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "fbo", ".", "head", ".", "Revision", "(", ")", ")", "\n", "}", "\n\n", "if", "fbo", ".", "head", ".", "MergedStatus", "(", ")", "!=", "kbfsmd", ".", "Unmerged", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "err", ":=", "md", ".", "CheckValidSuccessor", "(", "md", ".", "mdID", ",", "fbo", ".", "head", ".", "ReadOnly", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "oldHandle", ":=", "fbo", ".", "head", ".", "GetTlfHandle", "(", ")", "\n", "newHandle", ":=", "md", ".", "GetTlfHandle", "(", ")", "\n\n", "// The two handles must be the same, since no rekeying is done", "// while unmerged.", "eq", ",", "err", ":=", "oldHandle", ".", "Equals", "(", "fbo", ".", "config", ".", "Codec", "(", ")", ",", "*", "newHandle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "eq", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "oldHandle", ",", "newHandle", ")", "\n", "}", "\n\n", "return", "fbo", ".", "setHeadLocked", "(", "ctx", ",", "lState", ",", "md", ",", "headTrusted", ",", "mdToCommitType", "(", "md", ")", ")", "\n", "}" ]

[ "setHeadPredecessorLocked", "is", "for", "when", "we", "re", "unstaging", "updates", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "setHeadConflictResolvedLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "ImmutableRootMetadata", ")", "error", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "AssertLocked", "(", "lState", ")", "\n", "if", "fbo", ".", "head", ".", "MergedStatus", "(", ")", "!=", "kbfsmd", ".", "Unmerged", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "md", ".", "MergedStatus", "(", ")", "!=", "kbfsmd", ".", "Merged", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "fbo", ".", "setHeadLocked", "(", "ctx", ",", "lState", ",", "md", ",", "headTrusted", ",", "mdToCommitType", "(", "md", ")", ")", "\n", "}" ]

[ "setHeadConflictResolvedLocked", "is", "for", "when", "we", "re", "setting", "the", "merged", "update", "with", "resolved", "conflicts", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "getMDForRead", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "rtype", "mdReadType", ")", "(", "md", "ImmutableRootMetadata", ",", "err", "error", ")", "{", "if", "rtype", "!=", "mdReadNeedIdentify", "&&", "rtype", "!=", "mdReadNoIdentify", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "md", "=", "fbo", ".", "getTrustedHead", "(", "ctx", ",", "lState", ",", "mdCommit", ")", "\n", "if", "md", "!=", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "if", "rtype", "!=", "mdReadNoIdentify", "{", "err", "=", "fbo", ".", "identifyOnce", "(", "ctx", ",", "md", ".", "ReadOnly", "(", ")", ")", "\n", "}", "\n", "return", "md", ",", "err", "\n", "}", "\n\n", "return", "ImmutableRootMetadata", "{", "}", ",", "MDWriteNeededInRequest", "{", "}", "\n", "}" ]

[ "getMDForRead", "returns", "an", "existing", "md", "for", "a", "read", "operation", ".", "Note", "that", "mds", "will", "not", "be", "fetched", "here", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "GetTLFHandle", "(", "ctx", "context", ".", "Context", ",", "_", "Node", ")", "(", "*", "tlfhandle", ".", "Handle", ",", "error", ")", "{", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "md", ",", "_", ":=", "fbo", ".", "getHead", "(", "ctx", ",", "lState", ",", "mdNoCommit", ")", "\n", "return", "md", ".", "GetTlfHandle", "(", ")", ",", "nil", "\n", "}" ]

[ "GetTLFHandle", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "getMDForWriteOrRekeyLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "mdType", "mdUpdateType", ")", "(", "md", "ImmutableRootMetadata", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "||", "mdType", "==", "mdRekey", "{", "return", "\n", "}", "\n", "err", "=", "fbo", ".", "identifyOnce", "(", "ctx", ",", "md", ".", "ReadOnly", "(", ")", ")", "\n", "}", "(", ")", "\n\n", "md", "=", "fbo", ".", "getTrustedHead", "(", "ctx", ",", "lState", ",", "mdNoCommit", ")", "\n", "if", "md", "!=", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "return", "md", ",", "nil", "\n", "}", "\n\n", "// MDs coming from from rekey notifications are marked untrusted.", "//", "// TODO: Make tests not take this code path.", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n\n", "// Not in cache, fetch from server and add to cache. First, see", "// if this device has any unmerged commits -- take the latest one.", "mdops", ":=", "fbo", ".", "config", ".", "MDOps", "(", ")", "\n\n", "// get the head of the unmerged branch for this device (if any)", "md", ",", "err", "=", "mdops", ".", "GetUnmergedForTLF", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ",", "kbfsmd", ".", "NullBranchID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "mergedMD", ",", "err", ":=", "mdops", ".", "GetForTLF", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "mergedMD", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "errors", ".", "WithStack", "(", "NoMergedMDError", "{", "fbo", ".", "id", "(", ")", "}", ")", "\n", "}", "\n\n", "if", "md", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "// There are no unmerged MDs for this device, so just use the current head.", "md", "=", "mergedMD", "\n", "}", "else", "{", "func", "(", ")", "{", "fbo", ".", "headLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "headLock", ".", "Unlock", "(", "lState", ")", "\n", "// We don't need to do this for merged head", "// because the setHeadLocked() already does", "// that anyway.", "fbo", ".", "setLatestMergedRevisionLocked", "(", "ctx", ",", "lState", ",", "mergedMD", ".", "Revision", "(", ")", ",", "false", ")", "\n", "}", "(", ")", "\n", "}", "\n\n", "if", "md", ".", "data", ".", "Dir", ".", "Type", "!=", "data", ".", "Dir", "&&", "(", "!", "md", ".", "IsInitialized", "(", ")", "||", "md", ".", "IsReadable", "(", ")", ")", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "fbo", ".", "id", "(", ")", ",", "md", ".", "IsInitialized", "(", ")", ",", "md", ".", "IsReadable", "(", ")", ")", "\n", "}", "\n\n", "fbo", ".", "headLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "headLock", ".", "Unlock", "(", "lState", ")", "\n", "headStatus", ":=", "headTrusted", "\n", "if", "mdType", "==", "mdRekey", "{", "// If we already have a head (that has been filled after the initial", "// check, but before we acquired the lock), then just return it.", "if", "fbo", ".", "head", "!=", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "return", "fbo", ".", "head", ",", "nil", "\n", "}", "\n", "headStatus", "=", "headUntrusted", "\n", "}", "\n\n", "err", "=", "fbo", ".", "setHeadLocked", "(", "ctx", ",", "lState", ",", "md", ",", "headStatus", ",", "mdToCommitType", "(", "md", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "md", ",", "nil", "\n", "}" ]

[ "getMDForWriteOrRekeyLocked", "can", "fetch", "MDs", "identify", "them", "and", "contains", "the", "fancy", "logic", ".", "For", "reading", "use", "getMDLockedForRead", ".", "Here", "we", "actually", "can", "fetch", "things", "from", "the", "server", ".", "rekeys", "are", "untrusted", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "getMostRecentFullyMergedMD", "(", "ctx", "context", ".", "Context", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "mergedRev", ",", "err", ":=", "fbo", ".", "getJournalPredecessorRevision", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "mergedRev", "==", "kbfsmd", ".", "RevisionUninitialized", "{", "// No unflushed journal entries, so use the local head.", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "return", "fbo", ".", "getMDForReadHelper", "(", "ctx", ",", "lState", ",", "mdReadNoIdentify", ")", "\n", "}", "\n\n", "// Otherwise, use the specified revision.", "rmd", ",", "err", ":=", "getSingleMD", "(", "ctx", ",", "fbo", ".", "config", ",", "fbo", ".", "id", "(", ")", ",", "kbfsmd", ".", "NullBranchID", ",", "mergedRev", ",", "kbfsmd", ".", "Merged", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "mergedRev", ")", "\n", "return", "rmd", ",", "nil", "\n", "}" ]

[ "getMostRecentFullyMergedMD", "is", "a", "helper", "method", "that", "returns", "the", "most", "recent", "merged", "MD", "that", "has", "been", "flushed", "to", "the", "server", ".", "This", "could", "be", "different", "from", "the", "current", "local", "head", "if", "journaling", "is", "on", ".", "If", "the", "journal", "is", "on", "a", "branch", "it", "returns", "an", "error", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "getMDForRekeyWriteLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ")", "(", "rmd", "*", "RootMetadata", ",", "lastWriterVerifyingKey", "kbfscrypto", ".", "VerifyingKey", ",", "wasRekeySet", "bool", ",", "err", "error", ")", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n\n", "md", ",", "err", ":=", "fbo", ".", "getMDForWriteOrRekeyLocked", "(", "ctx", ",", "lState", ",", "mdRekey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "VerifyingKey", "{", "}", ",", "false", ",", "err", "\n", "}", "\n\n", "if", "md", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "return", "nil", ",", "kbfscrypto", ".", "VerifyingKey", "{", "}", ",", "false", ",", "nil", "\n", "}", "\n\n", "session", ",", "err", ":=", "fbo", ".", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "VerifyingKey", "{", "}", ",", "false", ",", "err", "\n", "}", "\n\n", "handle", ":=", "md", ".", "GetTlfHandle", "(", ")", "\n\n", "// must be a reader or writer (it checks both.)", "if", "!", "handle", ".", "IsReader", "(", "session", ".", "UID", ")", "{", "return", "nil", ",", "kbfscrypto", ".", "VerifyingKey", "{", "}", ",", "false", ",", "NewRekeyPermissionError", "(", "md", ".", "GetTlfHandle", "(", ")", ",", "session", ".", "Name", ")", "\n", "}", "\n\n", "newMd", ",", "err", ":=", "md", ".", "MakeSuccessor", "(", "ctx", ",", "fbo", ".", "config", ".", "MetadataVersion", "(", ")", ",", "fbo", ".", "config", ".", "Codec", "(", ")", ",", "fbo", ".", "config", ".", "KeyManager", "(", ")", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ",", "md", ".", "mdID", ",", "handle", ".", "IsWriter", "(", "session", ".", "UID", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "VerifyingKey", "{", "}", ",", "false", ",", "err", "\n", "}", "\n\n", "// readers shouldn't modify writer metadata", "if", "!", "handle", ".", "IsWriter", "(", "session", ".", "UID", ")", "&&", "!", "newMd", ".", "IsWriterMetadataCopiedSet", "(", ")", "{", "return", "nil", ",", "kbfscrypto", ".", "VerifyingKey", "{", "}", ",", "false", ",", "NewRekeyPermissionError", "(", "handle", ",", "session", ".", "Name", ")", "\n", "}", "\n\n", "return", "newMd", ",", "md", ".", "LastModifyingWriterVerifyingKey", "(", ")", ",", "md", ".", "IsRekeySet", "(", ")", ",", "nil", "\n", "}" ]

[ "getMDForRekeyWriteLocked", "returns", "a", "nil", "rmd", "if", "it", "is", "a", "team", "TLF", "since", "that", "can", "t", "be", "rekeyed", "by", "KBFS", "." ]

[ "func", "ResetRootBlock", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ",", "rmd", "*", "RootMetadata", ")", "(", "data", ".", "Block", ",", "data", ".", "BlockInfo", ",", "data", ".", "ReadyBlockData", ",", "error", ")", "{", "newDblock", ":=", "data", ".", "NewDirBlock", "(", ")", "\n", "chargedTo", ",", "err", ":=", "chargedToForTLF", "(", "ctx", ",", "config", ".", "KBPKI", "(", ")", ",", "config", ".", "KBPKI", "(", ")", ",", "config", ",", "rmd", ".", "GetTlfHandle", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "data", ".", "BlockInfo", "{", "}", ",", "data", ".", "ReadyBlockData", "{", "}", ",", "err", "\n", "}", "\n\n", "info", ",", "plainSize", ",", "readyBlockData", ",", "err", ":=", "data", ".", "ReadyBlock", "(", "ctx", ",", "config", ".", "BlockCache", "(", ")", ",", "config", ".", "BlockOps", "(", ")", ",", "rmd", ".", "ReadOnly", "(", ")", ",", "newDblock", ",", "chargedTo", ",", "config", ".", "DefaultBlockType", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "data", ".", "BlockInfo", "{", "}", ",", "data", ".", "ReadyBlockData", "{", "}", ",", "err", "\n", "}", "\n\n", "now", ":=", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", "\n", "rmd", ".", "data", ".", "Dir", "=", "data", ".", "DirEntry", "{", "BlockInfo", ":", "info", ",", "EntryInfo", ":", "data", ".", "EntryInfo", "{", "Type", ":", "data", ".", "Dir", ",", "Size", ":", "uint64", "(", "plainSize", ")", ",", "Mtime", ":", "now", ",", "Ctime", ":", "now", ",", "}", ",", "}", "\n", "prevDiskUsage", ":=", "rmd", ".", "DiskUsage", "(", ")", "\n", "rmd", ".", "SetDiskUsage", "(", "0", ")", "\n", "// Redundant, since this is called only for brand-new or", "// successor RMDs, but leave in to be defensive.", "rmd", ".", "ClearBlockChanges", "(", ")", "\n", "co", ":=", "newCreateOpForRootDir", "(", ")", "\n", "rmd", ".", "AddOp", "(", "co", ")", "\n", "rmd", ".", "AddRefBlock", "(", "rmd", ".", "data", ".", "Dir", ".", "BlockInfo", ")", "\n", "// Set unref bytes to the previous disk usage, so that the", "// accounting works out.", "rmd", ".", "AddUnrefBytes", "(", "prevDiskUsage", ")", "\n", "return", "newDblock", ",", "info", ",", "readyBlockData", ",", "nil", "\n", "}" ]

[ "ResetRootBlock", "creates", "a", "new", "empty", "dir", "block", "and", "sets", "the", "given", "metadata", "s", "root", "block", "to", "it", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "SetInitialHeadToNew", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "handle", "*", "tlfhandle", ".", "Handle", ")", "(", "err", "error", ")", "{", "startTime", ",", "timer", ":=", "fbo", ".", "startOp", "(", "ctx", ",", "\"", "\"", ",", "id", ")", "\n", "defer", "func", "(", ")", "{", "fbo", ".", "endOp", "(", "ctx", ",", "startTime", ",", "timer", ",", "\"", "\"", ",", "id", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "rmd", ",", "err", ":=", "makeInitialRootMetadata", "(", "fbo", ".", "config", ".", "MetadataVersion", "(", ")", ",", "id", ",", "handle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "runUnlessCanceled", "(", "ctx", ",", "func", "(", ")", "error", "{", "// New heads can only be set for the MasterBranch.", "fb", ":=", "data", ".", "FolderBranch", "{", "Tlf", ":", "rmd", ".", "TlfID", "(", ")", ",", "Branch", ":", "data", ".", "MasterBranch", "}", "\n", "if", "fb", "!=", "fbo", ".", "folderBranch", "{", "return", "WrongOpsError", "{", "fbo", ".", "folderBranch", ",", "fb", "}", "\n", "}", "\n\n", "// Always identify first when trying to initialize the folder,", "// even if we turn out not to be a writer. (We can't rely on", "// the identifyOnce call in getMDLocked, because that isn't", "// called from the initialization code path when the local", "// user is not a valid writer.) Also, we want to make sure we", "// fail before we set the head, otherwise future calls will", "// succeed incorrectly.", "err", "=", "fbo", ".", "identifyOnce", "(", "ctx", ",", "rmd", ".", "ReadOnly", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n\n", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n", "return", "fbo", ".", "initMDLocked", "(", "ctx", ",", "lState", ",", "rmd", ")", "\n", "}", ")", "\n", "}" ]

[ "SetInitialHeadToNew", "creates", "a", "brand", "-", "new", "ImmutableRootMetadata", "object", "and", "sets", "the", "head", "to", "that", ".", "This", "is", "trusted", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "statEntry", "(", "ctx", "context", ".", "Context", ",", "node", "Node", ")", "(", "de", "data", ".", "DirEntry", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "fbo", ".", "transformReadError", "(", "ctx", ",", "node", ",", "err", ")", "\n", "}", "(", ")", "\n", "err", "=", "fbo", ".", "checkNodeForRead", "(", "ctx", ",", "node", ")", "\n", "if", "err", "!=", "nil", "{", "return", "data", ".", "DirEntry", "{", "}", ",", "err", "\n", "}", "\n\n", "nodePath", ",", "err", ":=", "fbo", ".", "pathFromNodeForRead", "(", "node", ")", "\n", "if", "err", "!=", "nil", "{", "return", "data", ".", "DirEntry", "{", "}", ",", "err", "\n", "}", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "var", "md", "ImmutableRootMetadata", "\n", "if", "nodePath", ".", "HasValidParent", "(", ")", "{", "// Look up the node for the parent, and see if it has an FS", "// that can be used to stat `node`.", "parentPath", ":=", "nodePath", ".", "ParentPath", "(", ")", "\n", "parentNode", ":=", "fbo", ".", "nodeCache", ".", "Get", "(", "parentPath", ".", "TailPointer", "(", ")", ".", "Ref", "(", ")", ")", "\n", "de", ",", "ok", ",", "err", ":=", "fbo", ".", "statUsingFS", "(", "ctx", ",", "lState", ",", "parentNode", ",", "node", ".", "GetBasename", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "data", ".", "DirEntry", "{", "}", ",", "err", "\n", "}", "\n", "if", "ok", "{", "return", "de", ",", "nil", "\n", "}", "\n\n", "// Otherwise, proceed with the usual way.", "md", ",", "err", "=", "fbo", ".", "getMDForReadNeedIdentify", "(", "ctx", ",", "lState", ")", "\n", "// And handle the error, err is local to this block", "// shadowing the err in the surrounding block.", "if", "err", "!=", "nil", "{", "return", "data", ".", "DirEntry", "{", "}", ",", "err", "\n", "}", "\n", "}", "else", "{", "// If nodePath has no valid parent, it's just the TLF root, so", "// we don't need an identify in this case. Note: we don't", "// support FS-based stats for the root directory.", "md", ",", "err", "=", "fbo", ".", "getMDForReadNoIdentify", "(", "ctx", ",", "lState", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "data", ".", "DirEntry", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "fbo", ".", "blocks", ".", "GetEntryEvenIfDeleted", "(", "ctx", ",", "lState", ",", "md", ".", "ReadOnly", "(", ")", ",", "nodePath", ")", "\n", "}" ]

[ "statEntry", "is", "like", "Stat", "but", "it", "returns", "a", "DirEntry", ".", "This", "is", "used", "by", "tests", "." ]

[ "func", "isRevisionConflict", "(", "err", "error", ")", "bool", "{", "if", "err", "==", "nil", "{", "return", "false", "\n", "}", "\n", "_", ",", "isConflictRevision", ":=", "err", ".", "(", "kbfsmd", ".", "ServerErrorConflictRevision", ")", "\n", "_", ",", "isConflictPrevRoot", ":=", "err", ".", "(", "kbfsmd", ".", "ServerErrorConflictPrevRoot", ")", "\n", "_", ",", "isConflictDiskUsage", ":=", "err", ".", "(", "kbfsmd", ".", "ServerErrorConflictDiskUsage", ")", "\n", "_", ",", "isConditionFailed", ":=", "err", ".", "(", "kbfsmd", ".", "ServerErrorConditionFailed", ")", "\n", "_", ",", "isConflictFolderMapping", ":=", "err", ".", "(", "kbfsmd", ".", "ServerErrorConflictFolderMapping", ")", "\n", "_", ",", "isJournal", ":=", "err", ".", "(", "MDJournalConflictError", ")", "\n", "return", "isConflictRevision", "||", "isConflictPrevRoot", "||", "isConflictDiskUsage", "||", "isConditionFailed", "||", "isConflictFolderMapping", "||", "isJournal", "\n", "}" ]

[ "Returns", "true", "if", "the", "passed", "error", "indicates", "a", "revision", "conflict", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "PathType", "(", ")", "tlfhandle", ".", "PathType", "{", "switch", "fbo", ".", "folderBranch", ".", "Tlf", ".", "Type", "(", ")", "{", "case", "tlf", ".", "Public", ":", "return", "tlfhandle", ".", "PublicPathType", "\n", "case", "tlf", ".", "Private", ":", "return", "tlfhandle", ".", "PrivatePathType", "\n", "case", "tlf", ".", "SingleTeam", ":", "return", "tlfhandle", ".", "SingleTeamPathType", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fbo", ".", "folderBranch", ".", "Tlf", ".", "Type", "(", ")", ")", ")", "\n", "}", "\n", "}" ]

[ "PathType", "returns", "path", "type" ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "canonicalPath", "(", "ctx", "context", ".", "Context", ",", "dir", "Node", ",", "name", "string", ")", "(", "string", ",", "error", ")", "{", "dirPath", ",", "err", ":=", "fbo", ".", "pathFromNodeForRead", "(", "dir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "tlfhandle", ".", "BuildCanonicalPath", "(", "fbo", ".", "PathType", "(", ")", ",", "dirPath", ".", "String", "(", ")", ",", "name", ")", ",", "nil", "\n", "}" ]

[ "canonicalPath", "returns", "full", "canonical", "path", "for", "dir", "node", "and", "name", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "notifyAndSyncOrSignal", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "undoFn", "dirCacheUndoFn", ",", "nodesToDirty", "[", "]", "Node", ",", "op", "op", ",", "md", "ReadOnlyRootMetadata", ")", "(", "err", "error", ")", "{", "fbo", ".", "dirOps", "=", "append", "(", "fbo", ".", "dirOps", ",", "cachedDirOp", "{", "op", ",", "nodesToDirty", "}", ")", "\n", "var", "addedNodes", "[", "]", "Node", "\n", "for", "_", ",", "n", ":=", "range", "nodesToDirty", "{", "added", ":=", "fbo", ".", "status", ".", "addDirtyNode", "(", "n", ")", "\n", "if", "added", "{", "addedNodes", "=", "append", "(", "addedNodes", ",", "n", ")", "\n", "}", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "for", "_", ",", "n", ":=", "range", "addedNodes", "{", "fbo", ".", "status", ".", "rmDirtyNode", "(", "n", ")", "\n", "}", "\n", "fbo", ".", "dirOps", "=", "fbo", ".", "dirOps", "[", ":", "len", "(", "fbo", ".", "dirOps", ")", "-", "1", "]", "\n", "if", "undoFn", "!=", "nil", "{", "undoFn", "(", "lState", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "// It's safe to notify before we've synced, since it is only", "// sending invalidation notifications. At worst the upper layer", "// will just have to refresh its cache needlessly.", "err", "=", "fbo", ".", "notifyOneOp", "(", "ctx", ",", "lState", ",", "op", ",", "md", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "fbo", ".", "syncDirUpdateOrSignal", "(", "ctx", ",", "lState", ")", "\n", "}" ]

[ "notifyAndSyncOrSignal", "caches", "an", "op", "in", "memory", "and", "dirties", "the", "relevant", "node", "and", "then", "sends", "a", "notification", "for", "it", ".", "If", "batching", "is", "on", "it", "signals", "the", "write", ";", "otherwise", "it", "syncs", "the", "change", ".", "It", "should", "only", "be", "called", "as", "the", "final", "instruction", "that", "can", "fail", "in", "a", "method", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "unrefEntryLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "ro", "op", ",", "dir", "data", ".", "Path", ",", "de", "data", ".", "DirEntry", ",", "name", "string", ")", "error", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n", "if", "de", ".", "Type", "==", "data", ".", "Sym", "{", "return", "nil", "\n", "}", "\n\n", "unrefsToAdd", ":=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "bool", ")", "\n", "fbo", ".", "prepper", ".", "cacheBlockInfos", "(", "[", "]", "data", ".", "BlockInfo", "{", "de", ".", "BlockInfo", "}", ")", "\n", "unrefsToAdd", "[", "de", ".", "BlockPointer", "]", "=", "true", "\n", "// construct a path for the child so we can unlink with it.", "childPath", ":=", "dir", ".", "ChildPath", "(", "name", ",", "de", ".", "BlockPointer", ")", "\n\n", "// If this is an indirect block, we need to delete all of its", "// children as well. NOTE: non-empty directories can't be", "// removed, so no need to check for indirect directory blocks", "// here.", "if", "de", ".", "Type", "==", "data", ".", "File", "||", "de", ".", "Type", "==", "data", ".", "Exec", "{", "blockInfos", ",", "err", ":=", "fbo", ".", "blocks", ".", "GetIndirectFileBlockInfos", "(", "ctx", ",", "lState", ",", "kmd", ",", "childPath", ")", "\n", "if", "isRecoverableBlockErrorForRemoval", "(", "err", ")", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "childPath", ")", "\n", "fbo", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "msg", ")", "\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "msg", ",", "err", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fbo", ".", "prepper", ".", "cacheBlockInfos", "(", "blockInfos", ")", "\n", "for", "_", ",", "blockInfo", ":=", "range", "blockInfos", "{", "unrefsToAdd", "[", "blockInfo", ".", "BlockPointer", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "// Any referenced blocks that were unreferenced since the last", "// sync can just be forgotten about. Note that any updated", "// pointers that are unreferenced will be fixed up during syncing.", "for", "_", ",", "dirOp", ":=", "range", "fbo", ".", "dirOps", "{", "for", "i", ":=", "len", "(", "dirOp", ".", "dirOp", ".", "Refs", "(", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "ref", ":=", "dirOp", ".", "dirOp", ".", "Refs", "(", ")", "[", "i", "]", "\n", "if", "_", ",", "ok", ":=", "unrefsToAdd", "[", "ref", "]", ";", "ok", "{", "dirOp", ".", "dirOp", ".", "DelRefBlock", "(", "ref", ")", "\n", "delete", "(", "unrefsToAdd", ",", "ref", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "for", "unref", ":=", "range", "unrefsToAdd", "{", "ro", ".", "AddUnrefBlock", "(", "unref", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "unrefEntry", "modifies", "md", "to", "unreference", "all", "relevant", "blocks", "for", "the", "given", "entry", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "SyncAll", "(", "ctx", "context", ".", "Context", ",", "folderBranch", "data", ".", "FolderBranch", ")", "(", "err", "error", ")", "{", "startTime", ",", "timer", ":=", "fbo", ".", "startOp", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "fbo", ".", "endOp", "(", "ctx", ",", "startTime", ",", "timer", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "if", "folderBranch", "!=", "fbo", ".", "folderBranch", "{", "return", "WrongOpsError", "{", "fbo", ".", "folderBranch", ",", "folderBranch", "}", "\n", "}", "\n\n", "return", "fbo", ".", "doMDWriteWithRetryUnlessCanceled", "(", "ctx", ",", "func", "(", "lState", "*", "kbfssync", ".", "LockState", ")", "error", "{", "return", "fbo", ".", "syncAllLocked", "(", "ctx", ",", "lState", ",", "NoExcl", ")", "\n", "}", ")", "\n", "}" ]

[ "SyncAll", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "notifyBatchLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "ImmutableRootMetadata", ")", "error", "{", "fbo", ".", "headLock", ".", "AssertLocked", "(", "lState", ")", "\n\n", "for", "_", ",", "op", ":=", "range", "md", ".", "data", ".", "Changes", ".", "Ops", "{", "err", ":=", "fbo", ".", "notifyOneOpLocked", "(", "ctx", ",", "lState", ",", "op", ",", "md", ".", "ReadOnly", "(", ")", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "notifyBatchLocked", "sends", "out", "a", "notification", "for", "all", "the", "ops", "in", "md", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "searchForNode", "(", "ctx", "context", ".", "Context", ",", "ptr", "data", ".", "BlockPointer", ",", "md", "ReadOnlyRootMetadata", ")", "(", "Node", ",", "error", ")", "{", "// Record which pointers are new to this update, and thus worth", "// searching.", "newPtrs", ":=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "bool", ")", "\n", "for", "_", ",", "op", ":=", "range", "md", ".", "data", ".", "Changes", ".", "Ops", "{", "for", "_", ",", "update", ":=", "range", "op", ".", "allUpdates", "(", ")", "{", "newPtrs", "[", "update", ".", "Ref", "]", "=", "true", "\n", "}", "\n", "for", "_", ",", "ref", ":=", "range", "op", ".", "Refs", "(", ")", "{", "newPtrs", "[", "ref", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "nodeMap", ",", "_", ",", "err", ":=", "fbo", ".", "blocks", ".", "SearchForNodes", "(", "ctx", ",", "fbo", ".", "nodeCache", ",", "[", "]", "data", ".", "BlockPointer", "{", "ptr", "}", ",", "newPtrs", ",", "md", ",", "md", ".", "data", ".", "Dir", ".", "BlockPointer", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "n", ",", "ok", ":=", "nodeMap", "[", "ptr", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "NodeNotFoundError", "{", "ptr", "}", "\n", "}", "\n\n", "return", "n", ",", "nil", "\n", "}" ]

[ "searchForNode", "tries", "to", "figure", "out", "the", "path", "to", "the", "given", "blockPointer", "using", "only", "the", "block", "updates", "that", "happened", "as", "part", "of", "a", "given", "MD", "update", "operation", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "getAndApplyMDUpdates", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "lockBeforeGet", "*", "keybase1", ".", "LockID", ",", "applyFunc", "applyMDUpdatesFunc", ")", "error", "{", "// first look up all MD revisions newer than my current head", "start", ":=", "fbo", ".", "getLatestMergedRevision", "(", "lState", ")", "+", "1", "\n", "rmds", ",", "err", ":=", "getMergedMDUpdates", "(", "ctx", ",", "fbo", ".", "config", ",", "fbo", ".", "id", "(", ")", ",", "start", ",", "lockBeforeGet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "applyFunc", "(", "ctx", ",", "lState", ",", "rmds", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Assumes", "all", "necessary", "locking", "is", "either", "already", "done", "by", "caller", "or", "is", "done", "by", "applyFunc", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "getUnmergedMDUpdates", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ")", "(", "kbfsmd", ".", "Revision", ",", "[", "]", "ImmutableRootMetadata", ",", "error", ")", "{", "// acquire mdWriterLock to read the current branch ID.", "unmergedBID", ":=", "func", "(", ")", "kbfsmd", ".", "BranchID", "{", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n", "return", "fbo", ".", "unmergedBID", "\n", "}", "(", ")", "\n", "return", "getUnmergedMDUpdates", "(", "ctx", ",", "fbo", ".", "config", ",", "fbo", ".", "id", "(", ")", ",", "unmergedBID", ",", "fbo", ".", "getCurrMDRevision", "(", "lState", ")", ")", "\n", "}" ]

[ "getUnmergedMDUpdates", "returns", "a", "slice", "of", "the", "unmerged", "MDs", "for", "this", "TLF", "s", "current", "unmerged", "branch", "and", "unmerged", "branch", "between", "the", "merge", "point", "for", "the", "branch", "and", "the", "current", "head", ".", "The", "returned", "MDs", "are", "the", "same", "instances", "that", "are", "stored", "in", "the", "MD", "cache", "so", "they", "should", "be", "modified", "with", "care", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "undoUnmergedMDUpdatesLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ")", "(", "[", "]", "data", ".", "BlockPointer", ",", "error", ")", "{", "fbo", ".", "mdWriterLock", ".", "AssertLocked", "(", "lState", ")", "\n\n", "currHead", ",", "unmergedRmds", ",", "err", ":=", "fbo", ".", "getUnmergedMDUpdatesLocked", "(", "ctx", ",", "lState", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "fbo", ".", "undoMDUpdatesLocked", "(", "ctx", ",", "lState", ",", "unmergedRmds", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// We have arrived at the branch point. The new root is", "// the previous revision from the current head. Find it", "// and apply. TODO: somehow fake the current head into", "// being currHead-1, so that future calls to", "// applyMDUpdates will fetch this along with the rest of", "// the updates.", "fbo", ".", "setBranchIDLocked", "(", "lState", ",", "kbfsmd", ".", "NullBranchID", ")", "\n\n", "rmd", ",", "err", ":=", "getSingleMD", "(", "ctx", ",", "fbo", ".", "config", ",", "fbo", ".", "id", "(", ")", ",", "kbfsmd", ".", "NullBranchID", ",", "currHead", ",", "kbfsmd", ".", "Merged", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "err", "=", "func", "(", ")", "error", "{", "fbo", ".", "headLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "headLock", ".", "Unlock", "(", "lState", ")", "\n", "err", "=", "fbo", ".", "setHeadPredecessorLocked", "(", "ctx", ",", "lState", ",", "rmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fbo", ".", "setLatestMergedRevisionLocked", "(", "ctx", ",", "lState", ",", "rmd", ".", "Revision", "(", ")", ",", "true", ")", "\n", "return", "nil", "\n", "}", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Return all new refs", "var", "unmergedPtrs", "[", "]", "data", ".", "BlockPointer", "\n", "for", "_", ",", "rmd", ":=", "range", "unmergedRmds", "{", "for", "_", ",", "op", ":=", "range", "rmd", ".", "data", ".", "Changes", ".", "Ops", "{", "for", "_", ",", "ptr", ":=", "range", "op", ".", "Refs", "(", ")", "{", "if", "ptr", "!=", "data", ".", "ZeroPtr", "{", "unflushed", ",", "err", ":=", "fbo", ".", "config", ".", "BlockServer", "(", ")", ".", "IsUnflushed", "(", "ctx", ",", "rmd", ".", "tlfHandle", ".", "TlfID", "(", ")", ",", "ptr", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "!", "unflushed", "{", "unmergedPtrs", "=", "append", "(", "unmergedPtrs", ",", "ptr", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "for", "_", ",", "update", ":=", "range", "op", ".", "allUpdates", "(", ")", "{", "if", "update", ".", "Ref", "!=", "data", ".", "ZeroPtr", "{", "unflushed", ",", "err", ":=", "fbo", ".", "config", ".", "BlockServer", "(", ")", ".", "IsUnflushed", "(", "ctx", ",", "rmd", ".", "tlfHandle", ".", "TlfID", "(", ")", ",", "update", ".", "Ref", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "!", "unflushed", "{", "unmergedPtrs", "=", "append", "(", "unmergedPtrs", ",", "update", ".", "Ref", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "unmergedPtrs", ",", "nil", "\n", "}" ]

[ "Returns", "a", "list", "of", "block", "pointers", "that", "were", "created", "during", "the", "staged", "era", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "finalizeResolution", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "md", "*", "RootMetadata", ",", "bps", "blockPutState", ",", "newOps", "[", "]", "op", ",", "blocksToDelete", "[", "]", "kbfsblock", ".", "ID", ")", "error", "{", "// Take the writer lock.", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n", "return", "fbo", ".", "finalizeResolutionLocked", "(", "ctx", ",", "lState", ",", "md", ",", "bps", ",", "newOps", ",", "blocksToDelete", ")", "\n", "}" ]

[ "finalizeResolution", "caches", "all", "the", "blocks", "and", "writes", "the", "new", "MD", "to", "the", "merged", "branch", "failing", "if", "there", "is", "a", "conflict", ".", "It", "also", "sends", "out", "the", "given", "newOps", "notifications", "locally", ".", "This", "is", "used", "for", "completing", "conflict", "resolution", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "TeamAbandoned", "(", "ctx", "context", ".", "Context", ",", "tid", "keybase1", ".", "TeamID", ")", "{", "ctx", ",", "cancelFunc", ":=", "fbo", ".", "newCtxWithFBOID", "(", ")", "\n", "defer", "cancelFunc", "(", ")", "\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tid", ")", "\n", "fbo", ".", "locallyFinalizeTLF", "(", "ctx", ")", "\n", "}" ]

[ "TeamAbandoned", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "MigrateToImplicitTeam", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ")", "(", "err", "error", ")", "{", "// Only MasterBranch FBOs may be migrated.", "fb", ":=", "data", ".", "FolderBranch", "{", "Tlf", ":", "id", ",", "Branch", ":", "data", ".", "MasterBranch", "}", "\n", "if", "fb", "!=", "fbo", ".", "folderBranch", "{", "// TODO: log instead of panic?", "panic", "(", "WrongOpsError", "{", "fbo", ".", "folderBranch", ",", "fb", "}", ")", "\n", "}", "\n\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ")", "\n", "defer", "func", "(", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "if", "id", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "&&", "id", ".", "Type", "(", ")", "!=", "tlf", ".", "Public", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "id", ".", "Type", "(", ")", ")", "\n", "}", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n\n", "md", ",", "err", ":=", "fbo", ".", "getMDForMigrationLocked", "(", "ctx", ",", "lState", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "md", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "md", ".", "IsFinal", "(", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "md", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "name", ":=", "string", "(", "md", ".", "GetTlfHandle", "(", ")", ".", "GetCanonicalName", "(", ")", ")", "\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "name", ")", "\n", "newHandle", ",", "err", ":=", "tlfhandle", ".", "ParseHandle", "(", "ctx", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ".", "MDOps", "(", ")", ",", "fbo", ".", "config", ",", "name", ",", "id", ".", "Type", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Make sure the new handle contains just a team.", "if", "newHandle", ".", "TypeForKeying", "(", ")", "!=", "tlf", ".", "TeamKeying", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "session", ",", "err", ":=", "fbo", ".", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "isWriter", ":=", "true", "// getMDForMigrationLocked already checked this.", "\n", "newMD", ",", "err", ":=", "md", ".", "MakeSuccessorWithNewHandle", "(", "ctx", ",", "newHandle", ",", "fbo", ".", "config", ".", "MetadataVersion", "(", ")", ",", "fbo", ".", "config", ".", "Codec", "(", ")", ",", "fbo", ".", "config", ".", "KeyManager", "(", ")", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ",", "md", ".", "mdID", ",", "isWriter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "newMD", ".", "TypeForKeying", "(", ")", "!=", "tlf", ".", "TeamKeying", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Add an empty operation to satisfy assumptions elsewhere.", "newMD", ".", "AddOp", "(", "newRekeyOp", "(", ")", ")", "\n\n", "return", "fbo", ".", "finalizeMDRekeyWriteLocked", "(", "ctx", ",", "lState", ",", "newMD", ",", "session", ".", "VerifyingKey", ")", "\n", "}" ]

[ "MigrateToImplicitTeam", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "GetEditHistory", "(", "ctx", "context", ".", "Context", ",", "_", "data", ".", "FolderBranch", ")", "(", "tlfHistory", "keybase1", ".", "FSFolderEditHistory", ",", "err", "error", ")", "{", "// Wait for any outstanding edit requests.", "if", "err", ":=", "fbo", ".", "editActivity", ".", "Wait", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "FSFolderEditHistory", "{", "}", ",", "err", "\n", "}", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "md", ",", "_", ":=", "fbo", ".", "getHead", "(", "ctx", ",", "lState", ",", "mdNoCommit", ")", "\n", "name", ":=", "md", ".", "GetTlfHandle", "(", ")", ".", "GetCanonicalName", "(", ")", "\n", "return", "fbo", ".", "config", ".", "UserHistory", "(", ")", ".", "GetTlfHistory", "(", "name", ",", "fbo", ".", "id", "(", ")", ".", "Type", "(", ")", ")", ",", "nil", "\n", "}" ]

[ "GetEditHistory", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps" ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "ClearPrivateFolderMD", "(", "ctx", "context", ".", "Context", ")", "{", "func", "(", ")", "{", "// Cancel the edits goroutine and forget the old history, evem", "// for public folders, since some of the state in the history", "// is dependent on your login state.", "fbo", ".", "editsLock", ".", "Lock", "(", ")", "\n", "defer", "fbo", ".", "editsLock", ".", "Unlock", "(", ")", "\n", "if", "fbo", ".", "cancelEdits", "!=", "nil", "{", "fbo", ".", "cancelEdits", "(", ")", "\n", "fbo", ".", "cancelEdits", "=", "nil", "\n", "}", "\n", "fbo", ".", "editHistory", "=", "kbfsedits", ".", "NewTlfHistory", "(", ")", "\n", "// Allow the edit monitor to be re-launched later whenever the", "// MD is set again.", "fbo", ".", "launchEditMonitor", "=", "sync", ".", "Once", "{", "}", "\n", "fbo", ".", "convLock", ".", "Lock", "(", ")", "\n", "defer", "fbo", ".", "convLock", ".", "Unlock", "(", ")", "\n", "fbo", ".", "convID", "=", "nil", "\n", "}", "(", ")", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "headLock", ".", "Unlock", "(", "lState", ")", "\n\n", "fbo", ".", "blocks", ".", "ClearChargedTo", "(", "lState", ")", "\n\n", "if", "fbo", ".", "folderBranch", ".", "Tlf", ".", "Type", "(", ")", "==", "tlf", ".", "Public", "{", "return", "\n", "}", "\n\n", "if", "fbo", ".", "head", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "// Nothing to clear.", "return", "\n", "}", "\n\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "// First cancel the background goroutine that's registered for", "// updates, because the next time we set the head in this FBO", "// we'll launch another one.", "fbo", ".", "cancelUpdatesLock", ".", "Lock", "(", ")", "\n", "defer", "fbo", ".", "cancelUpdatesLock", ".", "Unlock", "(", ")", "\n", "if", "fbo", ".", "cancelUpdates", "!=", "nil", "{", "fbo", ".", "cancelUpdates", "(", ")", "\n", "select", "{", "case", "<-", "fbo", ".", "updateDoneChan", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "fbo", ".", "config", ".", "MDServer", "(", ")", ".", "CancelRegistration", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ")", "\n", "}", "\n\n", "fbo", ".", "head", "=", "ImmutableRootMetadata", "{", "}", "\n", "fbo", ".", "headStatus", "=", "headUntrusted", "\n", "fbo", ".", "latestMergedRevision", "=", "kbfsmd", ".", "RevisionUninitialized", "\n", "fbo", ".", "hasBeenCleared", "=", "true", "\n", "}" ]

[ "ClearPrivateFolderMD", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "ForceFastForward", "(", "ctx", "context", ".", "Context", ")", "{", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "fbo", ".", "headLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "headLock", ".", "RUnlock", "(", "lState", ")", "\n", "if", "fbo", ".", "head", "!=", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "// We're already up to date.", "return", "\n", "}", "\n", "if", "!", "fbo", ".", "hasBeenCleared", "{", "// No reason to fast-forward here if it hasn't ever been", "// cleared.", "return", "\n", "}", "\n", "fbo", ".", "hasBeenCleared", "=", "false", "\n\n", "fbo", ".", "forcedFastForwards", ".", "Add", "(", "1", ")", "\n", "fbo", ".", "goTracked", "(", "func", "(", ")", "{", "defer", "fbo", ".", "forcedFastForwards", ".", "Done", "(", ")", "\n", "ctx", ",", "cancelFunc", ":=", "fbo", ".", "newCtxWithFBOID", "(", ")", "\n", "defer", "cancelFunc", "(", ")", "\n\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "var", "currHead", "ImmutableRootMetadata", "\n", "var", "err", "error", "\n", "getMD", ":", "for", "i", ":=", "0", ";", ";", "i", "++", "{", "currHead", ",", "err", "=", "fbo", ".", "config", ".", "MDOps", "(", ")", ".", "GetForTLF", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ",", "nil", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "nil", ":", "break", "getMD", "\n", "case", "kbfsmd", ".", "ServerErrorUnauthorized", ":", "// The MD server connection might not be authorized", "// yet, so give it a few chances to go through.", "if", "i", ">", "5", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "fbo", ".", "id", "(", ")", ")", "\n", "return", "\n", "}", "\n", "if", "i", "==", "0", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "fbo", ".", "id", "(", ")", ")", "\n", "}", "\n", "time", ".", "Sleep", "(", "1", "*", "time", ".", "Second", ")", "\n", "default", ":", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "if", "currHead", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "currHead", ".", "Revision", "(", ")", ")", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "// Kick off partial prefetching once the latest merged", "// revision is set.", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "fbo", ".", "kickOffPartialSyncIfNeeded", "(", "ctx", ",", "lState", ",", "currHead", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "headLock", ".", "Unlock", "(", "lState", ")", "\n", "if", "fbo", ".", "head", "!=", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "// We're already up to date.", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "err", "=", "fbo", ".", "doFastForwardLocked", "(", "ctx", ",", "lState", ",", "currHead", ")", "\n", "if", "err", "!=", "nil", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "ForceFastForward", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "Reset", "(", "ctx", "context", ".", "Context", ",", "handle", "*", "tlfhandle", ".", "Handle", ")", "error", "{", "currHandle", ",", "err", ":=", "fbo", ".", "GetTLFHandle", "(", "ctx", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "equal", ",", "err", ":=", "currHandle", ".", "Equals", "(", "fbo", ".", "config", ".", "Codec", "(", ")", ",", "*", "handle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "equal", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "currHandle", ",", "handle", ")", "\n", "}", "\n\n", "oldHandle", ":=", "handle", ".", "DeepCopy", "(", ")", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "fbo", ".", "mdWriterLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "mdWriterLock", ".", "Unlock", "(", "lState", ")", "\n", "fbo", ".", "headLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "headLock", ".", "Unlock", "(", "lState", ")", "\n\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "changes", ",", "affectedNodeIDs", ",", "err", ":=", "fbo", ".", "blocks", ".", "GetInvalidationChangesForAll", "(", "ctx", ",", "lState", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Invalidate all the affected nodes.", "if", "len", "(", "changes", ")", ">", "0", "{", "fbo", ".", "observers", ".", "batchChanges", "(", "ctx", ",", "changes", ",", "affectedNodeIDs", ")", "\n", "}", "\n\n", "// Make up a finalized name for the old handle, and broadcast it", "// to all observers. This is to move it out of the way of the", "// next iteration of the folder.", "now", ":=", "fbo", ".", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", "\n", "finalizedInfo", ",", "err", ":=", "tlf", ".", "NewHandleExtension", "(", "tlf", ".", "HandleExtensionFinalized", ",", "1", ",", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "now", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "oldHandle", ".", "SetFinalizedInfo", "(", "finalizedInfo", ")", "\n", "// FIXME: This can't be subject to the WaitGroup due to a potential", "// deadlock, so we use a raw goroutine here instead of `goTracked`.", "go", "fbo", ".", "observers", ".", "tlfHandleChange", "(", "ctx", ",", "oldHandle", ")", "\n", "return", "nil", "\n", "}" ]

[ "Reset", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "GetSyncConfig", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "(", "keybase1", ".", "FolderSyncConfig", ",", "error", ")", "{", "if", "tlfID", "!=", "fbo", ".", "id", "(", ")", "||", "fbo", ".", "branch", "(", ")", "!=", "data", ".", "MasterBranch", "{", "return", "keybase1", ".", "FolderSyncConfig", "{", "}", ",", "WrongOpsError", "{", "fbo", ".", "folderBranch", ",", "data", ".", "FolderBranch", "{", "Tlf", ":", "tlfID", ",", "Branch", ":", "data", ".", "MasterBranch", ",", "}", "}", "\n", "}", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "md", ",", "_", ":=", "fbo", ".", "getHead", "(", "ctx", ",", "lState", ",", "mdNoCommit", ")", "\n", "config", ",", "tlfPath", ",", "err", ":=", "fbo", ".", "getProtocolSyncConfigUnlocked", "(", "ctx", ",", "lState", ",", "md", ")", "\n", "if", "errors", ".", "Cause", "(", "err", ")", "==", "errNeedMDForPartialSyncConfig", "{", "// This is a partially-synced TLF, so it should be initialized", "// automatically by KBFSOps; we just need to wait for the MD.", "var", "once", "sync", ".", "Once", "\n", "for", "md", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "{", "once", ".", "Do", "(", "func", "(", ")", "{", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", ")", "\n", "t", ":=", "time", ".", "After", "(", "100", "*", "time", ".", "Millisecond", ")", "\n", "select", "{", "case", "<-", "t", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "keybase1", ".", "FolderSyncConfig", "{", "}", ",", "errors", ".", "WithStack", "(", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n", "md", ",", "_", "=", "fbo", ".", "getHead", "(", "ctx", ",", "lState", ",", "mdNoCommit", ")", "\n", "}", "\n", "config", ",", "tlfPath", ",", "err", "=", "fbo", ".", "getProtocolSyncConfigUnlocked", "(", "ctx", ",", "lState", ",", "md", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "FolderSyncConfig", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "config", ".", "Mode", "==", "keybase1", ".", "FolderSyncMode_DISABLED", "||", "md", "==", "(", "ImmutableRootMetadata", "{", "}", ")", "||", "md", ".", "GetTlfHandle", "(", ")", ".", "GetCanonicalPath", "(", ")", "==", "tlfPath", "{", "return", "config", ",", "nil", "\n", "}", "\n\n", "// This means either the config was originally written before we", "// started saving TLF paths, or the TLF paths has changed due to", "// an SBS resolution or a subteam rename. Calling `SetSyncConfig`", "// will use the newest path from the MD's TlfHandle.", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\\\"", "\\\"", "\\\"", "\\\"", "\"", ",", "tlfPath", ",", "md", ".", "GetTlfHandle", "(", ")", ".", "GetCanonicalPath", "(", ")", ")", "\n", "_", ",", "err", "=", "fbo", ".", "SetSyncConfig", "(", "ctx", ",", "tlfID", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "fbo", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "GetSyncConfig", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "InvalidateNodeAndChildren", "(", "ctx", "context", ".", "Context", ",", "node", "Node", ")", "(", "err", "error", ")", "{", "startTime", ",", "timer", ":=", "fbo", ".", "startOp", "(", "ctx", ",", "\"", "\"", ",", "node", ")", "\n", "defer", "func", "(", ")", "{", "fbo", ".", "endOp", "(", "ctx", ",", "startTime", ",", "timer", ",", "\"", "\"", ",", "node", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "lState", ":=", "makeFBOLockState", "(", ")", "\n", "changes", ",", "affectedNodeIDs", ",", "err", ":=", "fbo", ".", "blocks", ".", "GetInvalidationChangesForNode", "(", "ctx", ",", "lState", ",", "node", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "len", "(", "changes", ")", ">", "0", "{", "fbo", ".", "observers", ".", "batchChanges", "(", "ctx", ",", "changes", ",", "affectedNodeIDs", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "InvalidateNodeAndChildren", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "(", "fbo", "*", "folderBranchOps", ")", "NewNotificationChannel", "(", "ctx", "context", ".", "Context", ",", "handle", "*", "tlfhandle", ".", "Handle", ",", "convID", "chat1", ".", "ConversationID", ",", "channelName", "string", ")", "{", "monitoringCh", ":=", "fbo", ".", "getEditMonitoringChannel", "(", ")", "\n", "if", "monitoringCh", "==", "nil", "{", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "convID", ",", "channelName", ")", "\n", "fbo", ".", "editActivity", ".", "Add", "(", "1", ")", "\n", "select", "{", "case", "fbo", ".", "editChannels", "<-", "editChannelActivity", "{", "convID", ",", "channelName", ",", "\"", "\"", "}", ":", "case", "<-", "monitoringCh", ":", "fbo", ".", "editActivity", ".", "Done", "(", ")", "\n", "fbo", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "NewNotificationChannel", "implements", "the", "KBFSOps", "interface", "for", "folderBranchOps", "." ]

[ "func", "encodeReply", "(", "call", "Call", ",", "reply", "Reply", ",", "wr", "io", ".", "Writer", ",", "indent", "bool", ")", "error", "{", "// copy jsonrpc fields from call to reply", "reply", ".", "Jsonrpc", "=", "call", ".", "Jsonrpc", "\n", "reply", ".", "ID", "=", "call", ".", "ID", "\n\n", "enc", ":=", "json", ".", "NewEncoder", "(", "wr", ")", "\n", "if", "indent", "{", "enc", ".", "SetIndent", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "enc", ".", "Encode", "(", "reply", ")", "\n", "}" ]

[ "encodeReply", "JSON", "encodes", "all", "replies", "." ]

[ "func", "unmarshalOptions", "(", "c", "Call", ",", "opts", "Checker", ")", "error", "{", "if", "len", "(", "c", ".", "Params", ".", "Options", ")", "==", "0", "{", "// still check the options in case any fields are required.", "return", "opts", ".", "Check", "(", ")", "\n", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "c", ".", "Params", ".", "Options", ",", "opts", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "opts", ".", "Check", "(", ")", "\n", "}" ]

[ "unmarshalOptions", "unmarshals", "any", "options", "in", "Call", "into", "opts", "and", "verify", "they", "pass", "the", "Checker", "checks", "." ]

[ "func", "(", "c", "DiskBlockCacheClient", ")", "GetBlock", "(", "ctx", "context", ".", "Context", ",", "__arg", "GetBlockArg", ")", "(", "res", "GetBlockRes", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "GetBlock", "gets", "a", "block", "from", "the", "disk", "cache", "." ]

[ "func", "(", "c", "DiskBlockCacheClient", ")", "GetPrefetchStatus", "(", "ctx", "context", ".", "Context", ",", "__arg", "GetPrefetchStatusArg", ")", "(", "res", "PrefetchStatus", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "GetPrefetchStatus", "gets", "the", "prefetch", "status", "from", "the", "disk", "cache", "." ]

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

[ "PutBlock", "puts", "a", "block", "into", "the", "disk", "cache", "." ]

[ "func", "(", "c", "DiskBlockCacheClient", ")", "DeleteBlocks", "(", "ctx", "context", ".", "Context", ",", "blockIDs", "[", "]", "[", "]", "byte", ")", "(", "res", "DeleteBlocksRes", ",", "err", "error", ")", "{", "__arg", ":=", "DeleteBlocksArg", "{", "BlockIDs", ":", "blockIDs", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

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

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

[ "UpdateBlockMetadata", "updates", "the", "metadata", "for", "a", "block", "in", "the", "disk", "cache", "." ]

[ "func", "(", "c", "*", "cmdWalletHistory", ")", "filterNote", "(", "note", "string", ")", "string", "{", "lines", ":=", "strings", ".", "Split", "(", "strings", ".", "TrimSpace", "(", "note", ")", ",", "\"", "\\n", "\"", ")", "\n", "if", "len", "(", "lines", ")", "<", "1", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "strings", ".", "TrimSpace", "(", "lines", "[", "0", "]", ")", "\n", "}" ]

[ "Pare", "down", "the", "note", "so", "that", "it", "s", "less", "likely", "to", "contain", "tricks", ".", "Such", "as", "newlines", "and", "fake", "transactions", ".", "Shows", "only", "the", "first", "line", "." ]

[ "func", "(", "c", "*", "CmdStatus", ")", "execToString", "(", "bin", "string", ",", "args", "[", "]", "string", ")", "(", "string", ",", "error", ")", "{", "result", ",", "err", ":=", "exec", ".", "Command", "(", "bin", ",", "args", "...", ")", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "result", "==", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "strings", ".", "TrimSpace", "(", "string", "(", "result", ")", ")", ",", "nil", "\n", "}" ]

[ "execToString", "returns", "the", "space", "-", "trimmed", "output", "of", "a", "command", "or", "an", "error", "." ]

[ "func", "(", "m", "*", "mounter", ")", "Mount", "(", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "m", ".", "options", ".", "MountPoint", ",", "err", ")", "\n", "fmt", ".", "Println", "(", "msg", ")", "\n", "m", ".", "log", ".", "Warning", "(", "msg", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "m", ".", "c", ",", "err", "=", "fuseMountDir", "(", "m", ".", "options", ".", "MountPoint", ",", "m", ".", "options", ".", "PlatformParams", ")", "\n", "// Exit if we were successful or we are not a force mounting on error.", "// Otherwise, try unmounting and mounting again.", "if", "err", "==", "nil", "||", "!", "m", ".", "options", ".", "ForceMount", "{", "return", "err", "\n", "}", "\n\n", "// Mount failed, let's try to unmount and then try mounting again, even", "// if unmounting errors here.", "m", ".", "Unmount", "(", ")", "\n\n", "// In case we are on darwin, ask the installer to reinstall the mount dir", "// and try again as the last resort. This specifically fixes a situation", "// where /keybase gets created and owned by root after Keybase app is", "// started, and `kbfs` later fails to mount because of a permission error.", "m", ".", "reinstallMountDirIfPossible", "(", ")", "\n", "m", ".", "c", ",", "err", "=", "fuseMountDir", "(", "m", ".", "options", ".", "MountPoint", ",", "m", ".", "options", ".", "PlatformParams", ")", "\n\n", "return", "err", "\n", "}" ]

[ "fuseMount", "tries", "to", "mount", "the", "mountpoint", ".", "On", "a", "force", "mount", "then", "unmount", "re", "-", "mount", "if", "unsuccessful" ]

[ "func", "(", "bg", "*", "realBlockGetter", ")", "getBlock", "(", "ctx", "context", ".", "Context", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "blockPtr", "data", ".", "BlockPointer", ",", "block", "data", ".", "Block", ",", "cacheType", "DiskBlockCacheType", ")", "error", "{", "bserv", ":=", "bg", ".", "config", ".", "BlockServer", "(", ")", "\n", "buf", ",", "blockServerHalf", ",", "err", ":=", "bserv", ".", "Get", "(", "ctx", ",", "kmd", ".", "TlfID", "(", ")", ",", "blockPtr", ".", "ID", ",", "blockPtr", ".", "Context", ",", "cacheType", ")", "\n", "if", "err", "!=", "nil", "{", "// Temporary code to track down bad block", "// requests. Remove when not needed anymore.", "if", "_", ",", "ok", ":=", "err", ".", "(", "kbfsblock", ".", "ServerErrorBadRequest", ")", ";", "ok", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ",", "blockPtr", ")", ")", "\n", "}", "\n\n", "return", "err", "\n", "}", "\n\n", "return", "assembleBlock", "(", "ctx", ",", "bg", ".", "config", ".", "keyGetter", "(", ")", ",", "bg", ".", "config", ".", "Codec", "(", ")", ",", "bg", ".", "config", ".", "cryptoPure", "(", ")", ",", "kmd", ",", "blockPtr", ",", "block", ",", "buf", ",", "blockServerHalf", ")", "\n", "}" ]

[ "getBlock", "implements", "the", "interface", "for", "realBlockGetter", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "forgetLocked", "(", "core", "*", "nodeCore", ")", "{", "ref", ":=", "core", ".", "pathNode", ".", "Ref", "(", ")", "\n\n", "entry", ",", "ok", ":=", "ncs", ".", "nodes", "[", "ref", "]", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n", "if", "entry", ".", "core", "!=", "core", "{", "return", "\n", "}", "\n\n", "entry", ".", "refCount", "--", "\n", "if", "entry", ".", "refCount", "<=", "0", "{", "delete", "(", "ncs", ".", "nodes", ",", "ref", ")", "\n", "}", "\n", "}" ]

[ "lock", "must", "be", "locked", "for", "writing", "by", "the", "caller" ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "newChildForParentLocked", "(", "parent", "Node", ")", "(", "*", "nodeStandard", ",", "error", ")", "{", "nodeStandard", ",", "ok", ":=", "parent", ".", "Unwrap", "(", ")", ".", "(", "*", "nodeStandard", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "ParentNodeNotFoundError", "{", "data", ".", "BlockRef", "{", "}", "}", "\n", "}", "\n\n", "ref", ":=", "nodeStandard", ".", "core", ".", "pathNode", ".", "Ref", "(", ")", "\n", "entry", ",", "ok", ":=", "ncs", ".", "nodes", "[", "ref", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "ParentNodeNotFoundError", "{", "ref", "}", "\n", "}", "\n", "if", "nodeStandard", ".", "core", "!=", "entry", ".", "core", "{", "return", "nil", ",", "ParentNodeNotFoundError", "{", "ref", "}", "\n", "}", "\n", "return", "nodeStandard", ",", "nil", "\n", "}" ]

[ "lock", "must", "be", "held", "for", "writing", "by", "the", "caller" ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "GetOrCreate", "(", "ptr", "data", ".", "BlockPointer", ",", "name", "string", ",", "parent", "Node", ",", "et", "data", ".", "EntryType", ")", "(", "n", "Node", ",", "err", "error", ")", "{", "var", "rootWrappers", "[", "]", "func", "(", "Node", ")", "Node", "\n", "defer", "func", "(", ")", "{", "if", "n", "!=", "nil", "{", "n", "=", "ncs", ".", "wrapNodeStandard", "(", "n", ",", "rootWrappers", ",", "parent", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "if", "!", "ptr", ".", "IsValid", "(", ")", "{", "// Temporary code to track down bad block", "// pointers. Remove when not needed anymore.", "panic", "(", "InvalidBlockRefError", "{", "ptr", ".", "Ref", "(", ")", "}", ")", "\n", "}", "\n\n", "if", "name", "==", "\"", "\"", "{", "return", "nil", ",", "EmptyNameError", "{", "ptr", ".", "Ref", "(", ")", "}", "\n", "}", "\n\n", "ncs", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "Unlock", "(", ")", "\n", "rootWrappers", "=", "ncs", ".", "rootWrappers", "\n", "entry", ",", "ok", ":=", "ncs", ".", "nodes", "[", "ptr", ".", "Ref", "(", ")", "]", "\n", "if", "ok", "{", "// If the entry happens to be unlinked, we may be in a", "// situation where a node got unlinked and then recreated, but", "// someone held onto a node the whole time and so it never got", "// removed from the cache. In that case, forcibly remove it", "// from the cache to make room for the new node.", "if", "parent", "!=", "nil", "&&", "entry", ".", "core", ".", "parent", "==", "nil", "{", "delete", "(", "ncs", ".", "nodes", ",", "ptr", ".", "Ref", "(", ")", ")", "\n", "}", "else", "{", "return", "ncs", ".", "makeNodeStandardForEntryLocked", "(", "entry", ")", ",", "nil", "\n", "}", "\n", "}", "\n\n", "if", "parent", "!=", "nil", "{", "// Make sure a child can be made for this parent.", "_", ",", "err", ":=", "ncs", ".", "newChildForParentLocked", "(", "parent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "entry", "=", "&", "nodeCacheEntry", "{", "core", ":", "newNodeCore", "(", "ptr", ",", "name", ",", "parent", ",", "ncs", ",", "et", ")", ",", "}", "\n", "ncs", ".", "nodes", "[", "ptr", ".", "Ref", "(", ")", "]", "=", "entry", "\n", "return", "ncs", ".", "makeNodeStandardForEntryLocked", "(", "entry", ")", ",", "nil", "\n", "}" ]

[ "GetOrCreate", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "Get", "(", "ref", "data", ".", "BlockRef", ")", "(", "n", "Node", ")", "{", "if", "ref", "==", "(", "data", ".", "BlockRef", "{", "}", ")", "{", "return", "nil", "\n", "}", "\n\n", "// Temporary code to track down bad block pointers. Remove (or", "// return an error) when not needed anymore.", "if", "!", "ref", ".", "IsValid", "(", ")", "{", "panic", "(", "InvalidBlockRefError", "{", "ref", "}", ")", "\n", "}", "\n\n", "var", "rootWrappers", "[", "]", "func", "(", "Node", ")", "Node", "\n", "var", "parent", "Node", "\n", "defer", "func", "(", ")", "{", "if", "n", "!=", "nil", "{", "n", "=", "ncs", ".", "wrapNodeStandard", "(", "n", ",", "rootWrappers", ",", "parent", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "ncs", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "Unlock", "(", ")", "\n", "rootWrappers", "=", "ncs", ".", "rootWrappers", "\n", "entry", ",", "ok", ":=", "ncs", ".", "nodes", "[", "ref", "]", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "ns", ":=", "ncs", ".", "makeNodeStandardForEntryLocked", "(", "entry", ")", "\n", "parent", "=", "ns", ".", "core", ".", "parent", "// get while under lock", "\n", "return", "ns", "\n", "}" ]

[ "Get", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "UpdatePointer", "(", "oldRef", "data", ".", "BlockRef", ",", "newPtr", "data", ".", "BlockPointer", ")", "(", "updatedNode", "NodeID", ")", "{", "if", "oldRef", "==", "(", "data", ".", "BlockRef", "{", "}", ")", "&&", "newPtr", "==", "(", "data", ".", "BlockPointer", "{", "}", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "!", "oldRef", ".", "IsValid", "(", ")", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "oldRef", ",", "newPtr", ")", ")", "\n", "}", "\n\n", "if", "!", "newPtr", ".", "IsValid", "(", ")", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "newPtr", ",", "oldRef", ")", ")", "\n", "}", "\n\n", "ncs", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "Unlock", "(", ")", "\n", "entry", ",", "ok", ":=", "ncs", ".", "nodes", "[", "oldRef", "]", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n\n", "// Cannot update the pointer for an unlinked node.", "if", "entry", ".", "core", ".", "cachedPath", ".", "IsValid", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "entry", ".", "core", ".", "pathNode", ".", "BlockPointer", "=", "newPtr", "\n", "delete", "(", "ncs", ".", "nodes", ",", "oldRef", ")", "\n", "ncs", ".", "nodes", "[", "newPtr", ".", "Ref", "(", ")", "]", "=", "entry", "\n", "return", "entry", ".", "core", "\n", "}" ]

[ "UpdatePointer", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "Move", "(", "ref", "data", ".", "BlockRef", ",", "newParent", "Node", ",", "newName", "string", ")", "(", "undoFn", "func", "(", ")", ",", "err", "error", ")", "{", "if", "ref", "==", "(", "data", ".", "BlockRef", "{", "}", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Temporary code to track down bad block pointers. Remove (or", "// return an error) when not needed anymore.", "if", "!", "ref", ".", "IsValid", "(", ")", "{", "panic", "(", "InvalidBlockRefError", "{", "ref", "}", ")", "\n", "}", "\n\n", "if", "newName", "==", "\"", "\"", "{", "return", "nil", ",", "EmptyNameError", "{", "ref", "}", "\n", "}", "\n\n", "ncs", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "Unlock", "(", ")", "\n", "entry", ",", "ok", ":=", "ncs", ".", "nodes", "[", "ref", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "newParentNS", ",", "err", ":=", "ncs", ".", "newChildForParentLocked", "(", "newParent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "oldParent", ":=", "entry", ".", "core", ".", "parent", "\n", "oldName", ":=", "entry", ".", "core", ".", "pathNode", ".", "Name", "\n\n", "entry", ".", "core", ".", "parent", "=", "newParentNS", "\n", "entry", ".", "core", ".", "pathNode", ".", "Name", "=", "newName", "\n\n", "return", "func", "(", ")", "{", "entry", ".", "core", ".", "parent", "=", "oldParent", "\n", "entry", ".", "core", ".", "pathNode", ".", "Name", "=", "oldName", "\n", "}", ",", "nil", "\n", "}" ]

[ "Move", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "Unlink", "(", "ref", "data", ".", "BlockRef", ",", "oldPath", "data", ".", "Path", ",", "oldDe", "data", ".", "DirEntry", ")", "(", "undoFn", "func", "(", ")", ")", "{", "if", "ref", "==", "(", "data", ".", "BlockRef", "{", "}", ")", "{", "return", "nil", "\n", "}", "\n\n", "// Temporary code to track down bad block pointers. Remove (or", "// return an error) when not needed anymore.", "if", "!", "ref", ".", "IsValid", "(", ")", "{", "panic", "(", "InvalidBlockRefError", "{", "ref", "}", ")", "\n", "}", "\n\n", "ncs", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "Unlock", "(", ")", "\n", "entry", ",", "ok", ":=", "ncs", ".", "nodes", "[", "ref", "]", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n\n", "if", "entry", ".", "core", ".", "cachedPath", ".", "IsValid", "(", ")", "{", "// Already unlinked!", "return", "nil", "\n", "}", "\n\n", "oldParent", ":=", "entry", ".", "core", ".", "parent", "\n", "oldName", ":=", "entry", ".", "core", ".", "pathNode", ".", "Name", "\n\n", "entry", ".", "core", ".", "cachedPath", "=", "oldPath", "\n", "entry", ".", "core", ".", "cachedDe", "=", "oldDe", "\n", "entry", ".", "core", ".", "parent", "=", "nil", "\n", "entry", ".", "core", ".", "pathNode", ".", "Name", "=", "\"", "\"", "\n\n", "return", "func", "(", ")", "{", "entry", ".", "core", ".", "cachedPath", "=", "data", ".", "Path", "{", "}", "\n", "entry", ".", "core", ".", "cachedDe", "=", "data", ".", "DirEntry", "{", "}", "\n", "entry", ".", "core", ".", "parent", "=", "oldParent", "\n", "entry", ".", "core", ".", "pathNode", ".", "Name", "=", "oldName", "\n", "}", "\n", "}" ]

[ "Unlink", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "IsUnlinked", "(", "node", "Node", ")", "bool", "{", "ncs", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "ns", ",", "ok", ":=", "node", ".", "Unwrap", "(", ")", ".", "(", "*", "nodeStandard", ")", "\n", "if", "!", "ok", "{", "return", "false", "\n", "}", "\n\n", "return", "ns", ".", "core", ".", "cachedPath", ".", "IsValid", "(", ")", "\n", "}" ]

[ "IsUnlinked", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "UnlinkedDirEntry", "(", "node", "Node", ")", "data", ".", "DirEntry", "{", "ncs", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "ns", ",", "ok", ":=", "node", ".", "Unwrap", "(", ")", ".", "(", "*", "nodeStandard", ")", "\n", "if", "!", "ok", "{", "return", "data", ".", "DirEntry", "{", "}", "\n", "}", "\n\n", "return", "ns", ".", "core", ".", "cachedDe", "\n", "}" ]

[ "UnlinkedDirEntry", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "UpdateUnlinkedDirEntry", "(", "node", "Node", ",", "newDe", "data", ".", "DirEntry", ")", "{", "ncs", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "ns", ",", "ok", ":=", "node", ".", "Unwrap", "(", ")", ".", "(", "*", "nodeStandard", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n\n", "ns", ".", "core", ".", "cachedDe", "=", "newDe", "\n", "}" ]

[ "UpdateUnlinkedDirEntry", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "PathFromNode", "(", "node", "Node", ")", "(", "p", "data", ".", "Path", ")", "{", "ncs", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "ns", ",", "ok", ":=", "node", ".", "Unwrap", "(", ")", ".", "(", "*", "nodeStandard", ")", "\n", "if", "!", "ok", "{", "p", ".", "Path", "=", "nil", "\n", "return", "\n", "}", "\n\n", "for", "ns", "!=", "nil", "{", "core", ":=", "ns", ".", "core", "\n", "if", "core", ".", "parent", "==", "nil", "&&", "len", "(", "core", ".", "cachedPath", ".", "Path", ")", ">", "0", "{", "// The node was unlinked, but is still in use, so use its", "// cached path. The path is already reversed, so append", "// it backwards one-by-one to the existing path. If this", "// is the first node, we can just optimize by returning", "// the complete cached path.", "if", "len", "(", "p", ".", "Path", ")", "==", "0", "{", "return", "core", ".", "cachedPath", "\n", "}", "\n", "for", "i", ":=", "len", "(", "core", ".", "cachedPath", ".", "Path", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "p", ".", "Path", "=", "append", "(", "p", ".", "Path", ",", "core", ".", "cachedPath", ".", "Path", "[", "i", "]", ")", "\n", "}", "\n", "break", "\n", "}", "\n\n", "p", ".", "Path", "=", "append", "(", "p", ".", "Path", ",", "*", "core", ".", "pathNode", ")", "\n", "if", "core", ".", "parent", "!=", "nil", "{", "ns", "=", "core", ".", "parent", ".", "Unwrap", "(", ")", ".", "(", "*", "nodeStandard", ")", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n\n", "// need to reverse the path nodes", "for", "i", ":=", "len", "(", "p", ".", "Path", ")", "/", "2", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "opp", ":=", "len", "(", "p", ".", "Path", ")", "-", "1", "-", "i", "\n", "p", ".", "Path", "[", "i", "]", ",", "p", ".", "Path", "[", "opp", "]", "=", "p", ".", "Path", "[", "opp", "]", ",", "p", ".", "Path", "[", "i", "]", "\n", "}", "\n\n", "// TODO: would it make any sense to cache the constructed path?", "p", ".", "FolderBranch", "=", "ncs", ".", "folderBranch", "\n", "return", "\n", "}" ]

[ "PathFromNode", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "AllNodes", "(", ")", "(", "nodes", "[", "]", "Node", ")", "{", "ncs", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "RUnlock", "(", ")", "\n", "nodes", "=", "make", "(", "[", "]", "Node", ",", "0", ",", "len", "(", "ncs", ".", "nodes", ")", ")", "\n", "for", "_", ",", "entry", ":=", "range", "ncs", ".", "nodes", "{", "nodes", "=", "append", "(", "nodes", ",", "ncs", ".", "makeNodeStandardForEntryLocked", "(", "entry", ")", ")", "\n", "}", "\n", "return", "nodes", "\n", "}" ]

[ "AllNodes", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "(", "ncs", "*", "nodeCacheStandard", ")", "AllNodeChildren", "(", "n", "Node", ")", "(", "nodes", "[", "]", "Node", ")", "{", "ncs", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "ncs", ".", "lock", ".", "RUnlock", "(", ")", "\n", "nodes", "=", "make", "(", "[", "]", "Node", ",", "0", ",", "len", "(", "ncs", ".", "nodes", ")", ")", "\n", "entryIDs", ":=", "make", "(", "map", "[", "NodeID", "]", "bool", ")", "\n", "for", "_", ",", "entry", ":=", "range", "ncs", ".", "nodes", "{", "var", "pathIDs", "[", "]", "NodeID", "\n", "parent", ":=", "entry", ".", "core", ".", "parent", "\n", "for", "parent", "!=", "nil", "{", "// If the node's parent is what we're looking for (or on", "// the path to what we're looking for), include it in the", "// list.", "parentID", ":=", "parent", ".", "GetID", "(", ")", "\n", "if", "parentID", "==", "n", ".", "GetID", "(", ")", "||", "entryIDs", "[", "parentID", "]", "{", "nodes", "=", "append", "(", "nodes", ",", "ncs", ".", "makeNodeStandardForEntryLocked", "(", "entry", ")", ")", "\n", "for", "_", ",", "id", ":=", "range", "pathIDs", "{", "entryIDs", "[", "id", "]", "=", "true", "\n", "}", "\n", "entryIDs", "[", "entry", ".", "core", "]", "=", "true", "\n", "break", "\n", "}", "\n\n", "// Otherwise, remember this parent and continue back", "// toward the root.", "pathIDs", "=", "append", "(", "pathIDs", ",", "parentID", ")", "\n", "ns", ",", "ok", ":=", "parent", ".", "Unwrap", "(", ")", ".", "(", "*", "nodeStandard", ")", "\n", "if", "!", "ok", "{", "break", "\n", "}", "\n", "parent", "=", "ns", ".", "core", ".", "parent", "\n", "}", "\n", "}", "\n", "return", "nodes", "\n", "}" ]

[ "AllNodeChildren", "implements", "the", "NodeCache", "interface", "for", "nodeCacheStandard", "." ]

[ "func", "IsWriter", "(", "ctx", "context", ".", "Context", ",", "kbpki", "libkbfs", ".", "KBPKI", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "h", "*", "tlfhandle", ".", "Handle", ")", "(", "bool", ",", "error", ")", "{", "session", ",", "err", ":=", "idutil", ".", "GetCurrentSessionIfPossible", "(", "ctx", ",", "kbpki", ",", "h", ".", "Type", "(", ")", "==", "tlf", ".", "Public", ")", "\n", "// We are using GetCurrentUserInfoIfPossible here so err is only non-nil if", "// a real problem happened. If the user is logged out, we will get an empty", "// username and uid, with a nil error.", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "h", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "tid", ",", "err", ":=", "h", ".", "FirstResolvedWriter", "(", ")", ".", "AsTeam", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "offline", ":=", "keybase1", ".", "OfflineAvailability_NONE", "\n", "if", "osg", "!=", "nil", "{", "offline", "=", "osg", ".", "OfflineAvailabilityForID", "(", "h", ".", "TlfID", "(", ")", ")", "\n", "}", "\n", "isWriter", ",", "err", ":=", "kbpki", ".", "IsTeamWriter", "(", "ctx", ",", "tid", ",", "session", ".", "UID", ",", "session", ".", "VerifyingKey", ",", "offline", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "isWriter", ",", "nil", "\n", "}", "\n", "return", "h", ".", "IsWriter", "(", "session", ".", "UID", ")", ",", "nil", "\n", "}" ]

[ "IsWriter", "returns", "whether", "or", "not", "the", "currently", "logged", "-", "in", "user", "is", "a", "valid", "writer", "for", "the", "folder", "described", "by", "h", "." ]

[ "func", "WritePermMode", "(", "ctx", "context", ".", "Context", ",", "node", "libkbfs", ".", "Node", ",", "original", "os", ".", "FileMode", ",", "kbpki", "libkbfs", ".", "KBPKI", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "h", "*", "tlfhandle", ".", "Handle", ")", "(", "os", ".", "FileMode", ",", "error", ")", "{", "original", "&^=", "os", ".", "FileMode", "(", "0222", ")", "// clear write perm bits", "\n\n", "if", "node", "!=", "nil", "&&", "node", ".", "Readonly", "(", "ctx", ")", "{", "return", "original", ",", "nil", "\n", "}", "\n\n", "isWriter", ",", "err", ":=", "IsWriter", "(", "ctx", ",", "kbpki", ",", "osg", ",", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "isWriter", "{", "original", "|=", "0200", "\n", "}", "\n\n", "return", "original", ",", "nil", "\n", "}" ]

[ "WritePermMode", "fills", "in", "original", "based", "on", "whether", "or", "not", "the", "currently", "logged", "-", "in", "user", "is", "a", "valid", "writer", "for", "the", "folder", "described", "by", "h", "." ]

[ "func", "(", "j", "journalMDOps", ")", "convertImmutableBareRMDToIRMD", "(", "ctx", "context", ".", "Context", ",", "ibrmd", "ImmutableBareRootMetadata", ",", "handle", "*", "tlfhandle", ".", "Handle", ",", "uid", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "VerifyingKey", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "// TODO: Avoid having to do this type assertion.", "brmd", ",", "ok", ":=", "ibrmd", ".", "RootMetadata", ".", "(", "kbfsmd", ".", "MutableRootMetadata", ")", "\n", "if", "!", "ok", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "kbfsmd", ".", "MutableRootMetadataNoImplError", "{", "}", "\n", "}", "\n\n", "rmd", ":=", "makeRootMetadata", "(", "brmd", ",", "ibrmd", ".", "extra", ",", "handle", ")", "\n\n", "config", ":=", "j", ".", "jManager", ".", "config", "\n", "pmd", ",", "err", ":=", "decryptMDPrivateData", "(", "ctx", ",", "config", ".", "Codec", "(", ")", ",", "config", ".", "Crypto", "(", ")", ",", "config", ".", "BlockCache", "(", ")", ",", "config", ".", "BlockOps", "(", ")", ",", "config", ".", "KeyManager", "(", ")", ",", "config", ".", "KBPKI", "(", ")", ",", "config", ",", "config", ".", "Mode", "(", ")", ",", "uid", ",", "rmd", ".", "GetSerializedPrivateMetadata", "(", ")", ",", "rmd", ",", "rmd", ",", "j", ".", "jManager", ".", "log", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "rmd", ".", "data", "=", "pmd", "\n", "irmd", ":=", "MakeImmutableRootMetadata", "(", "rmd", ",", "key", ",", "ibrmd", ".", "mdID", ",", "ibrmd", ".", "localTimestamp", ",", "false", ")", "\n", "return", "irmd", ",", "nil", "\n", "}" ]

[ "convertImmutableBareRMDToIRMD", "decrypts", "the", "bare", "MD", "into", "a", "full", "-", "fledged", "RMD", ".", "The", "MD", "is", "assumed", "to", "have", "been", "read", "from", "the", "journal", "." ]

[ "func", "(", "j", "journalMDOps", ")", "GetIDForHandle", "(", "ctx", "context", ".", "Context", ",", "handle", "*", "tlfhandle", ".", "Handle", ")", "(", "id", "tlf", ".", "ID", ",", "err", "error", ")", "{", "id", ",", "err", "=", "j", ".", "MDOps", ".", "GetIDForHandle", "(", "ctx", ",", "handle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "NullID", ",", "err", "\n", "}", "\n", "if", "id", "==", "tlf", ".", "NullID", "{", "return", "id", ",", "nil", "\n", "}", "\n", "// Create the journal if needed, while we have access to `handle`.", "_", ",", "_", "=", "j", ".", "jManager", ".", "getTLFJournal", "(", "id", ",", "handle", ")", "\n", "return", "id", ",", "nil", "\n", "}" ]

[ "GetIDForHandle", "implements", "the", "MDOps", "interface", "for", "journalMDOps", "." ]

[ "func", "(", "u", "*", "User", ")", "GetActivePGPKeys", "(", "sibkey", "bool", ")", "(", "ret", "[", "]", "*", "PGPKeyBundle", ")", "{", "if", "ckf", ":=", "u", ".", "GetComputedKeyFamily", "(", ")", ";", "ckf", "!=", "nil", "{", "ret", "=", "ckf", ".", "GetActivePGPKeys", "(", "sibkey", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "GetActivePGPKeys", "looks", "into", "the", "user", "s", "ComputedKeyFamily", "and", "returns", "only", "the", "active", "PGP", "keys", ".", "If", "you", "want", "only", "sibkeys", "then", "specify", "sibkey", "=", "true", "." ]

[ "func", "(", "u", "*", "User", ")", "FilterActivePGPKeys", "(", "sibkey", "bool", ",", "query", "string", ")", "[", "]", "*", "PGPKeyBundle", "{", "keys", ":=", "u", ".", "GetActivePGPKeys", "(", "sibkey", ")", "\n", "var", "res", "[", "]", "*", "PGPKeyBundle", "\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "if", "KeyMatchesQuery", "(", "k", ",", "query", ",", "false", ")", "{", "res", "=", "append", "(", "res", ",", "k", ")", "\n", "}", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "FilterActivePGPKeys", "returns", "the", "active", "pgp", "keys", "that", "match", "query", "." ]

[ "func", "(", "u", "*", "User", ")", "AllSyncedSecretKeys", "(", "m", "MetaContext", ")", "(", "keys", "[", "]", "*", "SKB", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "m", ".", "Dump", "(", ")", "\n\n", "ss", ",", "err", ":=", "m", ".", "SyncSecretsForUID", "(", "u", ".", "GetUID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ckf", ":=", "u", ".", "GetComputedKeyFamily", "(", ")", "\n", "if", "ckf", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n\n", "keys", "=", "ss", ".", "AllActiveKeys", "(", "ckf", ")", "\n", "return", "keys", ",", "nil", "\n", "}" ]

[ "AllSyncedSecretKeys", "returns", "all", "the", "PGP", "key", "blocks", "that", "were", "synced", "to", "API", "server", ".", "LoginContext", "can", "be", "nil", "if", "this", "isn", "t", "used", "while", "logging", "in", "signing", "up", "." ]

[ "func", "(", "u", "*", "User", ")", "GetHighLinkSeqnos", "(", "mctx", "MetaContext", ")", "(", "res", "[", "]", "keybase1", ".", "Seqno", ",", "err", "error", ")", "{", "sigChain", ":=", "u", ".", "sigChain", "(", ")", "\n", "if", "sigChain", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "c", ":=", "range", "sigChain", ".", "chainLinks", "{", "high", ",", "err", ":=", "c", ".", "IsHighUserLink", "(", "mctx", ",", "u", ".", "GetUID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "GetSeqno", "(", ")", ")", "\n", "}", "\n", "if", "high", "{", "res", "=", "append", "(", "res", ",", "c", ".", "GetSeqno", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "GetHighLinkSeqnos", "gets", "the", "list", "of", "all", "high", "links", "in", "the", "user", "s", "sigchain", "ascending", "." ]

[ "func", "(", "u", "*", "User", ")", "localDelegateKey", "(", "key", "GenericKey", ",", "sigID", "keybase1", ".", "SigID", ",", "kid", "keybase1", ".", "KID", ",", "isSibkey", "bool", ",", "isEldest", "bool", ",", "merkleHashMeta", "keybase1", ".", "HashMeta", ",", "firstAppearedUnverified", "keybase1", ".", "Seqno", ")", "(", "err", "error", ")", "{", "if", "err", "=", "u", ".", "keyFamily", ".", "LocalDelegate", "(", "key", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "u", ".", "sigChain", "(", ")", "==", "nil", "{", "err", "=", "NoSigChainError", "{", "}", "\n", "return", "\n", "}", "\n", "err", "=", "u", ".", "sigChain", "(", ")", ".", "LocalDelegate", "(", "u", ".", "keyFamily", ",", "key", ",", "sigID", ",", "kid", ",", "isSibkey", ",", "merkleHashMeta", ",", "firstAppearedUnverified", ")", "\n", "if", "isEldest", "{", "eldestKID", ":=", "key", ".", "GetKID", "(", ")", "\n", "u", ".", "leaf", ".", "eldest", "=", "eldestKID", "\n", "}", "\n", "return", "\n", "}" ]

[ "localDelegateKey", "takes", "the", "given", "GenericKey", "and", "provisions", "it", "locally", "so", "that", "we", "can", "use", "the", "key", "without", "needing", "a", "refresh", "from", "the", "server", ".", "The", "eventual", "refresh", "we", "do", "get", "from", "the", "server", "will", "clobber", "our", "work", "here", "." ]

[ "func", "(", "u", "*", "User", ")", "SigChainBump", "(", "linkID", "LinkID", ",", "sigID", "keybase1", ".", "SigID", ",", "isHighDelegator", "bool", ")", "{", "u", ".", "SigChainBumpMT", "(", "MerkleTriple", "{", "LinkID", ":", "linkID", ",", "SigID", ":", "sigID", "}", ",", "isHighDelegator", ")", "\n", "}" ]

[ "SigChainBump", "is", "called", "during", "a", "multikey", "post", "to", "update", "the", "correct", "seqno", "hash", "and", "high", "skip", ".", "When", "a", "delegator", "posts", "a", "high", "link", "they", "specify", "isHighDelegator", "=", "true", "in", "order", "to", "set", "the", "new", "high", "skip", "pointer", "to", "the", "delegator", "s", "link", "so", "subsequent", "keys", "in", "the", "multikey", "will", "supply", "the", "correct", "high", "skip", "." ]

[ "func", "(", "u", "*", "User", ")", "HasDeviceInCurrentInstall", "(", "did", "keybase1", ".", "DeviceID", ")", "bool", "{", "ckf", ":=", "u", ".", "GetComputedKeyFamily", "(", ")", "\n", "if", "ckf", "==", "nil", "{", "return", "false", "\n", "}", "\n\n", "_", ",", "err", ":=", "ckf", ".", "GetSibkeyForDevice", "(", "did", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Returns", "whether", "or", "not", "the", "current", "install", "has", "an", "active", "device", "sibkey", "." ]

[ "func", "(", "u", "User", ")", "PartialCopy", "(", ")", "*", "User", "{", "ret", ":=", "&", "User", "{", "Contextified", ":", "NewContextified", "(", "u", ".", "G", "(", ")", ")", ",", "id", ":", "u", ".", "id", ",", "name", ":", "u", ".", "name", ",", "leaf", ":", "u", ".", "leaf", ",", "dirty", ":", "false", ",", "}", "\n", "if", "ckf", ":=", "u", ".", "GetComputedKeyFamily", "(", ")", ";", "ckf", "!=", "nil", "{", "ret", ".", "ckfShallowCopy", "=", "ckf", ".", "ShallowCopy", "(", ")", "\n", "ret", ".", "keyFamily", "=", "ckf", ".", "kf", "\n", "}", "else", "if", "u", ".", "keyFamily", "!=", "nil", "{", "ret", ".", "keyFamily", "=", "u", ".", "keyFamily", ".", "ShallowCopy", "(", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "PartialCopy", "copies", "some", "fields", "of", "the", "User", "object", "but", "not", "all", ".", "For", "instance", "it", "doesn", "t", "copy", "the", "SigChain", "or", "IDTable", "and", "it", "only", "makes", "a", "shallow", "copy", "of", "the", "ComputedKeyFamily", "." ]

[ "func", "(", "c", "IdentifyClient", ")", "ResolveImplicitTeam", "(", "ctx", "context", ".", "Context", ",", "__arg", "ResolveImplicitTeamArg", ")", "(", "res", "Folder", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "resolveImplicitTeam", "returns", "a", "TLF", "display", "name", "given", "a", "teamID", ".", "The", "publicness", "of", "the", "team", "is", "inferred", "from", "the", "TeamID", "." ]

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

[ "This", "is", "a", "devel", "-", "only", "cmd", "which", "can", "be", "used", "to", "see", "how", "long", "different", "g", ".", "CTraceTimed", "calls", "are", "taking", "." ]

[ "func", "NewKeybaseServiceMeasured", "(", "delegate", "KeybaseService", ",", "r", "metrics", ".", "Registry", ")", "KeybaseServiceMeasured", "{", "resolveTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "identifyTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "normalizeSocialAssertionTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "resolveIdentifyImplicitTeamTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "resolveImplicitTeamByIDTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "loadUserPlusKeysTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "loadTeamPlusKeysTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "createTeamTLFTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "getTeamSettingsTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "getCurrentMerkleRootTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "verifyMerkleRootTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "currentSessionTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "favoriteAddTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "favoriteDeleteTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "favoriteListTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "encryptFavoritesTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", "+", "\"", "\"", ",", "r", ")", "\n", "decryptFavoritesTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", "+", "\"", "\"", ",", "r", ")", "\n", "notifyTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "notifyPathUpdatedTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "putGitMetadataTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "return", "KeybaseServiceMeasured", "{", "delegate", ":", "delegate", ",", "resolveTimer", ":", "resolveTimer", ",", "identifyTimer", ":", "identifyTimer", ",", "normalizeSocialAssertionTimer", ":", "normalizeSocialAssertionTimer", ",", "resolveIdentifyImplicitTeamTimer", ":", "resolveIdentifyImplicitTeamTimer", ",", "resolveImplicitTeamByIDTimer", ":", "resolveImplicitTeamByIDTimer", ",", "loadUserPlusKeysTimer", ":", "loadUserPlusKeysTimer", ",", "loadTeamPlusKeysTimer", ":", "loadTeamPlusKeysTimer", ",", "createTeamTLFTimer", ":", "createTeamTLFTimer", ",", "getTeamSettingsTimer", ":", "getTeamSettingsTimer", ",", "getCurrentMerkleRootTimer", ":", "getCurrentMerkleRootTimer", ",", "verifyMerkleRootTimer", ":", "verifyMerkleRootTimer", ",", "currentSessionTimer", ":", "currentSessionTimer", ",", "favoriteAddTimer", ":", "favoriteAddTimer", ",", "favoriteDeleteTimer", ":", "favoriteDeleteTimer", ",", "favoriteListTimer", ":", "favoriteListTimer", ",", "encryptFavoritesTimer", ":", "encryptFavoritesTimer", ",", "decryptFavoritesTimer", ":", "decryptFavoritesTimer", ",", "notifyTimer", ":", "notifyTimer", ",", "notifyPathUpdatedTimer", ":", "notifyPathUpdatedTimer", ",", "putGitMetadataTimer", ":", "putGitMetadataTimer", ",", "}", "\n", "}" ]

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

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "Resolve", "(", "ctx", "context", ".", "Context", ",", "assertion", "string", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "name", "kbname", ".", "NormalizedUsername", ",", "uid", "keybase1", ".", "UserOrTeamID", ",", "err", "error", ")", "{", "k", ".", "resolveTimer", ".", "Time", "(", "func", "(", ")", "{", "name", ",", "uid", ",", "err", "=", "k", ".", "delegate", ".", "Resolve", "(", "ctx", ",", "assertion", ",", "offline", ")", "\n", "}", ")", "\n", "return", "name", ",", "uid", ",", "err", "\n", "}" ]

[ "Resolve", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "Identify", "(", "ctx", "context", ".", "Context", ",", "assertion", ",", "reason", "string", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "name", "kbname", ".", "NormalizedUsername", ",", "id", "keybase1", ".", "UserOrTeamID", ",", "err", "error", ")", "{", "k", ".", "identifyTimer", ".", "Time", "(", "func", "(", ")", "{", "name", ",", "id", ",", "err", "=", "k", ".", "delegate", ".", "Identify", "(", "ctx", ",", "assertion", ",", "reason", ",", "offline", ")", "\n", "}", ")", "\n", "return", "name", ",", "id", ",", "err", "\n", "}" ]

[ "Identify", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "NormalizeSocialAssertion", "(", "ctx", "context", ".", "Context", ",", "assertion", "string", ")", "(", "res", "keybase1", ".", "SocialAssertion", ",", "err", "error", ")", "{", "k", ".", "normalizeSocialAssertionTimer", ".", "Time", "(", "func", "(", ")", "{", "res", ",", "err", "=", "k", ".", "delegate", ".", "NormalizeSocialAssertion", "(", "ctx", ",", "assertion", ")", "\n", "}", ")", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "NormalizeSocialAssertion", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "ResolveIdentifyImplicitTeam", "(", "ctx", "context", ".", "Context", ",", "assertions", ",", "suffix", "string", ",", "tlfType", "tlf", ".", "Type", ",", "doIdentifies", "bool", ",", "reason", "string", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "info", "idutil", ".", "ImplicitTeamInfo", ",", "err", "error", ")", "{", "k", ".", "resolveIdentifyImplicitTeamTimer", ".", "Time", "(", "func", "(", ")", "{", "info", ",", "err", "=", "k", ".", "delegate", ".", "ResolveIdentifyImplicitTeam", "(", "ctx", ",", "assertions", ",", "suffix", ",", "tlfType", ",", "doIdentifies", ",", "reason", ",", "offline", ")", "\n", "}", ")", "\n", "return", "info", ",", "err", "\n", "}" ]

[ "ResolveIdentifyImplicitTeam", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "ResolveImplicitTeamByID", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ")", "(", "name", "string", ",", "err", "error", ")", "{", "k", ".", "resolveImplicitTeamByIDTimer", ".", "Time", "(", "func", "(", ")", "{", "name", ",", "err", "=", "k", ".", "delegate", ".", "ResolveImplicitTeamByID", "(", "ctx", ",", "teamID", ")", "\n", "}", ")", "\n", "return", "name", ",", "err", "\n", "}" ]

[ "ResolveImplicitTeamByID", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "LoadUserPlusKeys", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "pollForKID", "keybase1", ".", "KID", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "userInfo", "idutil", ".", "UserInfo", ",", "err", "error", ")", "{", "k", ".", "loadUserPlusKeysTimer", ".", "Time", "(", "func", "(", ")", "{", "userInfo", ",", "err", "=", "k", ".", "delegate", ".", "LoadUserPlusKeys", "(", "ctx", ",", "uid", ",", "pollForKID", ",", "offline", ")", "\n", "}", ")", "\n", "return", "userInfo", ",", "err", "\n", "}" ]

[ "LoadUserPlusKeys", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]

[ "func", "(", "k", "KeybaseServiceMeasured", ")", "LoadTeamPlusKeys", "(", "ctx", "context", ".", "Context", ",", "tid", "keybase1", ".", "TeamID", ",", "tlfType", "tlf", ".", "Type", ",", "desiredKeyGen", "kbfsmd", ".", "KeyGen", ",", "desiredUser", "keybase1", ".", "UserVersion", ",", "desiredKey", "kbfscrypto", ".", "VerifyingKey", ",", "desiredRole", "keybase1", ".", "TeamRole", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "teamInfo", "idutil", ".", "TeamInfo", ",", "err", "error", ")", "{", "k", ".", "loadTeamPlusKeysTimer", ".", "Time", "(", "func", "(", ")", "{", "teamInfo", ",", "err", "=", "k", ".", "delegate", ".", "LoadTeamPlusKeys", "(", "ctx", ",", "tid", ",", "tlfType", ",", "desiredKeyGen", ",", "desiredUser", ",", "desiredKey", ",", "desiredRole", ",", "offline", ")", "\n", "}", ")", "\n", "return", "teamInfo", ",", "err", "\n", "}" ]

[ "LoadTeamPlusKeys", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceMeasured", "." ]