Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "(", "e", "*", "loginProvision", ")", "syncedPGPKey", "(", "m", "libkb", ".", "MetaContext", ")", "(", "ret", "libkb", ".", "GenericKey", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "key", ",", "err", ":=", "e", ".", "arg", ".", "User", ".", "SyncedSecretKey", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "key", "==", "nil", "{", "return", "nil", ",", "libkb", ".", "NoSyncedPGPKeyError", "{", "}", "\n", "}", "\n\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// unlock it", "// XXX improve this prompt", "parg", ":=", "m", ".", "SecretKeyPromptArg", "(", "libkb", ".", "SecretKeyArg", "{", "}", ",", "\"", "\"", ")", "\n", "unlocked", ",", "err", ":=", "key", ".", "PromptAndUnlock", "(", "m", ",", "parg", ",", "nil", ",", "e", ".", "arg", ".", "User", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "unlocked", ",", "nil", "\n", "}" ]

[ "syncedPGPKey", "looks", "for", "a", "synced", "pgp", "key", "for", "e", ".", "user", ".", "If", "found", "it", "unlocks", "it", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "gpgPrivateIndex", "(", "m", "libkb", ".", "MetaContext", ")", "(", "*", "libkb", ".", "GpgKeyIndex", ",", "error", ")", "{", "cli", ",", "err", ":=", "e", ".", "gpgClient", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// get an index of all the secret keys", "index", ",", "_", ",", "err", ":=", "cli", ".", "Index", "(", "true", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "index", ",", "nil", "\n", "}" ]

[ "gpgPrivateIndex", "returns", "an", "index", "of", "the", "private", "gpg", "keys", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "gpgClient", "(", "m", "libkb", ".", "MetaContext", ")", "(", "gpgInterface", ",", "error", ")", "{", "if", "e", ".", "arg", ".", "DeviceType", "==", "libkb", ".", "DeviceTypeMobile", "{", "return", "nil", ",", "libkb", ".", "GPGUnavailableError", "{", "}", "\n", "}", "\n", "if", "e", ".", "gpgCli", "!=", "nil", "{", "return", "e", ".", "gpgCli", ",", "nil", "\n", "}", "\n\n", "gpg", ":=", "m", ".", "G", "(", ")", ".", "GetGpgClient", "(", ")", "\n", "ok", ",", "err", ":=", "gpg", ".", "CanExec", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "!", "ok", "{", "return", "nil", ",", "libkb", ".", "GPGUnavailableError", "{", "}", "\n", "}", "\n", "e", ".", "gpgCli", "=", "gpg", "\n", "return", "e", ".", "gpgCli", ",", "nil", "\n", "}" ]

[ "gpgClient", "returns", "a", "gpg", "client", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "checkArg", "(", ")", "error", "{", "// check we have a good device type:", "if", "e", ".", "arg", ".", "DeviceType", "!=", "libkb", ".", "DeviceTypeDesktop", "&&", "e", ".", "arg", ".", "DeviceType", "!=", "libkb", ".", "DeviceTypeMobile", "{", "return", "libkb", ".", "InvalidArgumentError", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "libkb", ".", "DeviceTypeDesktop", ",", "libkb", ".", "DeviceTypeMobile", ",", "e", ".", "arg", ".", "DeviceType", ")", "}", "\n", "}", "\n\n", "if", "e", ".", "arg", ".", "User", "==", "nil", "{", "return", "libkb", ".", "InvalidArgumentError", "{", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkArg", "checks", "loginProvisionArg", "for", "sane", "arguments", "." ]

[ "func", "getPaperKey", "(", "m", "libkb", ".", "MetaContext", ",", "lastErr", "error", ",", "expectedPrefix", "*", "string", ")", "(", "keys", "*", "libkb", ".", "DeviceWithKeys", ",", "prefix", "string", ",", "err", "error", ")", "{", "passphrase", ",", "err", ":=", "libkb", ".", "GetPaperKeyPassphrase", "(", "m", ",", "m", ".", "UIs", "(", ")", ".", "SecretUI", ",", "\"", "\"", ",", "lastErr", ",", "expectedPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "getPaperKeyFromString", "(", "m", ",", "passphrase", ")", "\n", "}" ]

[ "This", "is", "used", "by", "SaltpackDecrypt", "as", "well", "." ]

[ "func", "NewLoginSessionWithSalt", "(", "g", "*", "GlobalContext", ",", "emailOrUsername", "string", ",", "salt", "[", "]", "byte", ")", "*", "LoginSession", "{", "ls", ":=", "NewLoginSession", "(", "g", ",", "emailOrUsername", ")", "\n", "ls", ".", "salt", "=", "salt", "\n", "// XXX are these right? is this just so the salt can be retrieved?", "ls", ".", "loaded", "=", "true", "\n", "ls", ".", "cleared", "=", "true", "\n", "return", "ls", "\n", "}" ]

[ "Upon", "signup", "a", "login", "session", "is", "created", "with", "a", "generated", "salt", "." ]

[ "func", "(", "s", "*", "LoginSession", ")", "Clear", "(", ")", "error", "{", "if", "s", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "if", "!", "s", ".", "loaded", "{", "return", "ErrLoginSessionNotLoaded", "\n", "}", "\n", "s", ".", "loginSession", "=", "nil", "\n", "s", ".", "loginSessionB64", "=", "\"", "\"", "\n", "s", ".", "cleared", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Clear", "removes", "the", "loginSession", "value", "from", "s", ".", "It", "does", "not", "clear", "the", "salt", ".", "Unclear", "how", "this", "is", "useful", "." ]

[ "func", "(", "h", "*", "Handler", ")", "autoClaim", "(", "mctx", "libkb", ".", "MetaContext", ",", "cli", "gregor1", ".", "IncomingInterface", ",", "category", "string", ",", "item", "gregor", ".", "Item", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "h", ".", "Name", "(", ")", ",", "category", ")", "\n", "mctx", ".", "G", "(", ")", ".", "GetStellar", "(", ")", ".", "KickAutoClaimRunner", "(", "mctx", ",", "item", ".", "Metadata", "(", ")", ".", "MsgID", "(", ")", ")", "\n", "}" ]

[ "The", "server", "is", "telling", "the", "client", "to", "claim", "relay", "payments", "." ]

[ "func", "(", "h", "*", "Handler", ")", "paymentStatus", "(", "mctx", "libkb", ".", "MetaContext", ",", "cli", "gregor1", ".", "IncomingInterface", ",", "category", "string", ",", "item", "gregor", ".", "Item", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "h", ".", "Name", "(", ")", ",", "category", ")", "\n\n", "// We will locally dismiss for now so that each client only plays them once:", "if", "err", ":=", "h", ".", "G", "(", ")", ".", "GregorState", ".", "LocalDismissItem", "(", "mctx", ".", "Ctx", "(", ")", ",", "item", ".", "Metadata", "(", ")", ".", "MsgID", "(", ")", ")", ";", "err", "!=", "nil", "{", "h", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "mctx", ".", "Ctx", "(", ")", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "paymentStatus", "is", "an", "old", "IBM", "and", "shouldn", "t", "happen", "anymore" ]

[ "func", "(", "c", "ConstIDGetter", ")", "GetIDForHandle", "(", "_", "context", ".", "Context", ",", "_", "*", "Handle", ")", "(", "tlf", ".", "ID", ",", "error", ")", "{", "return", "c", ".", "ID", ",", "nil", "\n", "}" ]

[ "GetIDForHandle", "implements", "the", "IDGetter", "interface", "for", "ConstIDGetter", "." ]

[ "func", "NewPGPVerify", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "PGPVerifyArg", ")", "*", "PGPVerify", "{", "return", "&", "PGPVerify", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewPGPVerify", "creates", "a", "PGPVerify", "engine", "." ]

[ "func", "(", "e", "*", "PGPVerify", ")", "runAttached", "(", "m", "libkb", ".", "MetaContext", ")", "error", "{", "arg", ":=", "&", "PGPDecryptArg", "{", "Source", ":", "e", ".", "source", ",", "Sink", ":", "libkb", ".", "NopWriteCloser", "{", "W", ":", "ioutil", ".", "Discard", "}", ",", "AssertSigned", ":", "true", ",", "SignedBy", ":", "e", ".", "arg", ".", "SignedBy", ",", "}", "\n", "eng", ":=", "NewPGPDecrypt", "(", "m", ".", "G", "(", ")", ",", "arg", ")", "\n", "if", "err", ":=", "RunEngine2", "(", "m", ",", "eng", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "e", ".", "signStatus", "=", "eng", ".", "SignatureStatus", "(", ")", "\n", "e", ".", "signer", "=", "eng", ".", "Signer", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "runAttached", "verifies", "an", "attached", "signature" ]

[ "func", "(", "e", "*", "PGPVerify", ")", "runDetached", "(", "m", "libkb", ".", "MetaContext", ")", "error", "{", "sk", ",", "err", ":=", "NewScanKeys", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "checkfn", ":=", "openpgp", ".", "CheckDetachedSignature", "\n", "if", "libkb", ".", "IsArmored", "(", "e", ".", "arg", ".", "Signature", ")", "{", "checkfn", "=", "openpgp", ".", "CheckArmoredDetachedSignature", "\n", "}", "\n", "signer", ",", "err", ":=", "checkfn", "(", "sk", ",", "e", ".", "source", ",", "bytes", ".", "NewReader", "(", "e", ".", "arg", ".", "Signature", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "e", ".", "signer", "=", "sk", ".", "KeyOwnerByEntity", "(", "signer", ")", "\n", "e", ".", "signStatus", "=", "&", "libkb", ".", "SignatureStatus", "{", "IsSigned", ":", "true", "}", "\n\n", "if", "signer", "!=", "nil", "{", "if", "len", "(", "signer", ".", "UnverifiedRevocations", ")", ">", "0", "{", "return", "libkb", ".", "BadSigError", "{", "E", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "signer", ".", "PrimaryKey", ".", "KeyId", ",", "e", ".", "signer", ".", "GetName", "(", ")", ")", ",", "}", "\n", "}", "\n\n", "e", ".", "signStatus", ".", "Verified", "=", "true", "\n", "e", ".", "signStatus", ".", "Entity", "=", "signer", "\n", "if", "err", ":=", "e", ".", "checkSignedBy", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "r", "io", ".", "Reader", "=", "bytes", ".", "NewReader", "(", "e", ".", "arg", ".", "Signature", ")", "\n", "if", "libkb", ".", "IsArmored", "(", "e", ".", "arg", ".", "Signature", ")", "{", "block", ",", "err", ":=", "armor", ".", "Decode", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "r", "=", "block", ".", "Body", "\n", "}", "\n\n", "p", ",", "err", ":=", "packet", ".", "Read", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "val", ",", "ok", ":=", "p", ".", "(", "*", "packet", ".", "Signature", ")", ";", "ok", "{", "e", ".", "signStatus", ".", "SignatureTime", "=", "val", ".", "CreationTime", "\n", "}", "\n\n", "fingerprint", ":=", "libkb", ".", "PGPFingerprint", "(", "signer", ".", "PrimaryKey", ".", "Fingerprint", ")", "\n", "OutputSignatureSuccess", "(", "m", ",", "fingerprint", ",", "e", ".", "signer", ",", "e", ".", "signStatus", ".", "SignatureTime", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "runDetached", "verifies", "a", "detached", "signature" ]

[ "func", "(", "e", "*", "PGPVerify", ")", "runClearsign", "(", "m", "libkb", ".", "MetaContext", ")", "error", "{", "// clearsign decode only works with the whole data slice, not a reader", "// so have to read it all here:", "msg", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "e", ".", "source", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "b", ",", "_", ":=", "clearsign", ".", "Decode", "(", "msg", ")", "\n", "if", "b", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "sigBody", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "b", ".", "ArmoredSignature", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sk", ",", "err", ":=", "NewScanKeys", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "signer", ",", "err", ":=", "openpgp", ".", "CheckDetachedSignature", "(", "sk", ",", "bytes", ".", "NewReader", "(", "b", ".", "Bytes", ")", ",", "bytes", ".", "NewReader", "(", "sigBody", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "e", ".", "signer", "=", "sk", ".", "KeyOwnerByEntity", "(", "signer", ")", "\n", "e", ".", "signStatus", "=", "&", "libkb", ".", "SignatureStatus", "{", "IsSigned", ":", "true", "}", "\n\n", "if", "signer", "!=", "nil", "{", "if", "len", "(", "signer", ".", "UnverifiedRevocations", ")", ">", "0", "{", "return", "libkb", ".", "BadSigError", "{", "E", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "signer", ".", "PrimaryKey", ".", "KeyId", ",", "e", ".", "signer", ".", "GetName", "(", ")", ")", ",", "}", "\n", "}", "\n\n", "e", ".", "signStatus", ".", "Verified", "=", "true", "\n", "e", ".", "signStatus", ".", "Entity", "=", "signer", "\n", "if", "err", ":=", "e", ".", "checkSignedBy", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "p", ",", "err", ":=", "packet", ".", "Read", "(", "bytes", ".", "NewReader", "(", "sigBody", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "val", ",", "ok", ":=", "p", ".", "(", "*", "packet", ".", "Signature", ")", ";", "ok", "{", "e", ".", "signStatus", ".", "SignatureTime", "=", "val", ".", "CreationTime", "\n", "}", "\n\n", "fingerprint", ":=", "libkb", ".", "PGPFingerprint", "(", "signer", ".", "PrimaryKey", ".", "Fingerprint", ")", "\n", "OutputSignatureSuccess", "(", "m", ",", "fingerprint", ",", "e", ".", "signer", ",", "e", ".", "signStatus", ".", "SignatureTime", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "runClearsign", "verifies", "a", "clearsign", "signature" ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "ListV1", "(", "ctx", "context", ".", "Context", ",", "opts", "listOptionsV1", ")", "Reply", "{", "var", "cl", "ChatList", "\n", "var", "rlimits", "[", "]", "chat1", ".", "RateLimit", "\n", "var", "pagination", "*", "chat1", ".", "Pagination", "\n", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "topicType", ",", "err", ":=", "TopicTypeFromStrDefault", "(", "opts", ".", "TopicType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "if", "opts", ".", "SkipUnbox", "{", "res", ",", "err", ":=", "client", ".", "GetInboxUILocal", "(", "ctx", ",", "chat1", ".", "GetInboxUILocalArg", "{", "Query", ":", "&", "chat1", ".", "GetInboxLocalQuery", "{", "Status", ":", "utils", ".", "VisibleChatConversationStatuses", "(", ")", ",", "TopicType", ":", "&", "topicType", ",", "UnreadOnly", ":", "opts", ".", "UnreadOnly", ",", "OneChatTypePerTLF", ":", "new", "(", "bool", ")", ",", "}", ",", "Pagination", ":", "opts", ".", "Pagination", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "pagination", "=", "res", ".", "Pagination", "\n", "rlimits", "=", "utils", ".", "AggRateLimits", "(", "res", ".", "RateLimits", ")", "\n", "if", "opts", ".", "FailOffline", "&&", "res", ".", "Offline", "{", "return", "c", ".", "errReply", "(", "chat", ".", "OfflineError", "{", "}", ")", "\n", "}", "\n", "cl", "=", "ChatList", "{", "Offline", ":", "res", ".", "Offline", ",", "IdentifyFailures", ":", "res", ".", "IdentifyFailures", ",", "}", "\n", "for", "_", ",", "conv", ":=", "range", "res", ".", "ConversationsRemote", "{", "cl", ".", "Conversations", "=", "append", "(", "cl", ".", "Conversations", ",", "c", ".", "exportRemoteConv", "(", "ctx", ",", "conv", ")", ")", "\n", "}", "\n", "}", "else", "{", "res", ",", "err", ":=", "client", ".", "GetInboxAndUnboxLocal", "(", "ctx", ",", "chat1", ".", "GetInboxAndUnboxLocalArg", "{", "Query", ":", "&", "chat1", ".", "GetInboxLocalQuery", "{", "Status", ":", "utils", ".", "VisibleChatConversationStatuses", "(", ")", ",", "TopicType", ":", "&", "topicType", ",", "UnreadOnly", ":", "opts", ".", "UnreadOnly", ",", "OneChatTypePerTLF", ":", "new", "(", "bool", ")", ",", "}", ",", "Pagination", ":", "opts", ".", "Pagination", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "pagination", "=", "res", ".", "Pagination", "\n", "rlimits", "=", "utils", ".", "AggRateLimits", "(", "res", ".", "RateLimits", ")", "\n", "if", "opts", ".", "FailOffline", "&&", "res", ".", "Offline", "{", "return", "c", ".", "errReply", "(", "chat", ".", "OfflineError", "{", "}", ")", "\n", "}", "\n", "cl", "=", "ChatList", "{", "Offline", ":", "res", ".", "Offline", ",", "IdentifyFailures", ":", "res", ".", "IdentifyFailures", ",", "}", "\n", "for", "_", ",", "conv", ":=", "range", "res", ".", "Conversations", "{", "if", "!", "opts", ".", "ShowErrors", "&&", "conv", ".", "Error", "!=", "nil", "{", "continue", "\n", "}", "\n", "cl", ".", "Conversations", "=", "append", "(", "cl", ".", "Conversations", ",", "c", ".", "exportLocalConv", "(", "ctx", ",", "conv", ")", ")", "\n", "}", "\n", "}", "\n", "cl", ".", "Pagination", "=", "pagination", "\n", "cl", ".", "RateLimits", ".", "RateLimits", "=", "c", ".", "aggRateLimits", "(", "rlimits", ")", "\n", "return", "Reply", "{", "Result", ":", "cl", "}", "\n", "}" ]

[ "ListV1", "implements", "ChatServiceHandler", ".", "ListV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "ReadV1", "(", "ctx", "context", ".", "Context", ",", "opts", "readOptionsV1", ")", "Reply", "{", "var", "rlimits", "[", "]", "chat1", ".", "RateLimit", "\n", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "conv", ",", "rlimits", ",", "err", ":=", "c", ".", "findConversation", "(", "ctx", ",", "opts", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "arg", ":=", "chat1", ".", "GetThreadLocalArg", "{", "ConversationID", ":", "conv", ".", "Info", ".", "Id", ",", "Pagination", ":", "opts", ".", "Pagination", ",", "Query", ":", "&", "chat1", ".", "GetThreadQuery", "{", "MarkAsRead", ":", "!", "opts", ".", "Peek", ",", "}", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "}", "\n", "threadView", ",", "err", ":=", "client", ".", "GetThreadLocal", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "rlimits", "=", "append", "(", "rlimits", ",", "threadView", ".", "RateLimits", "...", ")", "\n\n", "// Check to see if this was fetched offline and we should fail", "if", "opts", ".", "FailOffline", "&&", "threadView", ".", "Offline", "{", "return", "c", ".", "errReply", "(", "chat", ".", "OfflineError", "{", "}", ")", "\n", "}", "\n\n", "// This could be lower than the truth if any messages were", "// posted between the last two gregor rpcs.", "readMsgID", ":=", "conv", ".", "ReaderInfo", ".", "ReadMsgid", "\n\n", "selfUID", ":=", "c", ".", "G", "(", ")", ".", "Env", ".", "GetUID", "(", ")", "\n", "if", "selfUID", ".", "IsNil", "(", ")", "{", "c", ".", "G", "(", ")", ".", "Log", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n\n", "messages", ",", "err", ":=", "c", ".", "formatMessages", "(", "ctx", ",", "threadView", ".", "Thread", ".", "Messages", ",", "conv", ",", "selfUID", ",", "readMsgID", ",", "opts", ".", "UnreadOnly", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "thread", ":=", "Thread", "{", "Offline", ":", "threadView", ".", "Offline", ",", "IdentifyFailures", ":", "threadView", ".", "IdentifyFailures", ",", "Pagination", ":", "threadView", ".", "Thread", ".", "Pagination", ",", "Messages", ":", "messages", ",", "}", "\n\n", "thread", ".", "RateLimits", ".", "RateLimits", "=", "c", ".", "aggRateLimits", "(", "rlimits", ")", "\n", "return", "Reply", "{", "Result", ":", "thread", "}", "\n", "}" ]

[ "ReadV1", "implements", "ChatServiceHandler", ".", "ReadV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "GetV1", "(", "ctx", "context", ".", "Context", ",", "opts", "getOptionsV1", ")", "Reply", "{", "var", "rlimits", "[", "]", "chat1", ".", "RateLimit", "\n", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "conv", ",", "rlimits", ",", "err", ":=", "c", ".", "findConversation", "(", "ctx", ",", "opts", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "arg", ":=", "chat1", ".", "GetMessagesLocalArg", "{", "ConversationID", ":", "conv", ".", "Info", ".", "Id", ",", "MessageIDs", ":", "opts", ".", "MessageIDs", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "}", "\n\n", "res", ",", "err", ":=", "client", ".", "GetMessagesLocal", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "// Check to see if this was fetched offline and we should fail", "if", "opts", ".", "FailOffline", "&&", "res", ".", "Offline", "{", "return", "c", ".", "errReply", "(", "chat", ".", "OfflineError", "{", "}", ")", "\n", "}", "\n\n", "selfUID", ":=", "c", ".", "G", "(", ")", ".", "Env", ".", "GetUID", "(", ")", "\n", "if", "selfUID", ".", "IsNil", "(", ")", "{", "c", ".", "G", "(", ")", ".", "Log", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n\n", "messages", ",", "err", ":=", "c", ".", "formatMessages", "(", "ctx", ",", "res", ".", "Messages", ",", "conv", ",", "selfUID", ",", "0", "/* readMsgID */", ",", "false", "/* unreadOnly */", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "thread", ":=", "Thread", "{", "Offline", ":", "res", ".", "Offline", ",", "IdentifyFailures", ":", "res", ".", "IdentifyFailures", ",", "Messages", ":", "messages", ",", "}", "\n", "thread", ".", "RateLimits", ".", "RateLimits", "=", "c", ".", "aggRateLimits", "(", "rlimits", ")", "\n", "return", "Reply", "{", "Result", ":", "thread", "}", "\n", "}" ]

[ "GetV1", "implements", "ChatServiceHandler", ".", "GetV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "SendV1", "(", "ctx", "context", ".", "Context", ",", "opts", "sendOptionsV1", ",", "ui", "chat1", ".", "ChatUiInterface", ")", "Reply", "{", "arg", ":=", "sendArgV1", "{", "channel", ":", "opts", ".", "Channel", ",", "body", ":", "chat1", ".", "NewMessageBodyWithText", "(", "chat1", ".", "MessageText", "{", "Body", ":", "opts", ".", "Message", ".", "Body", "}", ")", ",", "mtype", ":", "chat1", ".", "MessageType_TEXT", ",", "response", ":", "\"", "\"", ",", "nonblock", ":", "opts", ".", "Nonblock", ",", "ephemeralLifetime", ":", "opts", ".", "EphemeralLifetime", ",", "replyTo", ":", "opts", ".", "ReplyTo", ",", "}", "\n", "return", "c", ".", "sendV1", "(", "ctx", ",", "arg", ",", "ui", ")", "\n", "}" ]

[ "SendV1", "implements", "ChatServiceHandler", ".", "SendV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "DeleteV1", "(", "ctx", "context", ".", "Context", ",", "opts", "deleteOptionsV1", ")", "Reply", "{", "messages", ":=", "[", "]", "chat1", ".", "MessageID", "{", "opts", ".", "MessageID", "}", "\n", "arg", ":=", "sendArgV1", "{", "channel", ":", "opts", ".", "Channel", ",", "mtype", ":", "chat1", ".", "MessageType_DELETE", ",", "supersedes", ":", "opts", ".", "MessageID", ",", "deletes", ":", "messages", ",", "response", ":", "\"", "\"", ",", "// NOTE: The service will fill in the IDs of edit messages that also need to be deleted.", "body", ":", "chat1", ".", "NewMessageBodyWithDelete", "(", "chat1", ".", "MessageDelete", "{", "MessageIDs", ":", "messages", "}", ")", ",", "}", "\n", "return", "c", ".", "sendV1", "(", "ctx", ",", "arg", ",", "utils", ".", "DummyChatUI", "{", "}", ")", "\n", "}" ]

[ "DeleteV1", "implements", "ChatServiceHandler", ".", "DeleteV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "EditV1", "(", "ctx", "context", ".", "Context", ",", "opts", "editOptionsV1", ")", "Reply", "{", "arg", ":=", "sendArgV1", "{", "channel", ":", "opts", ".", "Channel", ",", "body", ":", "chat1", ".", "NewMessageBodyWithEdit", "(", "chat1", ".", "MessageEdit", "{", "MessageID", ":", "opts", ".", "MessageID", ",", "Body", ":", "opts", ".", "Message", ".", "Body", "}", ")", ",", "mtype", ":", "chat1", ".", "MessageType_EDIT", ",", "supersedes", ":", "opts", ".", "MessageID", ",", "response", ":", "\"", "\"", ",", "}", "\n", "return", "c", ".", "sendV1", "(", "ctx", ",", "arg", ",", "utils", ".", "DummyChatUI", "{", "}", ")", "\n", "}" ]

[ "EditV1", "implements", "ChatServiceHandler", ".", "EditV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "ReactionV1", "(", "ctx", "context", ".", "Context", ",", "opts", "reactionOptionsV1", ")", "Reply", "{", "arg", ":=", "sendArgV1", "{", "channel", ":", "opts", ".", "Channel", ",", "body", ":", "chat1", ".", "NewMessageBodyWithReaction", "(", "chat1", ".", "MessageReaction", "{", "MessageID", ":", "opts", ".", "MessageID", ",", "Body", ":", "opts", ".", "Message", ".", "Body", "}", ")", ",", "mtype", ":", "chat1", ".", "MessageType_REACTION", ",", "supersedes", ":", "opts", ".", "MessageID", ",", "response", ":", "\"", "\"", ",", "}", "\n", "return", "c", ".", "sendV1", "(", "ctx", ",", "arg", ",", "utils", ".", "DummyChatUI", "{", "}", ")", "\n", "}" ]

[ "ReactionV1", "implements", "ChatServiceHandler", ".", "ReactionV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "DownloadV1", "(", "ctx", "context", ".", "Context", ",", "opts", "downloadOptionsV1", ",", "chatUI", "chat1", ".", "ChatUiInterface", ")", "Reply", "{", "if", "opts", ".", "NoStream", "&&", "opts", ".", "Output", "!=", "\"", "\"", "{", "return", "c", ".", "downloadV1NoStream", "(", "ctx", ",", "opts", ",", "chatUI", ")", "\n", "}", "\n", "var", "fsink", "Sink", "\n", "if", "opts", ".", "Output", "==", "\"", "\"", "{", "fsink", "=", "&", "StdoutSink", "{", "}", "\n", "}", "else", "{", "fsink", "=", "NewFileSink", "(", "c", ".", "G", "(", ")", ",", "opts", ".", "Output", ")", "\n", "}", "\n", "defer", "fsink", ".", "Close", "(", ")", "\n", "sink", ":=", "c", ".", "G", "(", ")", ".", "XStreams", ".", "ExportWriter", "(", "fsink", ")", "\n\n", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "protocols", ":=", "[", "]", "rpc", ".", "Protocol", "{", "NewStreamUIProtocol", "(", "c", ".", "G", "(", ")", ")", ",", "chat1", ".", "ChatUiProtocol", "(", "chatUI", ")", ",", "}", "\n", "if", "err", ":=", "RegisterProtocolsWithContext", "(", "protocols", ",", "c", ".", "G", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "convID", ",", "rlimits", ",", "err", ":=", "c", ".", "resolveAPIConvID", "(", "ctx", ",", "opts", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "arg", ":=", "chat1", ".", "DownloadAttachmentLocalArg", "{", "ConversationID", ":", "convID", ",", "MessageID", ":", "opts", ".", "MessageID", ",", "Sink", ":", "sink", ",", "Preview", ":", "opts", ".", "Preview", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "}", "\n\n", "dres", ",", "err", ":=", "client", ".", "DownloadAttachmentLocal", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "rlimits", "=", "append", "(", "rlimits", ",", "dres", ".", "RateLimits", "...", ")", "\n", "if", "opts", ".", "Output", "!=", "\"", "\"", "{", "if", "err", ":=", "attachments", ".", "Quarantine", "(", "ctx", ",", "opts", ".", "Output", ")", ";", "err", "!=", "nil", "{", "c", ".", "G", "(", ")", ".", "Log", ".", "Warning", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "res", ":=", "SendRes", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "opts", ".", "Output", ")", ",", "RateLimits", ":", "RateLimits", "{", "RateLimits", ":", "c", ".", "aggRateLimits", "(", "rlimits", ")", ",", "}", ",", "IdentifyFailures", ":", "dres", ".", "IdentifyFailures", ",", "}", "\n\n", "return", "Reply", "{", "Result", ":", "res", "}", "\n", "}" ]

[ "DownloadV1", "implements", "ChatServiceHandler", ".", "DownloadV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "downloadV1NoStream", "(", "ctx", "context", ".", "Context", ",", "opts", "downloadOptionsV1", ",", "chatUI", "chat1", ".", "ChatUiInterface", ")", "Reply", "{", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "protocols", ":=", "[", "]", "rpc", ".", "Protocol", "{", "NewStreamUIProtocol", "(", "c", ".", "G", "(", ")", ")", ",", "chat1", ".", "ChatUiProtocol", "(", "chatUI", ")", ",", "}", "\n", "if", "err", ":=", "RegisterProtocolsWithContext", "(", "protocols", ",", "c", ".", "G", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "convID", ",", "rlimits", ",", "err", ":=", "c", ".", "resolveAPIConvID", "(", "ctx", ",", "opts", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "arg", ":=", "chat1", ".", "DownloadFileAttachmentLocalArg", "{", "ConversationID", ":", "convID", ",", "MessageID", ":", "opts", ".", "MessageID", ",", "Preview", ":", "opts", ".", "Preview", ",", "Filename", ":", "opts", ".", "Output", ",", "}", "\n\n", "dres", ",", "err", ":=", "client", ".", "DownloadFileAttachmentLocal", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "rlimits", "=", "append", "(", "rlimits", ",", "dres", ".", "RateLimits", "...", ")", "\n\n", "res", ":=", "SendRes", "{", "Message", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "opts", ".", "Output", ")", ",", "RateLimits", ":", "RateLimits", "{", "RateLimits", ":", "c", ".", "aggRateLimits", "(", "rlimits", ")", ",", "}", ",", "}", "\n\n", "return", "Reply", "{", "Result", ":", "res", "}", "\n", "}" ]

[ "downloadV1NoStream", "uses", "DownloadFileAttachmentLocal", "instead", "of", "DownloadAttachmentLocal", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "SetStatusV1", "(", "ctx", "context", ".", "Context", ",", "opts", "setStatusOptionsV1", ")", "Reply", "{", "var", "rlimits", "[", "]", "chat1", ".", "RateLimit", "\n\n", "convID", ",", "rlimits", ",", "err", ":=", "c", ".", "resolveAPIConvID", "(", "ctx", ",", "opts", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "status", ",", "ok", ":=", "chat1", ".", "ConversationStatusMap", "[", "strings", ".", "ToUpper", "(", "opts", ".", "Status", ")", "]", "\n", "if", "!", "ok", "{", "return", "c", ".", "errReply", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "opts", ".", "Status", ")", ")", "\n", "}", "\n\n", "setStatusArg", ":=", "chat1", ".", "SetConversationStatusLocalArg", "{", "ConversationID", ":", "convID", ",", "Status", ":", "status", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "}", "\n\n", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "localRes", ",", "err", ":=", "client", ".", "SetConversationStatusLocal", "(", "ctx", ",", "setStatusArg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "rlimits", "=", "append", "(", "rlimits", ",", "localRes", ".", "RateLimits", "...", ")", "\n\n", "res", ":=", "EmptyRes", "{", "RateLimits", ":", "RateLimits", "{", "c", ".", "aggRateLimits", "(", "rlimits", ")", ",", "}", ",", "}", "\n", "return", "Reply", "{", "Result", ":", "res", "}", "\n", "}" ]

[ "SetStatusV1", "implements", "ChatServiceHandler", ".", "SetStatusV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "MarkV1", "(", "ctx", "context", ".", "Context", ",", "opts", "markOptionsV1", ")", "Reply", "{", "convID", ",", "rlimits", ",", "err", ":=", "c", ".", "resolveAPIConvID", "(", "ctx", ",", "opts", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "arg", ":=", "chat1", ".", "MarkAsReadLocalArg", "{", "ConversationID", ":", "convID", ",", "MsgID", ":", "opts", ".", "MessageID", ",", "}", "\n\n", "res", ",", "err", ":=", "client", ".", "MarkAsReadLocal", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "allLimits", ":=", "append", "(", "rlimits", ",", "res", ".", "RateLimits", "...", ")", "\n", "cres", ":=", "EmptyRes", "{", "RateLimits", ":", "RateLimits", "{", "c", ".", "aggRateLimits", "(", "allLimits", ")", ",", "}", ",", "}", "\n", "return", "Reply", "{", "Result", ":", "cres", "}", "\n", "}" ]

[ "MarkV1", "implements", "ChatServiceHandler", ".", "MarkV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "SearchInboxV1", "(", "ctx", "context", ".", "Context", ",", "opts", "searchInboxOptionsV1", ")", "Reply", "{", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "if", "opts", ".", "MaxHits", "<=", "0", "{", "opts", ".", "MaxHits", "=", "10", "\n", "}", "\n\n", "reindexMode", ":=", "chat1", ".", "ReIndexingMode_NONE", "\n", "if", "opts", ".", "ForceReindex", "{", "reindexMode", "=", "chat1", ".", "ReIndexingMode_PRESEARCH_SYNC", "\n", "}", "\n", "searchOpts", ":=", "chat1", ".", "SearchOpts", "{", "ReindexMode", ":", "reindexMode", ",", "SentBy", ":", "opts", ".", "SentBy", ",", "MaxHits", ":", "opts", ".", "MaxHits", ",", "BeforeContext", ":", "opts", ".", "BeforeContext", ",", "AfterContext", ":", "opts", ".", "AfterContext", ",", "}", "\n\n", "if", "opts", ".", "SentBefore", "!=", "\"", "\"", "&&", "opts", ".", "SentAfter", "!=", "\"", "\"", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "if", "opts", ".", "SentBefore", "!=", "\"", "\"", "{", "sentBefore", ",", "err", ":=", "dateparse", ".", "ParseAny", "(", "opts", ".", "SentBefore", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "searchOpts", ".", "SentBefore", "=", "gregor1", ".", "ToTime", "(", "sentBefore", ")", "\n", "}", "\n", "if", "opts", ".", "SentAfter", "!=", "\"", "\"", "{", "sentAfter", ",", "err", ":=", "dateparse", ".", "ParseAny", "(", "opts", ".", "SentAfter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "searchOpts", ".", "SentAfter", "=", "gregor1", ".", "ToTime", "(", "sentAfter", ")", "\n", "}", "\n\n", "arg", ":=", "chat1", ".", "SearchInboxArg", "{", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "Query", ":", "opts", ".", "Query", ",", "Opts", ":", "searchOpts", ",", "}", "\n\n", "res", ",", "err", ":=", "client", ".", "SearchInbox", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "searchRes", ":=", "SearchInboxRes", "{", "Results", ":", "res", ".", "Res", ",", "RateLimits", ":", "RateLimits", "{", "c", ".", "aggRateLimits", "(", "res", ".", "RateLimits", ")", ",", "}", ",", "IdentifyFailures", ":", "res", ".", "IdentifyFailures", ",", "}", "\n", "return", "Reply", "{", "Result", ":", "searchRes", "}", "\n", "}" ]

[ "SearchInbox", "implements", "ChatServiceHandler", ".", "SearchInboxV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "SearchRegexpV1", "(", "ctx", "context", ".", "Context", ",", "opts", "searchRegexpOptionsV1", ")", "Reply", "{", "convID", ",", "rlimits", ",", "err", ":=", "c", ".", "resolveAPIConvID", "(", "ctx", ",", "opts", ".", "Channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "client", ",", "err", ":=", "GetChatLocalClient", "(", "c", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "if", "opts", ".", "MaxHits", "<=", "0", "{", "opts", ".", "MaxHits", "=", "10", "\n", "}", "\n\n", "if", "opts", ".", "MaxMessages", "<=", "0", "{", "opts", ".", "MaxMessages", "=", "10000", "\n", "}", "\n\n", "searchOpts", ":=", "chat1", ".", "SearchOpts", "{", "SentBy", ":", "opts", ".", "SentBy", ",", "MaxHits", ":", "opts", ".", "MaxHits", ",", "MaxMessages", ":", "opts", ".", "MaxMessages", ",", "BeforeContext", ":", "opts", ".", "BeforeContext", ",", "AfterContext", ":", "opts", ".", "AfterContext", ",", "}", "\n\n", "if", "opts", ".", "SentBefore", "!=", "\"", "\"", "&&", "opts", ".", "SentAfter", "!=", "\"", "\"", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "if", "opts", ".", "SentBefore", "!=", "\"", "\"", "{", "sentBefore", ",", "err", ":=", "dateparse", ".", "ParseAny", "(", "opts", ".", "SentBefore", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "searchOpts", ".", "SentBefore", "=", "gregor1", ".", "ToTime", "(", "sentBefore", ")", "\n", "}", "\n", "if", "opts", ".", "SentAfter", "!=", "\"", "\"", "{", "sentAfter", ",", "err", ":=", "dateparse", ".", "ParseAny", "(", "opts", ".", "SentAfter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n", "searchOpts", ".", "SentAfter", "=", "gregor1", ".", "ToTime", "(", "sentAfter", ")", "\n", "}", "\n", "searchOpts", ".", "IsRegex", "=", "opts", ".", "IsRegex", "\n\n", "arg", ":=", "chat1", ".", "SearchRegexpArg", "{", "ConvID", ":", "convID", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_CHAT_CLI", ",", "Query", ":", "opts", ".", "Query", ",", "Opts", ":", "searchOpts", ",", "}", "\n\n", "res", ",", "err", ":=", "client", ".", "SearchRegexp", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "errReply", "(", "err", ")", "\n", "}", "\n\n", "allLimits", ":=", "append", "(", "rlimits", ",", "res", ".", "RateLimits", "...", ")", "\n", "searchRes", ":=", "SearchRegexpRes", "{", "Hits", ":", "res", ".", "Hits", ",", "RateLimits", ":", "RateLimits", "{", "c", ".", "aggRateLimits", "(", "allLimits", ")", ",", "}", ",", "IdentifyFailures", ":", "res", ".", "IdentifyFailures", ",", "}", "\n", "return", "Reply", "{", "Result", ":", "searchRes", "}", "\n", "}" ]

[ "SearchRegexpV1", "implements", "ChatServiceHandler", ".", "SearchRegexpV1", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "convertMsgBody", "(", "mb", "chat1", ".", "MessageBody", ")", "MsgContent", "{", "return", "MsgContent", "{", "TypeName", ":", "strings", ".", "ToLower", "(", "chat1", ".", "MessageTypeRevMap", "[", "mb", ".", "MessageType__", "]", ")", ",", "Text", ":", "mb", ".", "Text__", ",", "Attachment", ":", "mb", ".", "Attachment__", ",", "Edit", ":", "mb", ".", "Edit__", ",", "Reaction", ":", "mb", ".", "Reaction__", ",", "Delete", ":", "mb", ".", "Delete__", ",", "Metadata", ":", "mb", ".", "Metadata__", ",", "Headline", ":", "mb", ".", "Headline__", ",", "AttachmentUploaded", ":", "mb", ".", "Attachmentuploaded__", ",", "System", ":", "mb", ".", "System__", ",", "SendPayment", ":", "mb", ".", "Sendpayment__", ",", "RequestPayment", ":", "mb", ".", "Requestpayment__", ",", "Unfurl", ":", "mb", ".", "Unfurl__", ",", "Flip", ":", "mb", ".", "Flip__", ",", "}", "\n", "}" ]

[ "need", "this", "to", "get", "message", "type", "name" ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "resolveAPIConvID", "(", "ctx", "context", ".", "Context", ",", "channel", "ChatChannel", ")", "(", "chat1", ".", "ConversationID", ",", "[", "]", "chat1", ".", "RateLimit", ",", "error", ")", "{", "conv", ",", "limits", ",", "err", ":=", "c", ".", "findConversation", "(", "ctx", ",", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "chat1", ".", "ConversationID", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "return", "conv", ".", "Info", ".", "Id", ",", "limits", ",", "nil", "\n", "}" ]

[ "Resolve", "the", "ConvID", "of", "the", "specified", "conversation", ".", "Uses", "tlfclient", "and", "GetInboxAndUnboxLocal", "s", "ConversationsUnverified", "." ]

[ "func", "(", "c", "*", "chatServiceHandler", ")", "findConversation", "(", "ctx", "context", ".", "Context", ",", "channel", "ChatChannel", ")", "(", "chat1", ".", "ConversationLocal", ",", "[", "]", "chat1", ".", "RateLimit", ",", "error", ")", "{", "var", "conv", "chat1", ".", "ConversationLocal", "\n", "var", "rlimits", "[", "]", "chat1", ".", "RateLimit", "\n\n", "if", "channel", ".", "IsNil", "(", ")", "{", "return", "conv", ",", "rlimits", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "existing", ",", "existingRl", ",", "err", ":=", "c", ".", "getExistingConvs", "(", "ctx", ",", "channel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "conv", ",", "rlimits", ",", "err", "\n", "}", "\n", "rlimits", "=", "append", "(", "rlimits", ",", "existingRl", "...", ")", "\n\n", "if", "len", "(", "existing", ")", ">", "1", "{", "return", "conv", ",", "rlimits", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "channel", ".", "Name", ")", "\n", "}", "\n", "if", "len", "(", "existing", ")", "==", "0", "{", "return", "conv", ",", "rlimits", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "channel", ".", "Name", ")", "\n", "}", "\n\n", "return", "existing", "[", "0", "]", ",", "rlimits", ",", "nil", "\n", "}" ]

[ "findConversation", "finds", "a", "conversation", ".", "Uses", "tlfclient", "and", "GetInboxAndUnboxLocal", "s", "ConversationsUnverified", "." ]

[ "func", "NewContextWithReplayFrom", "(", "ctx", "context", ".", "Context", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "if", "replays", ",", "ok", ":=", "ctx", ".", "Value", "(", "CtxReplayKey", ")", ".", "(", "[", "]", "CtxReplayFunc", ")", ";", "ok", "{", "newCtx", ":=", "context", ".", "Background", "(", ")", "\n", "for", "_", ",", "replay", ":=", "range", "replays", "{", "newCtx", "=", "replay", "(", "newCtx", ")", "\n", "}", "\n", "replays", ",", "_", ":=", "ctx", ".", "Value", "(", "CtxReplayKey", ")", ".", "(", "[", "]", "CtxReplayFunc", ")", "\n", "newCtx", "=", "context", ".", "WithValue", "(", "newCtx", ",", "CtxReplayKey", ",", "replays", ")", "\n", "return", "newCtx", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "CtxNotReplayableError", "{", "}", "\n", "}" ]

[ "NewContextWithReplayFrom", "constructs", "a", "new", "context", "out", "of", "ctx", "by", "calling", "all", "attached", "replay", "functions", ".", "This", "disconnects", "any", "existing", "context", ".", "CancelFunc", "." ]

[ "func", "BackgroundContextWithCancellationDelayer", "(", ")", "context", ".", "Context", "{", "if", "ctx", ",", "err", ":=", "NewContextWithCancellationDelayer", "(", "NewContextReplayable", "(", "context", ".", "Background", "(", ")", ",", "func", "(", "c", "context", ".", "Context", ")", "context", ".", "Context", "{", "return", "c", "\n", "}", ")", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "else", "{", "return", "ctx", "\n", "}", "\n", "}" ]

[ "BackgroundContextWithCancellationDelayer", "generate", "a", "Background", "context", "that", "is", "cancellation", "delayable" ]

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

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

[ "func", "SafeWriteToFile", "(", "g", "SafeWriteLogger", ",", "t", "SafeWriter", ",", "mode", "os", ".", "FileMode", ")", "error", "{", "var", "err", "error", "\n", "for", "i", ":=", "0", ";", "i", "<", "5", ";", "i", "++", "{", "if", "err", "!=", "nil", "{", "g", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "err", "=", "safeWriteToFileOnce", "(", "g", ",", "t", ",", "mode", ")", "\n", "if", "err", "==", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "SafeWriteToFile", "retries", "safeWriteToFileOnce", "a", "few", "times", "on", "Windows", "in", "case", "AV", "programs", "interfere", "with", "2", "writes", "in", "quick", "succession", "." ]

[ "func", "renameFile", "(", "g", "*", "GlobalContext", ",", "src", "string", ",", "dest", "string", ")", "error", "{", "var", "err", "error", "\n", "for", "i", ":=", "0", ";", "i", "<", "5", ";", "i", "++", "{", "if", "err", "!=", "nil", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "err", "=", "os", ".", "Rename", "(", "src", ",", "dest", ")", "\n", "if", "err", "==", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "renameFile", "performs", "some", "retries", "on", "Windows", "similar", "to", "SafeWriteToFile" ]

[ "func", "notifyShell", "(", "path", "string", ")", "{", "pathEncoded", ":=", "utf16", ".", "Encode", "(", "[", "]", "rune", "(", "path", ")", ")", "\n", "if", "len", "(", "pathEncoded", ")", ">", "0", "{", "shChangeNotifyProc", ".", "Call", "(", "uintptr", "(", "0x00002000", ")", ",", "// SHCNE_UPDATEITEM", "uintptr", "(", "0x0005", ")", ",", "// SHCNF_PATHW", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "pathEncoded", "[", "0", "]", ")", ")", ",", "0", ")", "\n", "}", "\n", "}" ]

[ "Notify", "the", "shell", "that", "the", "thing", "located", "at", "path", "has", "changed" ]

[ "func", "ChangeMountIcon", "(", "oldMount", "string", ",", "newMount", "string", ")", "error", "{", "if", "oldMount", "!=", "\"", "\"", "{", "// DeleteKey doesn't work if there are subkeys", "registry", ".", "DeleteKey", "(", "registry", ".", "CURRENT_USER", ",", "`SOFTWARE\\Classes\\Applications\\Explorer.exe\\Drives\\`", "+", "oldMount", "[", ":", "1", "]", "+", "`\\DefaultIcon`", ")", "\n", "registry", ".", "DeleteKey", "(", "registry", ".", "CURRENT_USER", ",", "`SOFTWARE\\Classes\\Applications\\Explorer.exe\\Drives\\`", "+", "oldMount", "[", ":", "1", "]", "+", "`\\DefaultLabel`", ")", "\n", "registry", ".", "DeleteKey", "(", "registry", ".", "CURRENT_USER", ",", "`SOFTWARE\\Classes\\Applications\\Explorer.exe\\Drives\\`", "+", "oldMount", "[", ":", "1", "]", ")", "\n", "notifyShell", "(", "oldMount", ")", "\n", "}", "\n", "if", "newMount", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "k", ",", "_", ",", "err", ":=", "registry", ".", "CreateKey", "(", "registry", ".", "CURRENT_USER", ",", "`SOFTWARE\\Classes\\Applications\\Explorer.exe\\Drives\\`", "+", "newMount", "[", ":", "1", "]", "+", "`\\DefaultIcon`", ",", "registry", ".", "SET_VALUE", "|", "registry", ".", "CREATE_SUB_KEY", "|", "registry", ".", "WRITE", ")", "\n", "defer", "k", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "keybaseExe", ",", "err", ":=", "utils", ".", "BinPath", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Use the second icon bound into keybase.exe - hence the 1", "err", "=", "k", ".", "SetStringValue", "(", "\"", "\"", ",", "keybaseExe", "+", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Also give a nice label", "k2", ",", "_", ",", "err", ":=", "registry", ".", "CreateKey", "(", "registry", ".", "CURRENT_USER", ",", "`SOFTWARE\\Classes\\Applications\\Explorer.exe\\Drives\\`", "+", "newMount", "[", ":", "1", "]", "+", "`\\DefaultLabel`", ",", "registry", ".", "SET_VALUE", "|", "registry", ".", "CREATE_SUB_KEY", "|", "registry", ".", "WRITE", ")", "\n", "defer", "k2", ".", "Close", "(", ")", "\n", "err", "=", "k2", ".", "SetStringValue", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "notifyShell", "(", "newMount", ")", "\n", "return", "err", "\n", "}" ]

[ "Manipulate", "registry", "entries", "to", "reflect", "the", "mount", "point", "icon", "in", "the", "shell" ]

[ "func", "(", "fl", "*", "FolderList", ")", "PathType", "(", ")", "tlfhandle", ".", "PathType", "{", "switch", "fl", ".", "tlfType", "{", "case", "tlf", ".", "Private", ":", "return", "tlfhandle", ".", "PrivatePathType", "\n", "case", "tlf", ".", "Public", ":", "return", "tlfhandle", ".", "PublicPathType", "\n", "case", "tlf", ".", "SingleTeam", ":", "return", "tlfhandle", ".", "SingleTeamPathType", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fl", ".", "tlfType", ")", ")", "\n", "}", "\n", "}" ]

[ "PathType", "returns", "PathType", "for", "this", "folder" ]

[ "func", "(", "fl", "*", "FolderList", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "CreateRequest", ",", "resp", "*", "fuse", ".", "CreateResponse", ")", "(", "_", "fs", ".", "Node", ",", "_", "fs", ".", "Handle", ",", "err", "error", ")", "{", "fl", ".", "fs", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ")", "\n", "tlfName", ":=", "tlf", ".", "CanonicalName", "(", "req", ".", "Name", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "fl", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "tlfName", ",", "err", ")", "}", "(", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "req", ".", "Name", ",", "\"", "\"", ")", "{", "// Quietly ignore writes to special macOS files, without", "// triggering a notification.", "return", "nil", ",", "nil", ",", "syscall", ".", "ENOENT", "\n", "}", "\n", "return", "nil", ",", "nil", ",", "libkbfs", ".", "NewWriteUnsupportedError", "(", "tlfhandle", ".", "BuildCanonicalPath", "(", "fl", ".", "PathType", "(", ")", ",", "string", "(", "tlfName", ")", ")", ")", "\n", "}" ]

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

[ "func", "(", "fl", "*", "FolderList", ")", "Mkdir", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "MkdirRequest", ")", "(", "_", "fs", ".", "Node", ",", "err", "error", ")", "{", "fl", ".", "fs", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ")", "\n", "tlfName", ":=", "tlf", ".", "CanonicalName", "(", "req", ".", "Name", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "fl", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "tlfName", ",", "err", ")", "}", "(", ")", "\n", "return", "nil", ",", "libkbfs", ".", "NewWriteUnsupportedError", "(", "tlfhandle", ".", "BuildCanonicalPath", "(", "fl", ".", "PathType", "(", ")", ",", "string", "(", "tlfName", ")", ")", ")", "\n", "}" ]

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

[ "func", "(", "fl", "*", "FolderList", ")", "Remove", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "RemoveRequest", ")", "(", "err", "error", ")", "{", "fl", ".", "fs", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "req", ".", "Name", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "fl", ".", "fs", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "err", ")", "}", "(", ")", "\n\n", "h", ",", "err", ":=", "tlfhandle", ".", "ParseHandlePreferredQuick", "(", "ctx", ",", "fl", ".", "fs", ".", "config", ".", "KBPKI", "(", ")", ",", "fl", ".", "fs", ".", "config", ",", "req", ".", "Name", ",", "fl", ".", "tlfType", ")", "\n\n", "switch", "err", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "nil", ":", "func", "(", ")", "{", "fl", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "fl", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "tlf", ",", "ok", ":=", "fl", ".", "folders", "[", "req", ".", "Name", "]", ";", "ok", "{", "// Fake future attr calls for this TLF until the user", "// actually opens the TLF again, because some OSes (*cough", "// OS X cough*) like to do immediate lookup/attr calls", "// right after doing a remove, which would otherwise end", "// up re-adding the favorite.", "tlf", ".", "clearStoredDir", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// TODO how to handle closing down the folderbranchops", "// object? Open files may still exist long after removing", "// the favorite.", "return", "fl", ".", "fs", ".", "config", ".", "KBFSOps", "(", ")", ".", "DeleteFavorite", "(", "ctx", ",", "h", ".", "ToFavorite", "(", ")", ")", "\n\n", "case", "idutil", ".", "TlfNameNotCanonical", ":", "return", "nil", "\n\n", "default", ":", "return", "err", "\n", "}", "\n", "}" ]

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

[ "func", "NewAutogitManager", "(", "config", "libkbfs", ".", "Config", ",", "browserCacheSize", "int", ")", "*", "AutogitManager", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "browserCache", ",", "err", ":=", "lru", ".", "New", "(", "browserCacheSize", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "sharedCache", ",", "err", ":=", "newLRUSharedInBrowserCache", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "&", "AutogitManager", "{", "config", ":", "config", ",", "log", ":", "log", ",", "deferLog", ":", "log", ".", "CloneWithAddedDepth", "(", "1", ")", ",", "registeredFBs", ":", "make", "(", "map", "[", "data", ".", "FolderBranch", "]", "bool", ")", ",", "repoNodesForWatchedIDs", ":", "make", "(", "map", "[", "libkbfs", ".", "NodeID", "]", "*", "repoDirNode", ")", ",", "deleteCancels", ":", "make", "(", "map", "[", "string", "]", "context", ".", "CancelFunc", ")", ",", "browserCache", ":", "browserCache", ",", "sharedInBrowserCache", ":", "sharedCache", ",", "}", "\n", "}" ]

[ "NewAutogitManager", "constructs", "a", "new", "AutogitManager", "instance", "." ]

[ "func", "(", "am", "*", "AutogitManager", ")", "Shutdown", "(", ")", "{", "am", ".", "registryLock", ".", "Lock", "(", ")", "\n", "defer", "am", ".", "registryLock", ".", "Unlock", "(", ")", "\n", "am", ".", "shutdown", "=", "true", "\n", "for", "_", ",", "cancel", ":=", "range", "am", ".", "deleteCancels", "{", "cancel", "(", ")", "\n", "}", "\n", "}" ]

[ "Shutdown", "shuts", "down", "this", "manager", "." ]

[ "func", "(", "am", "*", "AutogitManager", ")", "LocalChange", "(", "ctx", "context", ".", "Context", ",", "node", "libkbfs", ".", "Node", ",", "wr", "libkbfs", ".", "WriteRange", ")", "{", "// Do nothing.", "}" ]

[ "LocalChange", "implements", "the", "libkbfs", ".", "Observer", "interface", "for", "AutogitManager", "." ]

[ "func", "(", "am", "*", "AutogitManager", ")", "BatchChanges", "(", "ctx", "context", ".", "Context", ",", "_", "[", "]", "libkbfs", ".", "NodeChange", ",", "affectedNodeIDs", "[", "]", "libkbfs", ".", "NodeID", ")", "{", "nodes", ",", "repoNodeIDs", ":=", "am", ".", "getNodesToInvalidate", "(", "affectedNodeIDs", ")", "\n", "go", "am", ".", "clearInvalidatedBrowsers", "(", "repoNodeIDs", ")", "\n", "for", "_", ",", "node", ":=", "range", "nodes", "{", "node", ":=", "node", "\n", "go", "func", "(", ")", "{", "ctx", ":=", "libkbfs", ".", "CtxWithRandomIDReplayable", "(", "context", ".", "Background", "(", ")", ",", "ctxAutogitIDKey", ",", "ctxAutogitOpID", ",", "am", ".", "log", ")", "\n", "am", ".", "config", ".", "KBFSOps", "(", ")", ".", "InvalidateNodeAndChildren", "(", "ctx", ",", "node", ")", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "BatchChanges", "implements", "the", "libkbfs", ".", "Observer", "interface", "for", "AutogitManager", "." ]

[ "func", "(", "am", "*", "AutogitManager", ")", "GetBrowserForRepo", "(", "ctx", "context", ".", "Context", ",", "gitFS", "*", "libfs", ".", "FS", ",", "repoName", "string", ",", "branch", "plumbing", ".", "ReferenceName", ",", "subdir", "string", ")", "(", "*", "libfs", ".", "FS", ",", "*", "Browser", ",", "error", ")", "{", "am", ".", "browserLock", ".", "Lock", "(", ")", "\n", "defer", "am", ".", "browserLock", ".", "Unlock", "(", ")", "\n", "return", "am", ".", "getBrowserForRepoLocked", "(", "ctx", ",", "gitFS", ",", "repoName", ",", "branch", ",", "subdir", ")", "\n", "}" ]

[ "GetBrowserForRepo", "returns", "the", "root", "FS", "for", "the", "specified", "repo", "and", "a", "Browser", "for", "the", "branch", "and", "subdir", "." ]

[ "func", "StartAutogit", "(", "config", "libkbfs", ".", "Config", ",", "browserCacheSize", "int", ")", "func", "(", ")", "{", "am", ":=", "NewAutogitManager", "(", "config", ",", "browserCacheSize", ")", "\n", "rw", ":=", "rootWrapper", "{", "am", "}", "\n", "config", ".", "AddRootNodeWrapper", "(", "rw", ".", "wrap", ")", "\n", "return", "am", ".", "Shutdown", "\n", "}" ]

[ "StartAutogit", "launches", "autogit", "and", "returns", "a", "function", "that", "should", "be", "called", "on", "shutdown", "." ]

[ "func", "(", "c", "ComponentName", ")", "Description", "(", ")", "string", "{", "switch", "c", "{", "case", "ComponentNameService", ":", "return", "\"", "\"", "\n", "case", "ComponentNameKBFS", ":", "return", "\"", "\"", "\n", "case", "ComponentNameApp", ":", "return", "\"", "\"", "\n", "case", "ComponentNameCLI", ":", "return", "\"", "\"", "\n", "case", "ComponentNameUpdater", ":", "return", "\"", "\"", "\n", "case", "ComponentNameFuse", ":", "return", "\"", "\"", "\n", "case", "ComponentNameHelper", ":", "return", "\"", "\"", "\n", "case", "ComponentNameKBNM", ":", "return", "\"", "\"", "\n", "case", "ComponentNameCLIPaths", ":", "return", "\"", "\"", "\n", "case", "ComponentNameRedirector", ":", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "Description", "returns", "description", "for", "component", "name" ]

[ "func", "ComponentNameFromString", "(", "s", "string", ")", "ComponentName", "{", "switch", "s", "{", "case", "string", "(", "ComponentNameCLI", ")", ":", "return", "ComponentNameCLI", "\n", "case", "string", "(", "ComponentNameService", ")", ":", "return", "ComponentNameService", "\n", "case", "string", "(", "ComponentNameKBFS", ")", ":", "return", "ComponentNameKBFS", "\n", "case", "string", "(", "ComponentNameKBNM", ")", ":", "return", "ComponentNameKBNM", "\n", "case", "string", "(", "ComponentNameUpdater", ")", ":", "return", "ComponentNameUpdater", "\n", "case", "string", "(", "ComponentNameApp", ")", ":", "return", "ComponentNameApp", "\n", "case", "string", "(", "ComponentNameFuse", ")", ":", "return", "ComponentNameFuse", "\n", "case", "string", "(", "ComponentNameHelper", ")", ":", "return", "ComponentNameHelper", "\n", "case", "string", "(", "ComponentNameCLIPaths", ")", ":", "return", "ComponentNameCLIPaths", "\n", "case", "string", "(", "ComponentNameRedirector", ")", ":", "return", "ComponentNameRedirector", "\n", "}", "\n", "return", "ComponentNameUnknown", "\n", "}" ]

[ "ComponentNameFromString", "returns", "ComponentName", "from", "a", "string" ]

[ "func", "ResolveInstallStatus", "(", "version", "string", ",", "bundleVersion", "string", ",", "lastExitStatus", "string", ",", "log", "Log", ")", "(", "installStatus", "keybase1", ".", "InstallStatus", ",", "installAction", "keybase1", ".", "InstallAction", ",", "status", "keybase1", ".", "Status", ")", "{", "installStatus", "=", "keybase1", ".", "InstallStatus_UNKNOWN", "\n", "installAction", "=", "keybase1", ".", "InstallAction_UNKNOWN", "\n", "if", "version", "!=", "\"", "\"", "&&", "bundleVersion", "!=", "\"", "\"", "{", "sv", ",", "err", ":=", "semver", ".", "Make", "(", "version", ")", "\n", "if", "err", "!=", "nil", "{", "installStatus", "=", "keybase1", ".", "InstallStatus_ERROR", "\n", "installAction", "=", "keybase1", ".", "InstallAction_REINSTALL", "\n", "status", "=", "keybase1", ".", "StatusFromCode", "(", "keybase1", ".", "StatusCode_SCInvalidVersionError", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "bsv", ",", "err", ":=", "semver", ".", "Make", "(", "bundleVersion", ")", "\n", "// Invalid bundle version", "if", "err", "!=", "nil", "{", "installStatus", "=", "keybase1", ".", "InstallStatus_ERROR", "\n", "installAction", "=", "keybase1", ".", "InstallAction_NONE", "\n", "status", "=", "keybase1", ".", "StatusFromCode", "(", "keybase1", ".", "StatusCode_SCInvalidVersionError", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "if", "bsv", ".", "GT", "(", "sv", ")", "{", "installStatus", "=", "keybase1", ".", "InstallStatus_INSTALLED", "\n", "installAction", "=", "keybase1", ".", "InstallAction_UPGRADE", "\n", "}", "else", "if", "bsv", ".", "EQ", "(", "sv", ")", "{", "installStatus", "=", "keybase1", ".", "InstallStatus_INSTALLED", "\n", "installAction", "=", "keybase1", ".", "InstallAction_NONE", "\n", "}", "else", "if", "bsv", ".", "LT", "(", "sv", ")", "{", "// It's ok if we have a bundled version less than what was installed", "log", ".", "Warning", "(", "\"", "\"", ",", "bundleVersion", ",", "version", ")", "\n", "installStatus", "=", "keybase1", ".", "InstallStatus_INSTALLED", "\n", "installAction", "=", "keybase1", ".", "InstallAction_NONE", "\n", "}", "\n", "}", "else", "if", "version", "!=", "\"", "\"", "&&", "bundleVersion", "==", "\"", "\"", "{", "installStatus", "=", "keybase1", ".", "InstallStatus_INSTALLED", "\n", "}", "else", "if", "version", "==", "\"", "\"", "&&", "bundleVersion", "!=", "\"", "\"", "{", "installStatus", "=", "keybase1", ".", "InstallStatus_NOT_INSTALLED", "\n", "installAction", "=", "keybase1", ".", "InstallAction_INSTALL", "\n", "}", "\n\n", "// If we have an unknown install status, then let's try to re-install.", "if", "bundleVersion", "!=", "\"", "\"", "&&", "installStatus", "==", "keybase1", ".", "InstallStatus_UNKNOWN", "&&", "(", "version", "!=", "\"", "\"", "||", "lastExitStatus", "!=", "\"", "\"", ")", "{", "installAction", "=", "keybase1", ".", "InstallAction_REINSTALL", "\n", "installStatus", "=", "keybase1", ".", "InstallStatus_INSTALLED", "\n", "}", "\n\n", "status", "=", "keybase1", ".", "StatusOK", "(", "\"", "\"", ")", "\n", "return", "\n", "}" ]

[ "ResolveInstallStatus", "will", "determine", "necessary", "install", "actions", "for", "the", "current", "environment" ]

[ "func", "UpdaterBinPath", "(", ")", "(", "string", ",", "error", ")", "{", "path", ",", "err", ":=", "BinPath", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "name", ",", "err", ":=", "updaterBinName", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "filepath", ".", "Join", "(", "filepath", ".", "Dir", "(", "path", ")", ",", "name", ")", ",", "nil", "\n", "}" ]

[ "UpdaterBinPath", "returns", "the", "path", "to", "the", "updater", "executable", "by", "default", "is", "in", "the", "same", "directory", "as", "the", "keybase", "executable", "." ]

[ "func", "newBoxPublicSummaryFromTable", "(", "table", "boxPublicSummaryTable", ")", "(", "*", "boxPublicSummary", ",", "error", ")", "{", "ret", ":=", "boxPublicSummary", "{", "table", ":", "table", ",", "}", "\n", "err", ":=", "ret", ".", "encode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "ret", ",", "nil", "\n", "}" ]

[ "encode", "only", "ever", "gets", "called", "with", "the", "boxPublicSummary", "is", "being", "constructed", ".", "This", "means", "we", "don", "t", "allow", "mutation", ".", "Thus", "we", "just", "encode", "it", "once", "since", "if", "ever", "canonical", "encoding", "stops", "working", "it", "won", "t", "matter", "we", "ll", "still", "get", "consistent", "results", "." ]

[ "func", "(", "s", "*", "SecretStoreRevokableSecretService", ")", "GetUsersWithStoredSecrets", "(", "mctx", "MetaContext", ")", "(", "usernames", "[", "]", "string", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "identifierKeystore", ":=", "s", ".", "identifierKeystore", "(", "mctx", ")", "\n", "suffixedUsernames", ",", "err", ":=", "identifierKeystore", ".", "AllKeys", "(", "mctx", ",", "identifierKeystoreSuffix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "suffixedUsername", ":=", "range", "suffixedUsernames", "{", "usernames", "=", "append", "(", "usernames", ",", "strings", ".", "TrimSuffix", "(", "suffixedUsername", ",", "identifierKeystoreSuffix", ")", ")", "\n", "}", "\n", "return", "usernames", ",", "nil", "\n", "}" ]

[ "Note", "that", "in", "the", "case", "of", "corruption", "not", "all", "of", "these", "usernames", "may", "actually", "be", "able", "to", "be", "logged", "in", "as", "due", "to", "the", "noise", "file", "being", "corrupted", "the", "keyring", "being", "uninstalled", "etc", "." ]

[ "func", "identifyForReview", "(", "mctx", "libkb", ".", "MetaContext", ",", "assertion", "string", ",", "successCh", "chan", "<-", "struct", "{", "}", ",", "trackFailCh", "chan", "<-", "struct", "{", "}", ",", "errCh", "chan", "<-", "error", ")", "{", "// Goroutines that are blocked on otherwise unreachable channels are not GC'd.", "// So use ctx to clean up.", "sendSuccess", ":=", "func", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "assertion", ")", "\n", "select", "{", "case", "successCh", "<-", "struct", "{", "}", "{", "}", ":", "case", "<-", "mctx", ".", "Ctx", "(", ")", ".", "Done", "(", ")", ":", "}", "\n", "}", "\n", "sendTrackFail", ":=", "func", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "assertion", ")", "\n", "select", "{", "case", "trackFailCh", "<-", "struct", "{", "}", "{", "}", ":", "case", "<-", "mctx", ".", "Ctx", "(", ")", ".", "Done", "(", ")", ":", "}", "\n", "}", "\n", "sendErr", ":=", "func", "(", "err", "error", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "assertion", ",", "err", ")", "\n", "select", "{", "case", "errCh", "<-", "err", ":", "case", "<-", "mctx", ".", "Ctx", "(", ")", ".", "Done", "(", ")", ":", "}", "\n", "}", "\n\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "assertion", ")", "\n", "reason", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "assertion", ")", "\n", "eng", ":=", "engine", ".", "NewResolveThenIdentify2", "(", "mctx", ".", "G", "(", ")", ",", "&", "keybase1", ".", "Identify2Arg", "{", "UserAssertion", ":", "assertion", ",", "CanSuppressUI", ":", "true", ",", "NoErrorOnTrackFailure", ":", "true", ",", "// take heed", "Reason", ":", "keybase1", ".", "IdentifyReason", "{", "Reason", ":", "reason", "}", ",", "IdentifyBehavior", ":", "keybase1", ".", "TLFIdentifyBehavior_RESOLVE_AND_CHECK", ",", "}", ")", "\n", "err", ":=", "engine", ".", "RunEngine2", "(", "mctx", ",", "eng", ")", "\n", "if", "err", "!=", "nil", "{", "sendErr", "(", "err", ")", "\n", "return", "\n", "}", "\n", "idRes", ",", "err", ":=", "eng", ".", "Result", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "sendErr", "(", "err", ")", "\n", "return", "\n", "}", "\n", "if", "idRes", "==", "nil", "{", "sendErr", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ")", "\n", "return", "\n", "}", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "idRes", ".", "Upk", ".", "Current", ".", "ToUserVersion", "(", ")", ")", "\n", "if", "idRes", ".", "TrackBreaks", "!=", "nil", "{", "sendTrackFail", "(", ")", "\n", "return", "\n", "}", "\n", "sendSuccess", "(", ")", "\n", "}" ]

[ "identifyForReview", "runs", "identify", "on", "a", "user", "looking", "only", "for", "tracking", "breaks", ".", "Sends", "a", "value", "to", "exactly", "one", "of", "the", "three", "channels", "." ]

[ "func", "isFollowingForReview", "(", "mctx", "libkb", ".", "MetaContext", ",", "assertion", "string", ")", "(", "isFollowing", "bool", ",", "err", "error", ")", "{", "// The 'following' check blocks sending, and is not that important, so impose a timeout.", "var", "cancel", "func", "(", ")", "\n", "mctx", ",", "cancel", "=", "mctx", ".", "WithTimeout", "(", "time", ".", "Second", "*", "5", ")", "\n", "defer", "cancel", "(", ")", "\n", "err", "=", "mctx", ".", "G", "(", ")", ".", "GetFullSelfer", "(", ")", ".", "WithSelf", "(", "mctx", ".", "Ctx", "(", ")", ",", "func", "(", "u", "*", "libkb", ".", "User", ")", "error", "{", "idTable", ":=", "u", ".", "IDTable", "(", ")", "\n", "if", "idTable", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "targetUsername", ":=", "libkb", ".", "NewNormalizedUsername", "(", "assertion", ")", "\n", "for", "_", ",", "track", ":=", "range", "idTable", ".", "GetTrackList", "(", ")", "{", "if", "trackedUsername", ",", "err", ":=", "track", ".", "GetTrackedUsername", "(", ")", ";", "err", "==", "nil", "{", "if", "trackedUsername", ".", "Eq", "(", "targetUsername", ")", "{", "isFollowing", "=", "true", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "isFollowing", ",", "err", "\n", "}" ]

[ "Whether", "the", "logged", "-", "in", "user", "following", "the", "recipient", ".", "Unresolved", "assertions", "will", "false", "negative", "." ]

[ "func", "SubtractFeeSoft", "(", "mctx", "libkb", ".", "MetaContext", ",", "availableStr", "string", ",", "baseFee", "uint64", ")", "string", "{", "available", ",", "err", ":=", "stellarnet", ".", "ParseStellarAmount", "(", "availableStr", ")", "\n", "if", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "availableStr", "\n", "}", "\n", "available", "-=", "int64", "(", "baseFee", ")", "\n", "if", "available", "<", "0", "{", "available", "=", "0", "\n", "}", "\n", "return", "stellarnet", ".", "StringFromStellarAmount", "(", "available", ")", "\n", "}" ]

[ "Subtract", "baseFee", "from", "the", "available", "balance", ".", "This", "shows", "the", "real", "available", "balance", "assuming", "an", "intent", "to", "send", "a", "1", "op", "tx", ".", "Does", "not", "error", "out", "just", "shows", "the", "inaccurate", "answer", "." ]

[ "func", "(", "b", "*", "buildPaymentData", ")", "CheckReadyToSend", "(", "arg", "stellar1", ".", "SendPaymentLocalArg", ")", "error", "{", "if", "!", "b", ".", "ReadyToSend", "{", "if", "!", "b", ".", "ReadyToReview", "{", "// Payment is not even ready for review.", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// Payment is ready to review but has not been reviewed.", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "b", ".", "Frozen", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "arg", ".", "From", ".", "Eq", "(", "b", ".", "Frozen", ".", "From", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "arg", ".", "From", ",", "b", ".", "Frozen", ".", "From", ")", "\n", "}", "\n", "if", "arg", ".", "To", "!=", "b", ".", "Frozen", ".", "To", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "arg", ".", "To", ",", "b", ".", "Frozen", ".", "To", ")", "\n", "}", "\n", "if", "arg", ".", "ToIsAccountID", "!=", "b", ".", "Frozen", ".", "ToIsAccountID", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "b", ".", "Frozen", ".", "ToIsAccountID", ")", "\n", "}", "\n", "// Check the true amount and asset that will be sent.", "// Don't bother checking the display worth. It's finicky and the server does a coarse check.", "if", "arg", ".", "Amount", "!=", "b", ".", "Frozen", ".", "Amount", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "arg", ".", "Amount", ",", "b", ".", "Frozen", ".", "Amount", ")", "\n", "}", "\n", "if", "!", "arg", ".", "Asset", ".", "SameAsset", "(", "b", ".", "Frozen", ".", "Asset", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "arg", ".", "Asset", ",", "b", ".", "Frozen", ".", "Asset", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Ready", "decides", "whether", "the", "frozen", "payment", "has", "been", "prechecked", "and", "the", "Send", "request", "matches", "it", "." ]

[ "func", "GetEncodedTlfEditHistory", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "folderBranch", "data", ".", "FolderBranch", ")", "(", "data", "[", "]", "byte", ",", "t", "time", ".", "Time", ",", "err", "error", ")", "{", "edits", ",", "err", ":=", "config", ".", "KBFSOps", "(", ")", ".", "GetEditHistory", "(", "ctx", ",", "folderBranch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n\n", "data", ",", "err", "=", "PrettyJSON", "(", "edits", ")", "\n", "return", "data", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}" ]

[ "GetEncodedTlfEditHistory", "returns", "serialized", "JSON", "containing", "the", "file", "edit", "history", "for", "a", "folder", "." ]

[ "func", "MakeCryptoCommon", "(", "codec", "kbfscodec", ".", "Codec", ",", "blockCryptVersioner", "blockCryptVersioner", ")", "CryptoCommon", "{", "return", "CryptoCommon", "{", "codec", ",", "blockCryptVersioner", "}", "\n", "}" ]

[ "MakeCryptoCommon", "returns", "a", "default", "CryptoCommon", "object", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "MakeRandomTlfID", "(", "t", "tlf", ".", "Type", ")", "(", "tlf", ".", "ID", ",", "error", ")", "{", "return", "tlf", ".", "MakeRandomID", "(", "t", ")", "\n", "}" ]

[ "MakeRandomTlfID", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "MakeBlockRefNonce", "(", ")", "(", "nonce", "kbfsblock", ".", "RefNonce", ",", "err", "error", ")", "{", "return", "kbfsblock", ".", "MakeRefNonce", "(", ")", "\n", "}" ]

[ "MakeBlockRefNonce", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "MakeRandomTLFEphemeralKeys", "(", ")", "(", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "kbfscrypto", ".", "TLFEphemeralPrivateKey", ",", "error", ")", "{", "return", "kbfscrypto", ".", "MakeRandomTLFEphemeralKeys", "(", ")", "\n", "}" ]

[ "MakeRandomTLFEphemeralKeys", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "MakeRandomTLFKeys", "(", ")", "(", "kbfscrypto", ".", "TLFPublicKey", ",", "kbfscrypto", ".", "TLFPrivateKey", ",", "kbfscrypto", ".", "TLFCryptKey", ",", "error", ")", "{", "publicKey", ",", "privateKey", ",", "err", ":=", "box", ".", "GenerateKey", "(", "rand", ".", "Reader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFPublicKey", "{", "}", ",", "kbfscrypto", ".", "TLFPrivateKey", "{", "}", ",", "kbfscrypto", ".", "TLFCryptKey", "{", "}", ",", "errors", ".", "WithStack", "(", "err", ")", "\n", "}", "\n\n", "pubKey", ":=", "kbfscrypto", ".", "MakeTLFPublicKey", "(", "*", "publicKey", ")", "\n", "privKey", ":=", "kbfscrypto", ".", "MakeTLFPrivateKey", "(", "*", "privateKey", ")", "\n\n", "cryptKey", ",", "err", ":=", "kbfscrypto", ".", "MakeRandomTLFCryptKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFPublicKey", "{", "}", ",", "kbfscrypto", ".", "TLFPrivateKey", "{", "}", ",", "kbfscrypto", ".", "TLFCryptKey", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "pubKey", ",", "privKey", ",", "cryptKey", ",", "nil", "\n", "}" ]

[ "MakeRandomTLFKeys", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "EncryptPrivateMetadata", "(", "pmd", "PrivateMetadata", ",", "key", "kbfscrypto", ".", "TLFCryptKey", ")", "(", "encryptedPmd", "kbfscrypto", ".", "EncryptedPrivateMetadata", ",", "err", "error", ")", "{", "encodedPmd", ",", "err", ":=", "c", ".", "codec", ".", "Encode", "(", "pmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "EncryptedPrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "kbfscrypto", ".", "EncryptEncodedPrivateMetadata", "(", "encodedPmd", ",", "key", ")", "\n", "}" ]

[ "EncryptPrivateMetadata", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "DecryptPrivateMetadata", "(", "encryptedPmd", "kbfscrypto", ".", "EncryptedPrivateMetadata", ",", "key", "kbfscrypto", ".", "TLFCryptKey", ")", "(", "PrivateMetadata", ",", "error", ")", "{", "encodedPrivateMetadata", ",", "err", ":=", "kbfscrypto", ".", "DecryptPrivateMetadata", "(", "encryptedPmd", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "var", "pmd", "PrivateMetadata", "\n", "err", "=", "c", ".", "codec", ".", "Decode", "(", "encodedPrivateMetadata", ",", "&", "pmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "PrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "pmd", ",", "nil", "\n", "}" ]

[ "DecryptPrivateMetadata", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "EncryptBlock", "(", "block", "data", ".", "Block", ",", "tlfCryptKey", "kbfscrypto", ".", "TLFCryptKey", ",", "blockServerHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ")", "(", "plainSize", "int", ",", "encryptedBlock", "kbfscrypto", ".", "EncryptedBlock", ",", "err", "error", ")", "{", "encodedBlock", ",", "err", ":=", "c", ".", "codec", ".", "Encode", "(", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "kbfscrypto", ".", "EncryptedBlock", "{", "}", ",", "err", "\n", "}", "\n\n", "paddedBlock", ",", "err", ":=", "kbfscrypto", ".", "PadBlock", "(", "encodedBlock", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "kbfscrypto", ".", "EncryptedBlock", "{", "}", ",", "err", "\n", "}", "\n\n", "encryptedBlock", ",", "err", "=", "kbfscrypto", ".", "EncryptPaddedEncodedBlock", "(", "paddedBlock", ",", "tlfCryptKey", ",", "blockServerHalf", ",", "c", ".", "blockCryptVersioner", ".", "BlockCryptVersion", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "kbfscrypto", ".", "EncryptedBlock", "{", "}", ",", "err", "\n", "}", "\n\n", "plainSize", "=", "len", "(", "encodedBlock", ")", "\n", "return", "plainSize", ",", "encryptedBlock", ",", "nil", "\n", "}" ]

[ "EncryptBlock", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "c", "CryptoCommon", ")", "DecryptBlock", "(", "encryptedBlock", "kbfscrypto", ".", "EncryptedBlock", ",", "tlfCryptKey", "kbfscrypto", ".", "TLFCryptKey", ",", "blockServerHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "block", "data", ".", "Block", ")", "error", "{", "var", "paddedBlock", "[", "]", "byte", "\n", "paddedBlock", ",", "err", ":=", "kbfscrypto", ".", "DecryptBlock", "(", "encryptedBlock", ",", "tlfCryptKey", ",", "blockServerHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "encodedBlock", ",", "err", ":=", "kbfscrypto", ".", "DepadBlock", "(", "paddedBlock", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "c", ".", "codec", ".", "Decode", "(", "encodedBlock", ",", "&", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "WithStack", "(", "BlockDecodeError", "{", "err", "}", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DecryptBlock", "implements", "the", "Crypto", "interface", "for", "CryptoCommon", "." ]

[ "func", "(", "s", "*", "baseConversationSource", ")", "patchPaginationLast", "(", "ctx", "context", ".", "Context", ",", "conv", "types", ".", "UnboxConversationInfo", ",", "uid", "gregor1", ".", "UID", ",", "page", "*", "chat1", ".", "Pagination", ",", "msgs", "[", "]", "chat1", ".", "MessageUnboxed", ")", "{", "if", "page", "==", "nil", "||", "page", ".", "Last", "{", "return", "\n", "}", "\n", "if", "len", "(", "msgs", ")", "==", "0", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "page", ".", "Last", "=", "true", "\n", "return", "\n", "}", "\n", "expunge", ":=", "conv", ".", "GetExpunge", "(", ")", "\n", "if", "expunge", "==", "nil", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "end1", ":=", "msgs", "[", "0", "]", ".", "GetMessageID", "(", ")", "\n", "end2", ":=", "msgs", "[", "len", "(", "msgs", ")", "-", "1", "]", ".", "GetMessageID", "(", ")", "\n", "if", "end1", ".", "Min", "(", "end2", ")", "<=", "expunge", ".", "Upto", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "// If any message is prior to the nukepoint, say this is the last page.", "page", ".", "Last", "=", "true", "\n", "}", "\n", "}" ]

[ "patchPaginationLast", "turns", "on", "page", ".", "Last", "if", "the", "messages", "are", "before", "InboxSource", "s", "view", "of", "Expunge", "." ]

[ "func", "(", "s", "*", "HybridConversationSource", ")", "completeAttachmentUpload", "(", "ctx", "context", ".", "Context", ",", "msg", "chat1", ".", "MessageUnboxed", ")", "{", "if", "msg", ".", "GetMessageType", "(", ")", "==", "chat1", ".", "MessageType_ATTACHMENT", "{", "outboxID", ":=", "msg", ".", "OutboxID", "(", ")", "\n", "if", "outboxID", "!=", "nil", "{", "s", ".", "G", "(", ")", ".", "AttachmentUploader", ".", "Complete", "(", "ctx", ",", "*", "outboxID", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "completeAttachmentUpload", "removes", "any", "attachment", "previews", "from", "pending", "preview", "storage" ]

[ "func", "(", "s", "*", "HybridConversationSource", ")", "notifyReactionUpdates", "(", "ctx", "context", ".", "Context", ",", "uid", "gregor1", ".", "UID", ",", "convID", "chat1", ".", "ConversationID", ",", "msgs", "[", "]", "chat1", ".", "MessageUnboxed", ")", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "msgs", ")", ")", "\n", "if", "len", "(", "msgs", ")", ">", "0", "{", "conv", ",", "err", ":=", "utils", ".", "GetVerifiedConv", "(", "ctx", ",", "s", ".", "G", "(", ")", ",", "uid", ",", "convID", ",", "types", ".", "InboxSourceDataSourceAll", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "msgs", ",", "err", "=", "s", ".", "TransformSupersedes", "(", "ctx", ",", "conv", ",", "uid", ",", "msgs", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "reactionUpdates", ":=", "[", "]", "chat1", ".", "ReactionUpdate", "{", "}", "\n", "for", "_", ",", "msg", ":=", "range", "msgs", "{", "if", "msg", ".", "IsValid", "(", ")", "{", "reactionUpdates", "=", "append", "(", "reactionUpdates", ",", "chat1", ".", "ReactionUpdate", "{", "Reactions", ":", "msg", ".", "Valid", "(", ")", ".", "Reactions", ",", "TargetMsgID", ":", "msg", ".", "GetMessageID", "(", ")", ",", "}", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "reactionUpdates", ")", ">", "0", "{", "userReacjis", ":=", "storage", ".", "NewReacjiStore", "(", "s", ".", "G", "(", ")", ")", ".", "UserReacjis", "(", "ctx", ",", "uid", ")", "\n", "activity", ":=", "chat1", ".", "NewChatActivityWithReactionUpdate", "(", "chat1", ".", "ReactionUpdateNotif", "{", "UserReacjis", ":", "userReacjis", ",", "ReactionUpdates", ":", "reactionUpdates", ",", "ConvID", ":", "convID", ",", "}", ")", "\n", "s", ".", "G", "(", ")", ".", "ActivityNotifier", ".", "Activity", "(", "ctx", ",", "uid", ",", "conv", ".", "GetTopicType", "(", ")", ",", "&", "activity", ",", "chat1", ".", "ChatActivitySource_LOCAL", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "notifyReactionUpdates", "notifies", "the", "GUI", "after", "reactions", "are", "received" ]

[ "func", "(", "s", "*", "HybridConversationSource", ")", "notifyEphemeralPurge", "(", "ctx", "context", ".", "Context", ",", "uid", "gregor1", ".", "UID", ",", "convID", "chat1", ".", "ConversationID", ",", "explodedMsgs", "[", "]", "chat1", ".", "MessageUnboxed", ")", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "explodedMsgs", ")", ")", "\n", "if", "len", "(", "explodedMsgs", ")", ">", "0", "{", "// Blast out an EphemeralPurgeNotifInfo since it's time sensitive for the UI", "// to update.", "purgedMsgs", ":=", "[", "]", "chat1", ".", "UIMessage", "{", "}", "\n", "for", "_", ",", "msg", ":=", "range", "explodedMsgs", "{", "purgedMsgs", "=", "append", "(", "purgedMsgs", ",", "utils", ".", "PresentMessageUnboxed", "(", "ctx", ",", "s", ".", "G", "(", ")", ",", "msg", ",", "uid", ",", "convID", ")", ")", "\n", "}", "\n", "act", ":=", "chat1", ".", "NewChatActivityWithEphemeralPurge", "(", "chat1", ".", "EphemeralPurgeNotifInfo", "{", "ConvID", ":", "convID", ",", "Msgs", ":", "purgedMsgs", ",", "}", ")", "\n", "s", ".", "G", "(", ")", ".", "ActivityNotifier", ".", "Activity", "(", "ctx", ",", "uid", ",", "chat1", ".", "TopicType_CHAT", ",", "&", "act", ",", "chat1", ".", "ChatActivitySource_LOCAL", ")", "\n\n", "// Send an additional notification to refresh the thread after we bump", "// the local inbox version", "if", "err", ":=", "storage", ".", "NewInbox", "(", "s", ".", "G", "(", ")", ")", ".", "IncrementLocalConvVersion", "(", "ctx", ",", "uid", ",", "convID", ")", ";", "err", "!=", "nil", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "s", ".", "G", "(", ")", ".", "ActivityNotifier", ".", "ThreadsStale", "(", "ctx", ",", "uid", ",", "[", "]", "chat1", ".", "ConversationStaleUpdate", "{", "chat1", ".", "ConversationStaleUpdate", "{", "ConvID", ":", "convID", ",", "UpdateType", ":", "chat1", ".", "StaleUpdateType_CONVUPDATE", ",", "}", ",", "}", ")", "\n", "s", ".", "notifyUpdated", "(", "ctx", ",", "uid", ",", "convID", ",", "s", ".", "storage", ".", "GetExplodedReplies", "(", "ctx", ",", "convID", ",", "uid", ",", "explodedMsgs", ")", ")", "\n", "}", "\n", "}" ]

[ "notifyEphemeralPurge", "notifies", "the", "GUI", "after", "messages", "are", "exploded", "." ]

[ "func", "(", "s", "*", "HybridConversationSource", ")", "Expunge", "(", "ctx", "context", ".", "Context", ",", "convID", "chat1", ".", "ConversationID", ",", "uid", "gregor1", ".", "UID", ",", "expunge", "chat1", ".", "Expunge", ")", "(", "err", "error", ")", "{", "defer", "s", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "convID", ",", "uid", ",", "expunge", ".", "Upto", ")", "\n", "if", "expunge", ".", "Upto", "==", "0", "{", "// just get out of here as quickly as possible with a 0 upto", "return", "nil", "\n", "}", "\n\n", "s", ".", "lockTab", ".", "Acquire", "(", "ctx", ",", "uid", ",", "convID", ")", "\n", "defer", "s", ".", "lockTab", ".", "Release", "(", "ctx", ",", "uid", ",", "convID", ")", "\n", "mergeRes", ",", "err", ":=", "s", ".", "storage", ".", "Expunge", "(", "ctx", ",", "convID", ",", "uid", ",", "expunge", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "s", ".", "notifyExpunge", "(", "ctx", ",", "uid", ",", "convID", ",", "mergeRes", ")", "\n", "return", "nil", "\n", "}" ]

[ "Expunge", "from", "storage", "and", "maybe", "notify", "the", "gui", "of", "staleness" ]

[ "func", "(", "s", "*", "HybridConversationSource", ")", "mergeMaybeNotify", "(", "ctx", "context", ".", "Context", ",", "convID", "chat1", ".", "ConversationID", ",", "uid", "gregor1", ".", "UID", ",", "msgs", "[", "]", "chat1", ".", "MessageUnboxed", ")", "error", "{", "mergeRes", ",", "err", ":=", "s", ".", "storage", ".", "Merge", "(", "ctx", ",", "convID", ",", "uid", ",", "msgs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "s", ".", "notifyExpunge", "(", "ctx", ",", "uid", ",", "convID", ",", "mergeRes", ")", "\n", "s", ".", "notifyEphemeralPurge", "(", "ctx", ",", "uid", ",", "convID", ",", "mergeRes", ".", "Exploded", ")", "\n", "s", ".", "notifyReactionUpdates", "(", "ctx", ",", "uid", ",", "convID", ",", "mergeRes", ".", "ReactionTargets", ")", "\n", "s", ".", "notifyUpdated", "(", "ctx", ",", "uid", ",", "convID", ",", "mergeRes", ".", "UnfurlTargets", ")", "\n", "s", ".", "notifyUpdated", "(", "ctx", ",", "uid", ",", "convID", ",", "mergeRes", ".", "RepliesAffected", ")", "\n", "return", "nil", "\n", "}" ]

[ "Merge", "with", "storage", "and", "maybe", "notify", "the", "gui", "of", "staleness" ]

[ "func", "(", "s", "*", "HybridConversationSource", ")", "ClearFromDelete", "(", "ctx", "context", ".", "Context", ",", "uid", "gregor1", ".", "UID", ",", "convID", "chat1", ".", "ConversationID", ",", "deleteID", "chat1", ".", "MessageID", ")", "bool", "{", "defer", "s", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ",", "\"", "\"", ")", "(", ")", "\n\n", "// Check to see if we have the message stored", "stored", ",", "err", ":=", "s", ".", "storage", ".", "FetchMessages", "(", "ctx", ",", "convID", ",", "uid", ",", "[", "]", "chat1", ".", "MessageID", "{", "deleteID", "}", ")", "\n", "if", "err", "==", "nil", "&&", "stored", "[", "0", "]", "!=", "nil", "{", "// Any error is grounds to load this guy into the conv loader aggressively", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "false", "\n", "}", "\n\n", "// Fire off a background load of the thread with a post hook to delete the bodies cache", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "p", ":=", "&", "chat1", ".", "Pagination", "{", "Num", ":", "s", ".", "numExpungeReload", "}", "\n", "s", ".", "G", "(", ")", ".", "ConvLoader", ".", "Queue", "(", "ctx", ",", "types", ".", "NewConvLoaderJob", "(", "convID", ",", "nil", "/*query */", ",", "p", ",", "types", ".", "ConvLoaderPriorityHighest", ",", "func", "(", "ctx", "context", ".", "Context", ",", "tv", "chat1", ".", "ThreadView", ",", "job", "types", ".", "ConvLoaderJob", ")", "{", "if", "len", "(", "tv", ".", "Messages", ")", "==", "0", "{", "return", "\n", "}", "\n", "bound", ":=", "tv", ".", "Messages", "[", "0", "]", ".", "GetMessageID", "(", ")", ".", "Min", "(", "tv", ".", "Messages", "[", "len", "(", "tv", ".", "Messages", ")", "-", "1", "]", ".", "GetMessageID", "(", ")", ")", "\n", "if", "err", ":=", "s", ".", "storage", ".", "ClearBefore", "(", "ctx", ",", "convID", ",", "uid", ",", "bound", ")", ";", "err", "!=", "nil", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", ")", ")", "\n", "return", "true", "\n", "}" ]

[ "ClearFromDelete", "clears", "the", "current", "cache", "if", "there", "is", "a", "delete", "that", "we", "don", "t", "know", "about", "and", "returns", "true", "to", "the", "caller", "if", "it", "schedules", "a", "background", "loader", "job" ]

[ "func", "(", "pr", "PrevRevisions", ")", "AddRevision", "(", "r", ",", "minRev", "kbfsmd", ".", "Revision", ")", "(", "ret", "PrevRevisions", ")", "{", "newLength", ":=", "len", "(", "pr", ")", "\n", "if", "newLength", "<", "len", "(", "minPrevRevisionSlotCounts", ")", "{", "newLength", "++", "\n", "}", "\n", "ret", "=", "make", "(", "PrevRevisions", ",", "newLength", ")", "\n", "copy", "(", "ret", ",", "pr", ")", "\n", "earliestGoodSlot", ":=", "0", "\n", "numDropped", ":=", "0", "\n\n", "// First we eliminate any revisions in the current list that don't", "// make sense anymore, either because they're greater or equal to", "// `r`, or they're smaller or equal to `minRev` (and thus have", "// been GC'd). For example:", "//", "// pr = [27, 25, 15, 10, 5] (revision numbers only)", "// r = 27", "// minRev = 11", "//", "// After this next block, we should have:", "//", "// ret = [0, 25, 15, 0, 0]", "// earliestGoodSlot = 1", "// numDropped = 2", "//", "// Then the next block of code will trim it appropriately.", "for", "i", ",", "prc", ":=", "range", "ret", "{", "if", "prc", ".", "Count", "==", "255", "{", "// This count on this revision is too large, so remove it", "// before it overflows. This may happen when revisions", "// are repeatedly overwritten when on an unmerged branch,", "// as in the case below.", "ret", "[", "i", "]", "=", "PrevRevisionAndCount", "{", "Revision", ":", "kbfsmd", ".", "RevisionUninitialized", ",", "Count", ":", "0", ",", "}", "\n", "numDropped", "++", "\n", "continue", "\n", "}", "else", "if", "prc", ".", "Revision", ">=", "r", "{", "if", "numDropped", ">", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "// The revision number is bigger than expected (e.g. it", "// was made on an unmerged branch).", "ret", "[", "i", "]", "=", "PrevRevisionAndCount", "{", "Revision", ":", "kbfsmd", ".", "RevisionUninitialized", ",", "Count", ":", "0", ",", "}", "\n", "earliestGoodSlot", "=", "i", "+", "1", "\n", "continue", "\n", "}", "else", "if", "prc", ".", "Revision", "<=", "minRev", "{", "// This revision is too old (or is empty), so remove it.", "ret", "[", "i", "]", "=", "PrevRevisionAndCount", "{", "Revision", ":", "kbfsmd", ".", "RevisionUninitialized", ",", "Count", ":", "0", ",", "}", "\n", "numDropped", "++", "\n", "continue", "\n", "}", "else", "if", "numDropped", ">", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "// `minRev` < `prc.Revision` < `r`, so we keep it in the new", "// slice and increment its count.", "ret", "[", "i", "]", ".", "Count", "++", "\n", "}", "\n\n", "// Cut out the revisions that are newer than `r` (e.g., because", "// they are from an unmerged branch).", "//", "// Continuing the example above, this code will leave us with:", "//", "// ret = [25, 15, 0, 0]", "if", "earliestGoodSlot", ">", "0", "{", "if", "earliestGoodSlot", "==", "len", "(", "ret", ")", "{", "// Always leave at least one empty slot.", "earliestGoodSlot", "--", "\n", "}", "\n", "ret", "=", "ret", "[", "earliestGoodSlot", ":", "]", "\n", "}", "\n\n", "// Drop revisions off the end that are too old, but leave an empty", "// slot available at the end for shifting everything over and", "// putting `r` in slot 0.", "//", "// Continuing the example above, this code will leave us with:", "//", "// ret = [25, 15, 0]", "if", "numDropped", "==", "len", "(", "ret", ")", "{", "// Leave the first slot available for overwriting.", "ret", "=", "ret", "[", ":", "1", "]", "\n", "}", "else", "if", "numDropped", ">", "1", "{", "ret", "=", "ret", "[", ":", "len", "(", "ret", ")", "-", "(", "numDropped", "-", "1", ")", "]", "\n", "}", "\n\n", "// Starting at the end, shift revisions to the right if either a)", "// that slot is already empty or b) they satisfy the count of the", "// slot to the right. If a revision is not going to shifted, but", "// it is too close (in terms of count) to the revision on its", "// right, just drop it and let the other revisions slide over --", "// this makes sure we have a nicely-spaced set of revision numbers", "// even when the total number of revisions for the entry is small.", "//", "// Continuing the example above, this code will leave us with:", "//", "// ret = [0, 25, 15]", "for", "i", ":=", "len", "(", "ret", ")", "-", "1", ";", "i", ">=", "1", ";", "i", "--", "{", "// Check if we can shift over the entry in slot i-1.", "minCount", ":=", "minPrevRevisionSlotCounts", "[", "i", "]", "\n", "if", "ret", "[", "i", "]", ".", "Count", "==", "0", "||", "ret", "[", "i", "-", "1", "]", ".", "Count", ">=", "minCount", "{", "ret", "[", "i", "]", ",", "ret", "[", "i", "-", "1", "]", "=", "ret", "[", "i", "-", "1", "]", ",", "PrevRevisionAndCount", "{", "Revision", ":", "kbfsmd", ".", "RevisionUninitialized", ",", "Count", ":", "0", ",", "}", "\n", "}", "else", "if", "ret", "[", "i", "]", ".", "Count", "-", "ret", "[", "i", "-", "1", "]", ".", "Count", "<", "minCount", "/", "5", "{", "// This revision is not being shifted, but it's", "// uncomfortablely close to its neighbor on the right, so", "// just drop it.", "ret", "[", "i", "-", "1", "]", "=", "PrevRevisionAndCount", "{", "Revision", ":", "kbfsmd", ".", "RevisionUninitialized", ",", "Count", ":", "0", ",", "}", "\n", "}", "\n", "}", "\n\n", "// Finally, overwrite whatever's left in the first slot with `r`", "// and a count of 1.", "//", "// Continuing the example above, this code will leave us with:", "//", "// ret = [27, 25, 15]", "ret", "[", "0", "]", "=", "PrevRevisionAndCount", "{", "Revision", ":", "r", ",", "Count", ":", "1", ",", "}", "\n", "return", "ret", "\n", "}" ]

[ "AddRevision", "returns", "a", "copy", "of", "pr", "with", "a", "new", "immediately", "-", "previous", "revision", "added", "with", "the", "existing", "entries", "moved", "or", "overwritten", "to", "accomodate", "the", "new", "entry", "and", "with", "increased", "counts", ".", "Any", "existing", "revisions", "smaller", "than", "or", "equal", "to", "minRev", "will", "be", "removed", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "GetState", "(", "lState", "*", "kbfssync", ".", "LockState", ")", "overallBlockState", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n", "if", "len", "(", "fbo", ".", "dirtyFiles", ")", "==", "0", "&&", "len", "(", "fbo", ".", "dirtyDirs", ")", "==", "0", "&&", "fbo", ".", "dirtyRootDirEntry", "==", "nil", "{", "return", "cleanState", "\n", "}", "\n", "return", "dirtyState", "\n", "}" ]

[ "GetState", "returns", "the", "overall", "block", "state", "of", "this", "TLF", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "getCleanEncodedBlockSizeLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "ptr", "data", ".", "BlockPointer", ",", "branch", "data", ".", "BranchName", ",", "rtype", "data", ".", "BlockReqType", ",", "assumeCacheIsLive", "bool", ")", "(", "size", "uint32", ",", "status", "keybase1", ".", "BlockStatus", ",", "err", "error", ")", "{", "if", "rtype", "!=", "data", ".", "BlockReadParallel", "{", "if", "rtype", "==", "data", ".", "BlockWrite", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "fbo", ".", "blockLock", ".", "AssertAnyLocked", "(", "lState", ")", "\n", "}", "else", "if", "lState", "!=", "nil", "{", "panic", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "ptr", ".", "IsValid", "(", ")", "{", "return", "0", ",", "0", ",", "InvalidBlockRefError", "{", "ptr", ".", "Ref", "(", ")", "}", "\n", "}", "\n\n", "if", "assumeCacheIsLive", "{", "// If we're assuming all blocks in the cache are live, we just", "// need to get the block size, which we can do from either one", "// of the caches.", "if", "block", ",", "err", ":=", "fbo", ".", "config", ".", "BlockCache", "(", ")", ".", "Get", "(", "ptr", ")", ";", "err", "==", "nil", "{", "return", "block", ".", "GetEncodedSize", "(", ")", ",", "keybase1", ".", "BlockStatus_LIVE", ",", "nil", "\n", "}", "\n", "if", "diskBCache", ":=", "fbo", ".", "config", ".", "DiskBlockCache", "(", ")", ";", "diskBCache", "!=", "nil", "{", "cacheType", ":=", "DiskBlockAnyCache", "\n", "if", "fbo", ".", "config", ".", "IsSyncedTlf", "(", "fbo", ".", "id", "(", ")", ")", "{", "cacheType", "=", "DiskBlockSyncCache", "\n", "}", "\n", "if", "buf", ",", "_", ",", "_", ",", "err", ":=", "diskBCache", ".", "Get", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ",", "ptr", ".", "ID", ",", "cacheType", ")", ";", "err", "==", "nil", "{", "return", "uint32", "(", "len", "(", "buf", ")", ")", ",", "keybase1", ".", "BlockStatus_LIVE", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "checkDataVersion", "(", "fbo", ".", "config", ",", "data", ".", "Path", "{", "}", ",", "ptr", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "ptr", ",", "size", ",", "status", ",", "err", ")", "\n", "// In certain testing situations, a block might be represented", "// with a 0 size in our journal or be missing from our local", "// data stores, and we need to reconstruct the size using the", "// cache in order to make the accounting work out for the test.", "_", ",", "isBlockNotFound", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "kbfsblock", ".", "ServerErrorBlockNonExistent", ")", "\n", "if", "isBlockNotFound", "||", "size", "==", "0", "{", "if", "block", ",", "cerr", ":=", "fbo", ".", "config", ".", "BlockCache", "(", ")", ".", "Get", "(", "ptr", ")", ";", "cerr", "==", "nil", "{", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "ptr", ")", "\n", "size", "=", "block", ".", "GetEncodedSize", "(", ")", "\n", "err", "=", "nil", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Unlock the blockLock while we wait for the network, only if", "// it's locked for reading by a single goroutine. If it's locked", "// for writing, that indicates we are performing an atomic write", "// operation, and we need to ensure that nothing else comes in and", "// modifies the blocks, so don't unlock.", "//", "// If there may be multiple goroutines fetching blocks under the", "// same lState, we can't safely unlock since some of the other", "// goroutines may be operating on the data assuming they have the", "// lock.", "bops", ":=", "fbo", ".", "config", ".", "BlockOps", "(", ")", "\n", "if", "rtype", "!=", "data", ".", "BlockReadParallel", "&&", "rtype", "!=", "data", ".", "BlockLookup", "{", "fbo", ".", "blockLock", ".", "DoRUnlockedIfPossible", "(", "lState", ",", "func", "(", "*", "kbfssync", ".", "LockState", ")", "{", "size", ",", "status", ",", "err", "=", "bops", ".", "GetEncodedSize", "(", "ctx", ",", "kmd", ",", "ptr", ")", "\n", "}", ")", "\n", "}", "else", "{", "size", ",", "status", ",", "err", "=", "bops", ".", "GetEncodedSize", "(", "ctx", ",", "kmd", ",", "ptr", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "err", "\n", "}", "\n\n", "return", "size", ",", "status", ",", "nil", "\n", "}" ]

[ "getCleanEncodedBlockHelperLocked", "retrieves", "the", "encoded", "size", "of", "the", "clean", "block", "pointed", "to", "by", "ptr", "which", "must", "be", "valid", "either", "from", "the", "cache", "or", "from", "the", "server", ".", "If", "rtype", "is", "blockReadParallel", "it", "s", "assumed", "that", "some", "coordinating", "goroutine", "is", "holding", "the", "correct", "locks", "and", "in", "that", "case", "lState", "must", "be", "nil", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "ClearChargedTo", "(", "lState", "*", "kbfssync", ".", "LockState", ")", "{", "fbo", ".", "blockLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "Unlock", "(", "lState", ")", "\n", "fbo", ".", "chargedTo", "=", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", "\n", "}" ]

[ "ClearChargedTo", "clears", "out", "the", "cached", "chargedTo", "UID", "for", "this", "FBO", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "deepCopyFileLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "file", "data", ".", "Path", ",", "dirtyBcache", "data", ".", "DirtyBlockCacheSimple", ",", "dataVer", "data", ".", "Ver", ")", "(", "newTopPtr", "data", ".", "BlockPointer", ",", "allChildPtrs", "[", "]", "data", ".", "BlockPointer", ",", "err", "error", ")", "{", "// Deep copying doesn't alter any data in use, it only makes copy,", "// so only a read lock is needed.", "fbo", ".", "blockLock", ".", "AssertRLocked", "(", "lState", ")", "\n", "chargedTo", ",", "err", ":=", "chargedToForTLF", "(", "ctx", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ",", "kmd", ".", "GetTlfHandle", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "data", ".", "BlockPointer", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "fd", ":=", "fbo", ".", "newFileDataWithCache", "(", "lState", ",", "file", ",", "chargedTo", ",", "kmd", ",", "dirtyBcache", ")", "\n", "return", "fd", ".", "DeepCopy", "(", "ctx", ",", "dataVer", ")", "\n", "}" ]

[ "DeepCopyFile", "makes", "a", "complete", "copy", "of", "the", "given", "file", "deduping", "leaf", "blocks", "and", "making", "new", "random", "BlockPointers", "for", "all", "indirect", "blocks", ".", "It", "returns", "the", "new", "top", "pointer", "of", "the", "copy", "and", "all", "the", "new", "child", "pointers", "in", "the", "copy", ".", "It", "takes", "a", "custom", "DirtyBlockCache", "which", "directs", "where", "the", "resulting", "block", "copies", "are", "stored", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "newDirDataWithDBMLocked", "(", "lState", "*", "kbfssync", ".", "LockState", ",", "dir", "data", ".", "Path", ",", "chargedTo", "keybase1", ".", "UserOrTeamID", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "dbm", "dirBlockMap", ")", "*", "data", ".", "DirData", "{", "fbo", ".", "blockLock", ".", "AssertRLocked", "(", "lState", ")", "\n", "return", "data", ".", "NewDirData", "(", "dir", ",", "chargedTo", ",", "fbo", ".", "config", ".", "BlockSplitter", "(", ")", ",", "kmd", ",", "func", "(", "ctx", "context", ".", "Context", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "ptr", "data", ".", "BlockPointer", ",", "dir", "data", ".", "Path", ",", "rtype", "data", ".", "BlockReqType", ")", "(", "*", "data", ".", "DirBlock", ",", "bool", ",", "error", ")", "{", "hasBlock", ",", "err", ":=", "dbm", ".", "hasBlock", "(", "ctx", ",", "ptr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n", "if", "hasBlock", "{", "block", ",", "err", ":=", "dbm", ".", "getBlock", "(", "ctx", ",", "ptr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n", "return", "block", ",", "true", ",", "nil", "\n", "}", "\n\n", "localLState", ":=", "lState", "\n", "getRtype", ":=", "rtype", "\n", "switch", "rtype", "{", "case", "data", ".", "BlockReadParallel", ":", "localLState", "=", "nil", "\n", "case", "data", ".", "BlockWrite", ":", "getRtype", "=", "data", ".", "BlockRead", "\n", "}", "\n\n", "block", ",", "wasDirty", ",", "err", ":=", "fbo", ".", "getDirLocked", "(", "ctx", ",", "localLState", ",", "kmd", ",", "ptr", ",", "dir", ",", "getRtype", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "if", "rtype", "==", "data", ".", "BlockWrite", "{", "// Make a copy before we stick it in the local block cache.", "block", "=", "block", ".", "DeepCopy", "(", ")", "\n", "err", "=", "dbm", ".", "putBlock", "(", "ctx", ",", "ptr", ",", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n", "}", "\n", "return", "block", ",", "wasDirty", ",", "nil", "\n", "}", ",", "func", "(", "ctx", "context", ".", "Context", ",", "ptr", "data", ".", "BlockPointer", ",", "block", "data", ".", "Block", ")", "error", "{", "return", "dbm", ".", "putBlock", "(", "ctx", ",", "ptr", ",", "block", ".", "(", "*", "data", ".", "DirBlock", ")", ")", "\n", "}", ",", "fbo", ".", "log", ",", "fbo", ".", "vlog", ")", "\n", "}" ]

[ "newDirDataWithDBMLocked", "creates", "a", "new", "dirData", "that", "reads", "from", "and", "puts", "into", "a", "local", "dir", "block", "cache", ".", "If", "it", "reads", "a", "block", "out", "from", "anything", "but", "the", "dbm", "it", "makes", "a", "copy", "of", "it", "before", "inserting", "it", "into", "the", "dbm", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "newDirDataWithDBM", "(", "lState", "*", "kbfssync", ".", "LockState", ",", "dir", "data", ".", "Path", ",", "chargedTo", "keybase1", ".", "UserOrTeamID", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "dbm", "dirBlockMap", ")", "(", "*", "data", ".", "DirData", ",", "func", "(", ")", ")", "{", "// Lock and fetch for reading only, we want any dirty", "// blocks to go into the dbm.", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "cleanupFn", ":=", "func", "(", ")", "{", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "}", "\n", "return", "fbo", ".", "newDirDataWithDBMLocked", "(", "lState", ",", "dir", ",", "chargedTo", ",", "kmd", ",", "dbm", ")", ",", "cleanupFn", "\n", "}" ]

[ "newDirDataWithDBM", "is", "like", "newDirDataWithDBMLocked", "but", "it", "must", "be", "called", "with", "blockLock", "unlocked", "and", "the", "returned", "function", "must", "be", "called", "when", "the", "returned", "dirData", "is", "no", "longer", "in", "use", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "AddDirEntryInCache", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "dir", "data", ".", "Path", ",", "newName", "string", ",", "newDe", "data", ".", "DirEntry", ")", "(", "dirCacheUndoFn", ",", "error", ")", "{", "fbo", ".", "blockLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "Unlock", "(", "lState", ")", "\n", "fn", ",", "err", ":=", "fbo", ".", "addDirEntryInCacheLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "dir", ",", "newName", ",", "newDe", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "fbo", ".", "wrapWithBlockLock", "(", "fn", ")", ",", "nil", "\n", "}" ]

[ "AddDirEntryInCache", "adds", "a", "brand", "new", "entry", "to", "the", "given", "directory", "and", "updates", "the", "directory", "s", "own", "mtime", "and", "ctime", ".", "It", "returns", "a", "function", "that", "can", "be", "called", "if", "the", "change", "needs", "to", "be", "undone", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "SetAttrInDirEntryInCache", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "p", "data", ".", "Path", ",", "newDe", "data", ".", "DirEntry", ",", "attr", "attrChange", ")", "(", "dirCacheUndoFn", ",", "error", ")", "{", "fbo", ".", "blockLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "Unlock", "(", "lState", ")", "\n", "return", "fbo", ".", "setCachedAttrLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "*", "p", ".", "ParentPath", "(", ")", ",", "p", ".", "TailName", "(", ")", ",", "attr", ",", "newDe", ")", "\n", "}" ]

[ "SetAttrInDirEntryInCache", "updates", "an", "entry", "from", "the", "given", "directory", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "GetDirtyDirCopy", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "dir", "data", ".", "Path", ",", "rtype", "data", ".", "BlockReqType", ")", "(", "*", "data", ".", "DirBlock", ",", "error", ")", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n", "dblock", ",", "err", ":=", "fbo", ".", "getDirtyDirLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "dir", ",", "rtype", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Copy it while under lock. Otherwise, another operation like", "// `Write` can modify it while the caller is trying to copy it,", "// leading to a panic like in KBFS-3407.", "return", "dblock", ".", "DeepCopy", "(", ")", ",", "nil", "\n", "}" ]

[ "GetDirtyDirCopy", "returns", "a", "deep", "copy", "of", "the", "directory", "block", "for", "a", "dirty", "directory", "while", "under", "lock", "updated", "with", "all", "cached", "dirty", "entries", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "updateEntryLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "file", "data", ".", "Path", ",", "de", "data", ".", "DirEntry", ",", "includeDeleted", "bool", ")", "error", "{", "fbo", ".", "blockLock", ".", "AssertAnyLocked", "(", "lState", ")", "\n\n", "chargedTo", ",", "err", ":=", "fbo", ".", "getChargedToLocked", "(", "ctx", ",", "lState", ",", "kmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "parentPath", ":=", "*", "file", ".", "ParentPath", "(", ")", "\n", "dd", ":=", "fbo", ".", "newDirDataLocked", "(", "lState", ",", "parentPath", ",", "chargedTo", ",", "kmd", ")", "\n", "unrefs", ",", "err", ":=", "dd", ".", "UpdateEntry", "(", "ctx", ",", "file", ".", "TailName", "(", ")", ",", "de", ")", "\n", "_", ",", "noExist", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "idutil", ".", "NoSuchNameError", ")", "\n", "if", "noExist", "&&", "includeDeleted", "{", "unlinkedNode", ":=", "fbo", ".", "nodeCache", ".", "Get", "(", "file", ".", "TailPointer", "(", ")", ".", "Ref", "(", ")", ")", "\n", "if", "unlinkedNode", "!=", "nil", "&&", "fbo", ".", "nodeCache", ".", "IsUnlinked", "(", "unlinkedNode", ")", "{", "fbo", ".", "nodeCache", ".", "UpdateUnlinkedDirEntry", "(", "unlinkedNode", ",", "de", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "_", "=", "fbo", ".", "makeDirDirtyLocked", "(", "lState", ",", "parentPath", ".", "TailPointer", "(", ")", ",", "unrefs", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "file", "must", "have", "a", "valid", "parent", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "GetEntry", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "file", "data", ".", "Path", ")", "(", "data", ".", "DirEntry", ",", "error", ")", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n", "return", "fbo", ".", "getEntryLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "file", ",", "false", ")", "\n", "}" ]

[ "GetEntry", "returns", "the", "possibly", "-", "dirty", "DirEntry", "of", "the", "given", "file", "in", "its", "parent", "DirBlock", ".", "file", "must", "have", "a", "valid", "parent", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "Lookup", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "dir", "Node", ",", "name", "string", ")", "(", "Node", ",", "data", ".", "DirEntry", ",", "error", ")", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n\n", "dirPath", ":=", "fbo", ".", "nodeCache", ".", "PathFromNode", "(", "dir", ")", "\n", "if", "!", "dirPath", ".", "IsValid", "(", ")", "{", "return", "nil", ",", "data", ".", "DirEntry", "{", "}", ",", "errors", ".", "WithStack", "(", "InvalidPathError", "{", "dirPath", "}", ")", "\n", "}", "\n\n", "childPath", ":=", "dirPath", ".", "ChildPathNoPtr", "(", "name", ")", "\n", "de", ",", "err", ":=", "fbo", ".", "getEntryLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "childPath", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "data", ".", "DirEntry", "{", "}", ",", "err", "\n", "}", "\n\n", "node", ",", "err", ":=", "fbo", ".", "getChildNodeLocked", "(", "lState", ",", "dir", ",", "name", ",", "de", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "data", ".", "DirEntry", "{", "}", ",", "err", "\n", "}", "\n", "return", "node", ",", "de", ",", "nil", "\n", "}" ]

[ "Lookup", "returns", "the", "possibly", "-", "dirty", "DirEntry", "of", "the", "given", "file", "in", "its", "parent", "DirBlock", "and", "a", "Node", "for", "the", "file", "if", "it", "exists", ".", "It", "has", "to", "do", "all", "of", "this", "under", "the", "block", "lock", "to", "avoid", "races", "with", "UpdatePointers", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "cacheBlockIfNotYetDirtyLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "ptr", "data", ".", "BlockPointer", ",", "file", "data", ".", "Path", ",", "block", "data", ".", "Block", ")", "error", "{", "fbo", ".", "blockLock", ".", "AssertLocked", "(", "lState", ")", "\n", "df", ":=", "fbo", ".", "getOrCreateDirtyFileLocked", "(", "lState", ",", "file", ")", "\n", "needsCaching", ",", "isSyncing", ":=", "df", ".", "SetBlockDirty", "(", "ptr", ")", "\n\n", "if", "needsCaching", "{", "err", ":=", "fbo", ".", "config", ".", "DirtyBlockCache", "(", ")", ".", "Put", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ",", "ptr", ",", "file", ".", "Branch", ",", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "isSyncing", "{", "fbo", ".", "doDeferWrite", "=", "true", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cacheBlockIfNotYetDirtyLocked", "puts", "a", "block", "into", "the", "cache", "but", "only", "does", "so", "if", "the", "block", "isn", "t", "already", "marked", "as", "dirty", "in", "the", "cache", ".", "This", "is", "useful", "when", "operating", "on", "a", "dirty", "copy", "of", "a", "block", "that", "may", "already", "be", "in", "the", "cache", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "GetDirtyFileBlockRefs", "(", "lState", "*", "kbfssync", ".", "LockState", ")", "[", "]", "data", ".", "BlockRef", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n", "var", "dirtyRefs", "[", "]", "data", ".", "BlockRef", "\n", "for", "ref", ":=", "range", "fbo", ".", "unrefCache", "{", "dirtyRefs", "=", "append", "(", "dirtyRefs", ",", "ref", ")", "\n", "}", "\n", "return", "dirtyRefs", "\n", "}" ]

[ "GetDirtyFileBlockRefs", "returns", "a", "list", "of", "references", "of", "all", "known", "dirty", "files", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "GetDirtyDirBlockRefs", "(", "lState", "*", "kbfssync", ".", "LockState", ")", "[", "]", "data", ".", "BlockRef", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n", "var", "dirtyRefs", "[", "]", "data", ".", "BlockRef", "\n", "for", "ptr", ":=", "range", "fbo", ".", "dirtyDirs", "{", "dirtyRefs", "=", "append", "(", "dirtyRefs", ",", "ptr", ".", "Ref", "(", ")", ")", "\n", "}", "\n", "return", "dirtyRefs", "\n", "}" ]

[ "GetDirtyDirBlockRefs", "returns", "a", "list", "of", "references", "of", "all", "known", "dirty", "directories", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "getDirtyDirUnrefsLocked", "(", "lState", "*", "kbfssync", ".", "LockState", ",", "ptr", "data", ".", "BlockPointer", ")", "[", "]", "data", ".", "BlockInfo", "{", "fbo", ".", "blockLock", ".", "AssertRLocked", "(", "lState", ")", "\n", "return", "fbo", ".", "dirtyDirs", "[", "ptr", "]", "\n", "}" ]

[ "getDirtyDirUnrefsLocked", "returns", "a", "list", "of", "block", "infos", "that", "need", "to", "be", "unreferenced", "for", "the", "given", "directory", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "Read", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "file", "Node", ",", "dest", "[", "]", "byte", ",", "off", "int64", ")", "(", "int64", ",", "error", ")", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n\n", "filePath", ":=", "fbo", ".", "nodeCache", ".", "PathFromNode", "(", "file", ")", "\n\n", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "filePath", ".", "TailPointer", "(", ")", ")", "\n\n", "var", "id", "keybase1", ".", "UserOrTeamID", "// Data reads don't depend on the id.", "\n", "fd", ":=", "fbo", ".", "newFileData", "(", "lState", ",", "filePath", ",", "id", ",", "kmd", ")", "\n", "return", "fd", ".", "Read", "(", "ctx", ",", "dest", ",", "data", ".", "Int64Offset", "(", "off", ")", ")", "\n", "}" ]

[ "Read", "reads", "from", "the", "given", "file", "into", "the", "given", "buffer", "at", "the", "given", "offset", ".", "It", "returns", "the", "number", "of", "bytes", "read", "and", "nil", "or", "0", "and", "the", "error", "if", "there", "was", "one", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "writeGetFileLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "file", "data", ".", "Path", ")", "(", "*", "data", ".", "FileBlock", ",", "error", ")", "{", "fbo", ".", "blockLock", ".", "AssertLocked", "(", "lState", ")", "\n\n", "session", ",", "err", ":=", "fbo", ".", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "isWriter", ",", "err", ":=", "kmd", ".", "IsWriter", "(", "ctx", ",", "fbo", ".", "config", ".", "KBPKI", "(", ")", ",", "fbo", ".", "config", ",", "session", ".", "UID", ",", "session", ".", "VerifyingKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "!", "isWriter", "{", "return", "nil", ",", "tlfhandle", ".", "NewWriteAccessError", "(", "kmd", ".", "GetTlfHandle", "(", ")", ",", "session", ".", "Name", ",", "file", ".", "String", "(", ")", ")", "\n", "}", "\n", "fblock", ",", "err", ":=", "fbo", ".", "getFileLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "file", ",", "data", ".", "BlockWrite", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "fblock", ",", "nil", "\n", "}" ]

[ "writeGetFileLocked", "checks", "write", "permissions", "explicitly", "for", "writeDataLocked", "truncateLocked", "etc", "and", "returns" ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "truncateExtendLocked", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "file", "data", ".", "Path", ",", "size", "uint64", ",", "parentBlocks", "[", "]", "data", ".", "ParentBlockAndChildIndex", ")", "(", "WriteRange", ",", "[", "]", "data", ".", "BlockPointer", ",", "error", ")", "{", "fblock", ",", "err", ":=", "fbo", ".", "writeGetFileLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "WriteRange", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n\n", "chargedTo", ",", "err", ":=", "fbo", ".", "getChargedToLocked", "(", "ctx", ",", "lState", ",", "kmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "WriteRange", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n\n", "fd", ":=", "fbo", ".", "newFileData", "(", "lState", ",", "file", ",", "chargedTo", ",", "kmd", ")", "\n\n", "de", ",", "err", ":=", "fbo", ".", "getEntryLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "file", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "WriteRange", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "df", ":=", "fbo", ".", "getOrCreateDirtyFileLocked", "(", "lState", ",", "file", ")", "\n", "newDe", ",", "dirtyPtrs", ",", "err", ":=", "fd", ".", "TruncateExtend", "(", "ctx", ",", "size", ",", "fblock", ",", "parentBlocks", ",", "de", ",", "df", ")", "\n", "if", "err", "!=", "nil", "{", "return", "WriteRange", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n\n", "now", ":=", "fbo", ".", "nowUnixNano", "(", ")", "\n", "newDe", ".", "Mtime", "=", "now", "\n", "newDe", ".", "Ctime", "=", "now", "\n", "err", "=", "fbo", ".", "updateEntryLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "file", ",", "newDe", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "WriteRange", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n\n", "si", ",", "err", ":=", "fbo", ".", "getOrCreateSyncInfoLocked", "(", "lState", ",", "de", ")", "\n", "if", "err", "!=", "nil", "{", "return", "WriteRange", "{", "}", ",", "nil", ",", "err", "\n", "}", "\n", "latestWrite", ":=", "si", ".", "op", ".", "addTruncate", "(", "size", ")", "\n\n", "if", "fbo", ".", "config", ".", "DirtyBlockCache", "(", ")", ".", "ShouldForceSync", "(", "fbo", ".", "id", "(", ")", ")", "{", "select", "{", "// If we can't send on the channel, that means a sync is", "// already in progress", "case", "fbo", ".", "forceSyncChan", "<-", "struct", "{", "}", "{", "}", ":", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ")", "\n", "default", ":", "}", "\n", "}", "\n\n", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ")", "\n", "return", "latestWrite", ",", "dirtyPtrs", ",", "nil", "\n", "}" ]

[ "truncateExtendLocked", "is", "called", "by", "truncateLocked", "to", "extend", "a", "file", "and", "creates", "a", "hole", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "Truncate", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "file", "Node", ",", "size", "uint64", ")", "error", "{", "// If there is too much unflushed data, we should wait until some", "// of it gets flush so our memory usage doesn't grow without", "// bound.", "//", "// Assume the whole remaining file will be dirty after this", "// truncate. TODO: try to figure out how many bytes actually will", "// be dirtied ahead of time?", "c", ",", "err", ":=", "fbo", ".", "config", ".", "DirtyBlockCache", "(", ")", ".", "RequestPermissionToDirty", "(", "ctx", ",", "fbo", ".", "id", "(", ")", ",", "int64", "(", "size", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "fbo", ".", "config", ".", "DirtyBlockCache", "(", ")", ".", "UpdateUnsyncedBytes", "(", "fbo", ".", "id", "(", ")", ",", "-", "int64", "(", "size", ")", ",", "false", ")", "\n", "err", "=", "fbo", ".", "maybeWaitOnDeferredWrites", "(", "ctx", ",", "lState", ",", "file", ",", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "fbo", ".", "blockLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "Unlock", "(", "lState", ")", "\n\n", "filePath", ",", "err", ":=", "fbo", ".", "pathFromNodeForBlockWriteLocked", "(", "lState", ",", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "fbo", ".", "doDeferWrite", "=", "false", "\n", "}", "(", ")", "\n\n", "latestWrite", ",", "dirtyPtrs", ",", "newlyDirtiedChildBytes", ",", "err", ":=", "fbo", ".", "truncateLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "filePath", ",", "size", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "latestWrite", "!=", "nil", "{", "fbo", ".", "observers", ".", "localChange", "(", "ctx", ",", "file", ",", "*", "latestWrite", ")", "\n", "}", "\n\n", "if", "fbo", ".", "doDeferWrite", "{", "// There's an ongoing sync, and this truncate altered", "// dirty blocks that are in the process of syncing. So,", "// we have to redo this truncate once the sync is complete,", "// using the new file path.", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "filePath", ".", "TailPointer", "(", ")", ")", "\n", "ds", ":=", "fbo", ".", "deferred", "[", "filePath", ".", "TailRef", "(", ")", "]", "\n", "ds", ".", "dirtyDeletes", "=", "append", "(", "ds", ".", "dirtyDeletes", ",", "dirtyPtrs", "...", ")", "\n", "ds", ".", "writes", "=", "append", "(", "ds", ".", "writes", ",", "func", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "kmd", "KeyMetadataWithRootDirEntry", ",", "f", "data", ".", "Path", ")", "error", "{", "// We are about to re-dirty these bytes, so mark that", "// they will no longer be synced via the old file.", "df", ":=", "fbo", ".", "getOrCreateDirtyFileLocked", "(", "lState", ",", "filePath", ")", "\n", "df", ".", "UpdateNotYetSyncingBytes", "(", "-", "newlyDirtiedChildBytes", ")", "\n\n", "// Truncate the file again. We know this won't be", "// deferred, so no need to check the new ptrs.", "_", ",", "_", ",", "_", ",", "err", ":=", "fbo", ".", "truncateLocked", "(", "ctx", ",", "lState", ",", "kmd", ",", "f", ",", "size", ")", "\n", "return", "err", "\n", "}", ")", "\n", "ds", ".", "waitBytes", "+=", "newlyDirtiedChildBytes", "\n", "fbo", ".", "deferred", "[", "filePath", ".", "TailRef", "(", ")", "]", "=", "ds", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Truncate", "truncates", "or", "extends", "the", "given", "file", "to", "the", "given", "size", ".", "May", "block", "if", "there", "is", "too", "much", "unflushed", "data", ";", "in", "that", "case", "it", "will", "be", "unblocked", "by", "a", "future", "sync", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "IsDirty", "(", "lState", "*", "kbfssync", ".", "LockState", ",", "file", "data", ".", "Path", ")", "bool", "{", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n", "// A dirty file should probably match all three of these, but", "// check them individually just in case.", "if", "fbo", ".", "config", ".", "DirtyBlockCache", "(", ")", ".", "IsDirty", "(", "fbo", ".", "id", "(", ")", ",", "file", ".", "TailPointer", "(", ")", ",", "file", ".", "Branch", ")", "{", "return", "true", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "fbo", ".", "dirtyFiles", "[", "file", ".", "TailPointer", "(", ")", "]", ";", "ok", "{", "return", "ok", "\n", "}", "\n\n", "_", ",", "ok", ":=", "fbo", ".", "unrefCache", "[", "file", ".", "TailRef", "(", ")", "]", "\n", "return", "ok", "\n", "}" ]

[ "IsDirty", "returns", "whether", "the", "given", "file", "is", "dirty", ";", "if", "false", "is", "returned", "then", "the", "file", "doesn", "t", "need", "to", "be", "synced", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "ClearCacheInfo", "(", "lState", "*", "kbfssync", ".", "LockState", ",", "file", "data", ".", "Path", ")", "error", "{", "fbo", ".", "blockLock", ".", "Lock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "Unlock", "(", "lState", ")", "\n", "return", "fbo", ".", "clearCacheInfoLocked", "(", "lState", ",", "file", ")", "\n", "}" ]

[ "ClearCacheInfo", "removes", "any", "cached", "info", "for", "the", "the", "given", "file", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "revertSyncInfoAfterRecoverableError", "(", "ctx", "context", ".", "Context", ",", "blocksToRemove", "[", "]", "data", ".", "BlockPointer", ",", "result", "fileSyncState", ")", "{", "si", ":=", "result", ".", "si", "\n", "savedSi", ":=", "result", ".", "savedSi", "\n\n", "// Save the blocks we need to clean up on the next attempt.", "toClean", ":=", "si", ".", "toCleanIfUnused", "\n\n", "newIndirect", ":=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "bool", ")", "\n", "for", "_", ",", "ptr", ":=", "range", "result", ".", "newIndirectFileBlockPtrs", "{", "newIndirect", "[", "ptr", "]", "=", "true", "\n", "}", "\n\n", "// Propagate all unrefs forward, except those that belong to new", "// blocks that were created during the sync.", "unrefs", ":=", "make", "(", "[", "]", "data", ".", "BlockInfo", ",", "0", ",", "len", "(", "si", ".", "unrefs", ")", ")", "\n", "for", "_", ",", "unref", ":=", "range", "si", ".", "unrefs", "{", "if", "newIndirect", "[", "unref", ".", "BlockPointer", "]", "{", "fbo", ".", "vlog", ".", "CLogf", "(", "nil", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "unref", ")", "\n", "continue", "\n", "}", "\n", "unrefs", "=", "append", "(", "unrefs", ",", "unref", ")", "\n", "}", "\n\n", "// This sync will be retried and needs new blocks, so", "// reset everything in the sync info.", "*", "si", "=", "*", "savedSi", "\n", "si", ".", "toCleanIfUnused", "=", "toClean", "\n", "si", ".", "unrefs", "=", "unrefs", "\n", "if", "si", ".", "bps", "==", "nil", "{", "return", "\n", "}", "\n\n", "// Mark any bad pointers so they get skipped next time.", "blocksToRemoveSet", ":=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "bool", ")", "\n", "for", "_", ",", "ptr", ":=", "range", "blocksToRemove", "{", "blocksToRemoveSet", "[", "ptr", "]", "=", "true", "\n", "}", "\n\n", "newBps", ",", "err", ":=", "savedSi", ".", "bps", ".", "deepCopyWithBlacklist", "(", "ctx", ",", "blocksToRemoveSet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "si", ".", "bps", "=", "newBps", "\n", "}" ]

[ "revertSyncInfoAfterRecoverableError", "updates", "the", "saved", "sync", "info", "to", "include", "all", "the", "blocks", "from", "before", "the", "error", "except", "for", "those", "that", "have", "encountered", "recoverable", "block", "errors", "themselves", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "mergeDirtyEntryWithDBM", "(", "ctx", "context", ".", "Context", ",", "lState", "*", "kbfssync", ".", "LockState", ",", "file", "data", ".", "Path", ",", "md", "libkey", ".", "KeyMetadata", ",", "dbm", "dirBlockMap", ",", "dirtyDe", "data", ".", "DirEntry", ")", "error", "{", "// Lock and fetch for reading only, any dirty blocks will go into", "// the dbm.", "fbo", ".", "blockLock", ".", "RLock", "(", "lState", ")", "\n", "defer", "fbo", ".", "blockLock", ".", "RUnlock", "(", "lState", ")", "\n\n", "chargedTo", ",", "err", ":=", "fbo", ".", "getChargedToLocked", "(", "ctx", ",", "lState", ",", "md", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "dd", ":=", "fbo", ".", "newDirDataWithDBMLocked", "(", "lState", ",", "*", "file", ".", "ParentPath", "(", ")", ",", "chargedTo", ",", "md", ",", "dbm", ")", "\n", "unrefs", ",", "err", ":=", "dd", ".", "SetEntry", "(", "ctx", ",", "file", ".", "TailName", "(", ")", ",", "dirtyDe", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "len", "(", "unrefs", ")", "!=", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "unrefs", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "mergeDirtyEntryWithDBM", "sets", "the", "entry", "for", "a", "file", "into", "a", "directory", "storing", "all", "the", "affected", "blocks", "into", "dbm", "rather", "than", "the", "dirty", "block", "cache", ".", "It", "must", "only", "be", "called", "with", "an", "entry", "that", "s", "already", "been", "written", "to", "the", "dirty", "block", "cache", "such", "that", "no", "new", "blocks", "are", "dirtied", "." ]

[ "func", "(", "fbo", "*", "folderBlockOps", ")", "cleanUpUnusedBlocks", "(", "ctx", "context", ".", "Context", ",", "md", "ReadOnlyRootMetadata", ",", "syncState", "fileSyncState", ",", "fbm", "*", "folderBlockManager", ")", "error", "{", "numToClean", ":=", "len", "(", "syncState", ".", "si", ".", "toCleanIfUnused", ")", "\n", "if", "numToClean", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// What blocks are referenced in the successful MD?", "refs", ":=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "bool", ")", "\n", "for", "_", ",", "op", ":=", "range", "md", ".", "data", ".", "Changes", ".", "Ops", "{", "for", "_", ",", "ptr", ":=", "range", "op", ".", "Refs", "(", ")", "{", "if", "ptr", "==", "data", ".", "ZeroPtr", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "refs", "[", "ptr", "]", "=", "true", "\n", "}", "\n", "for", "_", ",", "update", ":=", "range", "op", ".", "allUpdates", "(", ")", "{", "if", "update", ".", "Ref", "==", "data", ".", "ZeroPtr", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "refs", "[", "update", ".", "Ref", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "// For each MD to clean, clean up the old failed blocks", "// immediately if the merge status matches the successful put, if", "// they didn't get referenced in the successful put. If the merge", "// status is different (e.g., we ended up on a conflict branch),", "// clean it up only if the original revision failed. If the same", "// block appears more than once, the one with a different merged", "// status takes precedence (which will always come earlier in the", "// list of MDs).", "blocksSeen", ":=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "bool", ")", "\n", "for", "_", ",", "oldMD", ":=", "range", "syncState", ".", "si", ".", "toCleanIfUnused", "{", "bdType", ":=", "blockDeleteAlways", "\n", "if", "oldMD", ".", "md", ".", "MergedStatus", "(", ")", "!=", "md", ".", "MergedStatus", "(", ")", "{", "bdType", "=", "blockDeleteOnMDFail", "\n", "}", "\n\n", "failedBps", ":=", "newBlockPutStateMemory", "(", "oldMD", ".", "bps", ".", "numBlocks", "(", ")", ")", "\n", "for", "_", ",", "ptr", ":=", "range", "oldMD", ".", "bps", ".", "ptrs", "(", ")", "{", "if", "ptr", "==", "data", ".", "ZeroPtr", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "blocksSeen", "[", "ptr", "]", "{", "continue", "\n", "}", "\n", "blocksSeen", "[", "ptr", "]", "=", "true", "\n", "if", "refs", "[", "ptr", "]", "&&", "bdType", "==", "blockDeleteAlways", "{", "continue", "\n", "}", "\n", "failedBps", ".", "blockStates", "[", "ptr", "]", "=", "blockState", "{", "}", "\n", "fbo", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", "+", "\"", "\"", ",", "ptr", ",", "oldMD", ".", "md", ".", "Revision", "(", ")", ",", "oldMD", ".", "md", ".", "MergedStatus", "(", ")", ",", "bdType", ")", "\n", "}", "\n\n", "if", "len", "(", "failedBps", ".", "blockStates", ")", ">", "0", "{", "fbm", ".", "cleanUpBlockState", "(", "oldMD", ".", "md", ",", "failedBps", ",", "bdType", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "cleanUpUnusedBlocks", "cleans", "up", "the", "blocks", "from", "any", "previous", "failed", "sync", "attempts", "." ]