Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "CreateWalletSoft", "(", "mctx", "libkb", ".", "MetaContext", ")", "{", "var", "err", "error", "\n", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "if", "!", "mctx", ".", "G", "(", ")", ".", "LocalSigchainGuard", "(", ")", ".", "IsAvailable", "(", "mctx", ".", "Ctx", "(", ")", ",", "\"", "\"", ")", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "_", ",", "err", "=", "CreateWalletGated", "(", "mctx", ")", "\n", "}" ]

[ "CreateWalletSoft", "creates", "a", "user", "s", "initial", "wallet", "if", "they", "don", "t", "already", "have", "one", ".", "Does", "not", "get", "in", "the", "way", "of", "intentional", "user", "actions", "." ]

[ "func", "Upkeep", "(", "mctx", "libkb", ".", "MetaContext", ")", "(", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "_", ",", "_", ",", "prevAccountPukGens", ",", "err", ":=", "remote", ".", "FetchBundleWithGens", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "pukring", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetPerUserKeyring", "(", "mctx", ".", "Ctx", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "pukring", ".", "Sync", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "currentPukGen", ":=", "pukring", ".", "CurrentGeneration", "(", ")", "\n", "var", "madeAnyChanges", "bool", "\n", "for", "accountID", ",", "accountPukGen", ":=", "range", "prevAccountPukGens", "{", "if", "accountPukGen", "<", "currentPukGen", "{", "madeAnyChanges", "=", "true", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "accountID", "[", ":", "5", "]", ",", "currentPukGen", ",", "accountPukGen", ")", "\n", "if", "err", "=", "pushSimpleUpdateForAccount", "(", "mctx", ",", "accountID", ")", ";", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "accountID", "[", ":", "5", "]", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "!", "madeAnyChanges", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "currentPukGen", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Upkeep", "makes", "sure", "the", "bundle", "is", "encrypted", "for", "the", "user", "s", "latest", "PUK", "." ]

[ "func", "SendPaymentCLI", "(", "m", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ",", "sendArg", "SendPaymentArg", ")", "(", "res", "SendPaymentResult", ",", "err", "error", ")", "{", "return", "sendPayment", "(", "m", ",", "walletState", ",", "sendArg", ",", "true", ")", "\n", "}" ]

[ "SendPaymentCLI", "sends", "XLM", "from", "CLI", "." ]

[ "func", "SendPaymentGUI", "(", "m", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ",", "sendArg", "SendPaymentArg", ")", "(", "res", "SendPaymentResult", ",", "err", "error", ")", "{", "return", "sendPayment", "(", "m", ",", "walletState", ",", "sendArg", ",", "false", ")", "\n", "}" ]

[ "SendPaymentGUI", "sends", "XLM", "from", "GUI", "." ]

[ "func", "SendPathPaymentCLI", "(", "mctx", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ",", "sendArg", "SendPathPaymentArg", ")", "(", "res", "SendPaymentResult", ",", "err", "error", ")", "{", "return", "sendPathPayment", "(", "mctx", ",", "walletState", ",", "sendArg", ")", "\n", "}" ]

[ "SendPathPaymentCLI", "sends", "a", "path", "payment", "from", "CLI", "." ]

[ "func", "SpecMiniChatPayments", "(", "mctx", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ",", "payments", "[", "]", "libkb", ".", "MiniChatPayment", ")", "(", "*", "libkb", ".", "MiniChatPaymentSummary", ",", "error", ")", "{", "// look up sender account", "_", ",", "senderAccountBundle", ",", "err", ":=", "LookupSenderPrimary", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "senderAccountID", ":=", "senderAccountBundle", ".", "AccountID", "\n", "senderCurrency", ",", "err", ":=", "GetCurrencySetting", "(", "mctx", ",", "senderAccountID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "senderRate", ",", "err", ":=", "walletState", ".", "ExchangeRate", "(", "mctx", ".", "Ctx", "(", ")", ",", "string", "(", "senderCurrency", ".", "Code", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "summary", "libkb", ".", "MiniChatPaymentSummary", "\n\n", "var", "xlmTotal", "int64", "\n", "if", "len", "(", "payments", ")", ">", "0", "{", "ch", ":=", "make", "(", "chan", "indexedSpec", ")", "\n", "for", "i", ",", "payment", ":=", "range", "payments", "{", "go", "func", "(", "payment", "libkb", ".", "MiniChatPayment", ",", "index", "int", ")", "{", "spec", ",", "xlmAmountNumeric", ":=", "specMiniChatPayment", "(", "mctx", ",", "walletState", ",", "payment", ")", "\n", "ch", "<-", "indexedSpec", "{", "spec", ":", "spec", ",", "index", ":", "index", ",", "xlmAmountNumeric", ":", "xlmAmountNumeric", "}", "\n", "}", "(", "payment", ",", "i", ")", "\n", "}", "\n\n", "summary", ".", "Specs", "=", "make", "(", "[", "]", "libkb", ".", "MiniChatPaymentSpec", ",", "len", "(", "payments", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "payments", ")", ";", "i", "++", "{", "ispec", ":=", "<-", "ch", "\n", "summary", ".", "Specs", "[", "ispec", ".", "index", "]", "=", "ispec", ".", "spec", "\n", "xlmTotal", "+=", "ispec", ".", "xlmAmountNumeric", "\n", "}", "\n", "}", "\n\n", "summary", ".", "XLMTotal", "=", "stellarnet", ".", "StringFromStellarAmount", "(", "xlmTotal", ")", "\n", "if", "senderRate", ".", "Currency", "!=", "\"", "\"", "&&", "senderRate", ".", "Currency", "!=", "\"", "\"", "{", "outsideAmount", ",", "err", ":=", "stellarnet", ".", "ConvertXLMToOutside", "(", "summary", ".", "XLMTotal", ",", "senderRate", ".", "Rate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "summary", ".", "DisplayTotal", ",", "err", "=", "FormatCurrencyWithCodeSuffix", "(", "mctx", ",", "outsideAmount", ",", "senderRate", ".", "Currency", ",", "stellarnet", ".", "Round", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "summary", ".", "XLMTotal", ",", "err", "=", "FormatAmountDescriptionXLM", "(", "mctx", ",", "summary", ".", "XLMTotal", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "summary", ",", "nil", "\n", "}" ]

[ "SpecMiniChatPayments", "returns", "a", "summary", "of", "the", "payment", "amounts", "for", "each", "recipient", "and", "a", "total", "." ]

[ "func", "Claim", "(", "mctx", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ",", "txID", "string", ",", "into", "stellar1", ".", "AccountID", ",", "dir", "*", "stellar1", ".", "RelayDirection", ",", "autoClaimToken", "*", "string", ")", "(", "res", "stellar1", ".", "RelayClaimResult", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "txID", ",", "into", ",", "dir", ",", "autoClaimToken", ")", "\n", "details", ",", "err", ":=", "walletState", ".", "PaymentDetailsGeneric", "(", "mctx", ".", "Ctx", "(", ")", ",", "txID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "p", ":=", "details", ".", "Summary", "\n", "typ", ",", "err", ":=", "p", ".", "Typ", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "switch", "typ", "{", "case", "stellar1", ".", "PaymentSummaryType_STELLAR", ":", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "case", "stellar1", ".", "PaymentSummaryType_DIRECT", ":", "p", ":=", "p", ".", "Direct", "(", ")", "\n", "switch", "p", ".", "TxStatus", "{", "case", "stellar1", ".", "TransactionStatus_SUCCESS", ":", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "case", "stellar1", ".", "TransactionStatus_PENDING", ":", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "default", ":", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "stellar1", ".", "PaymentSummaryType_RELAY", ":", "return", "claimPaymentWithDetail", "(", "mctx", ",", "walletState", ",", "p", ".", "Relay", "(", ")", ",", "into", ",", "dir", ")", "\n", "default", ":", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "typ", ")", "\n", "}", "\n", "}" ]

[ "Claim", "claims", "a", "waiting", "relay", ".", "If", "dir", "is", "nil", "the", "direction", "is", "inferred", "." ]

[ "func", "claimPaymentWithDetail", "(", "mctx", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ",", "p", "stellar1", ".", "PaymentSummaryRelay", ",", "into", "stellar1", ".", "AccountID", ",", "dir", "*", "stellar1", ".", "RelayDirection", ")", "(", "res", "stellar1", ".", "RelayClaimResult", ",", "err", "error", ")", "{", "if", "p", ".", "Claim", "!=", "nil", "&&", "p", ".", "Claim", ".", "TxStatus", "==", "stellar1", ".", "TransactionStatus_SUCCESS", "{", "recipient", ",", "_", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ".", "Load", "(", "libkb", ".", "NewLoadUserByUIDArg", "(", "mctx", ".", "Ctx", "(", ")", ",", "mctx", ".", "G", "(", ")", ",", "p", ".", "Claim", ".", "To", ".", "Uid", ")", ")", "\n", "if", "err", "!=", "nil", "||", "recipient", "==", "nil", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "recipient", ".", "GetName", "(", ")", ")", "\n", "}", "\n", "rsec", ",", "err", ":=", "relays", ".", "DecryptB64", "(", "mctx", ",", "p", ".", "TeamID", ",", "p", ".", "BoxB64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "skey", ",", "_", ",", "_", ",", "err", ":=", "libkb", ".", "ParseStellarSecretKey", "(", "rsec", ".", "Sk", ".", "SecureNoLogString", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "destinationFunded", ",", "err", ":=", "isAccountFunded", "(", "mctx", ".", "Ctx", "(", ")", ",", "walletState", ",", "into", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "useDir", ":=", "stellar1", ".", "RelayDirection_CLAIM", "\n", "if", "dir", "==", "nil", "{", "// Infer direction", "if", "p", ".", "From", ".", "Uid", ".", "Equal", "(", "mctx", ".", "ActiveDevice", "(", ")", ".", "UID", "(", ")", ")", "{", "useDir", "=", "stellar1", ".", "RelayDirection_YANK", "\n", "}", "\n", "}", "else", "{", "// Direction from caller", "useDir", "=", "*", "dir", "\n", "}", "\n\n", "baseFee", ":=", "walletState", ".", "BaseFee", "(", "mctx", ")", "\n", "sp", ",", "unlock", ":=", "NewClaimSeqnoProvider", "(", "mctx", ",", "walletState", ")", "\n", "defer", "unlock", "(", ")", "\n", "tb", ",", "err", ":=", "getTimeboundsForSending", "(", "mctx", ",", "walletState", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "sig", ",", "err", ":=", "stellarnet", ".", "RelocateTransaction", "(", "stellarnet", ".", "SeedStr", "(", "skey", ".", "SecureNoLogString", "(", ")", ")", ",", "stellarnet", ".", "AddressStr", "(", "into", ".", "String", "(", ")", ")", ",", "destinationFunded", ",", "nil", ",", "sp", ",", "tb", ",", "baseFee", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "walletState", ".", "SubmitRelayClaim", "(", "mctx", ".", "Ctx", "(", ")", ",", "stellar1", ".", "RelayClaimPost", "{", "KeybaseID", ":", "p", ".", "KbTxID", ",", "Dir", ":", "useDir", ",", "SignedTransaction", ":", "sig", ".", "Signed", ",", "}", ")", "\n", "}" ]

[ "If", "dir", "is", "nil", "the", "direction", "is", "inferred", "." ]

[ "func", "assertAssetIsSane", "(", "asset", "stellar1", ".", "Asset", ")", "error", "{", "switch", "asset", ".", "Type", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "case", "\"", "\"", ",", "\"", "\"", ":", "// These prefixes that are missing \"credit_\" shouldn't show up, but just to be on the safe side.", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "asset", ".", "Type", ")", "\n", "}", "\n", "// Sanity check asset code very loosely. We know tighter bounds but there's no need to fail here.", "if", "len", "(", "asset", ".", "Code", ")", "==", "0", "||", "len", "(", "asset", ".", "Code", ")", ">=", "20", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "asset", ".", "Code", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Return", "an", "error", "if", "asset", "is", "completely", "outside", "of", "what", "we", "understand", "like", "asset", "unknown", "types", "or", "unexpected", "length", "." ]

[ "func", "ChangeAccountName", "(", "m", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ",", "accountID", "stellar1", ".", "AccountID", ",", "newName", "string", ")", "(", "err", "error", ")", "{", "if", "newName", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "runes", ":=", "utf8", ".", "RuneCountInString", "(", "newName", ")", "\n", "if", "runes", ">", "AccountNameMaxRunes", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "AccountNameMaxRunes", ",", "runes", ")", "\n", "}", "\n", "b", ",", "err", ":=", "remote", ".", "FetchSecretlessBundle", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "var", "found", "bool", "\n", "for", "i", ",", "acc", ":=", "range", "b", ".", "Accounts", "{", "if", "acc", ".", "AccountID", ".", "Eq", "(", "accountID", ")", "{", "// Change Name in place to modify Account struct.", "b", ".", "Accounts", "[", "i", "]", ".", "Name", "=", "newName", "\n", "found", "=", "true", "\n", "}", "else", "if", "acc", ".", "Name", "==", "newName", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "accountID", ")", "\n", "}", "\n", "nextBundle", ":=", "bundle", ".", "AdvanceBundle", "(", "*", "b", ")", "\n", "if", "err", ":=", "remote", ".", "Post", "(", "m", ",", "nextBundle", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "walletState", ".", "UpdateAccountEntriesWithBundle", "(", "m", ",", "\"", "\"", ",", "&", "nextBundle", ")", "\n", "}" ]

[ "ChangeAccountName", "changes", "the", "name", "of", "an", "account", ".", "Make", "sure", "to", "keep", "this", "in", "sync", "with", "ValidateAccountNameLocal", ".", "An", "empty", "name", "is", "not", "allowed", ".", "Renaming", "an", "account", "to", "an", "already", "used", "name", "is", "blocked", ".", "Maximum", "length", "of", "AccountNameMaxRunes", "runes", "." ]

[ "func", "AccountExchangeRate", "(", "mctx", "libkb", ".", "MetaContext", ",", "remoter", "remote", ".", "Remoter", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "stellar1", ".", "OutsideExchangeRate", ",", "error", ")", "{", "currency", ",", "err", ":=", "GetCurrencySetting", "(", "mctx", ",", "accountID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stellar1", ".", "OutsideExchangeRate", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "remoter", ".", "ExchangeRate", "(", "mctx", ".", "Ctx", "(", ")", ",", "string", "(", "currency", ".", "Code", ")", ")", "\n", "}" ]

[ "AccountExchangeRate", "returns", "the", "exchange", "rate", "for", "an", "account", "for", "the", "logged", "in", "user", ".", "Note", "that", "it", "is", "possible", "that", "multiple", "users", "can", "own", "the", "same", "account", "and", "have", "different", "display", "currency", "preferences", "." ]

[ "func", "WalletAccount", "(", "mctx", "libkb", ".", "MetaContext", ",", "remoter", "remote", ".", "Remoter", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "stellar1", ".", "WalletAccountLocal", ",", "error", ")", "{", "bundle", ",", "err", ":=", "remote", ".", "FetchSecretlessBundle", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stellar1", ".", "WalletAccountLocal", "{", "}", ",", "err", "\n", "}", "\n", "entry", ",", "err", ":=", "bundle", ".", "Lookup", "(", "accountID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stellar1", ".", "WalletAccountLocal", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "accountLocal", "(", "mctx", ",", "remoter", ",", "entry", ")", "\n", "}" ]

[ "WalletAccount", "returns", "stellar1", ".", "WalletAccountLocal", "for", "accountID", "." ]

[ "func", "AccountDetails", "(", "mctx", "libkb", ".", "MetaContext", ",", "remoter", "remote", ".", "Remoter", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "stellar1", ".", "AccountDetails", ",", "error", ")", "{", "details", ",", "err", ":=", "remoter", ".", "Details", "(", "mctx", ".", "Ctx", "(", ")", ",", "accountID", ")", "\n", "details", ".", "SetDefaultDisplayCurrency", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "details", ",", "err", "\n", "}", "\n\n", "err", "=", "mctx", ".", "G", "(", ")", ".", "GetStellar", "(", ")", ".", "UpdateUnreadCount", "(", "mctx", ".", "Ctx", "(", ")", ",", "accountID", ",", "details", ".", "UnreadPayments", ")", "\n", "if", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "details", ",", "nil", "\n", "}" ]

[ "AccountDetails", "gets", "stellar1", ".", "AccountDetails", "for", "accountID", ".", "It", "has", "the", "side", "effect", "of", "updating", "the", "badge", "state", "with", "the", "stellar", "payment", "unread", "count", "for", "accountID", "." ]

[ "func", "(", "t", "*", "Terminal", ")", "GetSize", "(", ")", "(", "int", ",", "int", ")", "{", "if", "err", ":=", "t", ".", "open", "(", ")", ";", "err", "!=", "nil", "{", "return", "80", ",", "24", "\n", "}", "\n", "return", "t", ".", "engine", ".", "Size", "(", ")", "\n", "}" ]

[ "GetSize", "tries", "to", "get", "the", "size", "for", "the", "current", "terminal", ".", "It", "if", "fails", "it", "returns", "80x24" ]

[ "func", "NewQuarantineXattrHandler", "(", "node", "libkbfs", ".", "Node", ",", "folder", "*", "Folder", ",", ")", "XattrHandler", "{", "return", "&", "QuarantineXattrHandler", "{", "node", ":", "node", ",", "folder", ":", "folder", ",", "}", "\n", "}" ]

[ "NewQuarantineXattrHandler", "returns", "a", "handler", "that", "handles", "com", ".", "apple", ".", "quarantine", "but", "returns", "fuse", ".", "ENOTSUP", "for", "all", "other", "xattrs", "." ]

[ "func", "makeDiskJournal", "(", "codec", "kbfscodec", ".", "Codec", ",", "dir", "string", ",", "entryType", "reflect", ".", "Type", ")", "(", "*", "diskJournal", ",", "error", ")", "{", "j", ":=", "&", "diskJournal", "{", "codec", ":", "codec", ",", "dir", ":", "dir", ",", "entryType", ":", "entryType", ",", "}", "\n\n", "earliest", ",", "err", ":=", "j", ".", "readEarliestOrdinalFromDisk", "(", ")", "\n", "if", "ioutil", ".", "IsNotExist", "(", "err", ")", "{", "// Continue with j.earliestValid = false.", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "{", "j", ".", "earliestValid", "=", "true", "\n", "j", ".", "earliest", "=", "earliest", "\n", "}", "\n\n", "latest", ",", "err", ":=", "j", ".", "readLatestOrdinalFromDisk", "(", ")", "\n", "if", "ioutil", ".", "IsNotExist", "(", "err", ")", "{", "// Continue with j.latestValid = false.", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "{", "j", ".", "latestValid", "=", "true", "\n", "j", ".", "latest", "=", "latest", "\n", "}", "\n\n", "return", "j", ",", "nil", "\n", "}" ]

[ "makeDiskJournal", "returns", "a", "new", "diskJournal", "for", "the", "given", "directory", "." ]

[ "func", "(", "j", "*", "diskJournal", ")", "clear", "(", ")", "error", "{", "// Clear ordinals first to not leave the journal in a weird", "// state if we crash in the middle of removing the files,", "// assuming that file removal is atomic.", "err", ":=", "ioutil", ".", "Remove", "(", "j", ".", "earliestPath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// If we crash here, on the next startup the journal will", "// still be considered empty.", "j", ".", "earliestValid", "=", "false", "\n", "j", ".", "earliest", "=", "journalOrdinal", "(", "0", ")", "\n\n", "err", "=", "ioutil", ".", "Remove", "(", "j", ".", "latestPath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "j", ".", "latestValid", "=", "false", "\n", "j", ".", "latest", "=", "journalOrdinal", "(", "0", ")", "\n\n", "// j.dir will be recreated on the next call to", "// writeJournalEntry (via kbfscodec.SerializeToFile), which", "// must always come before any ordinal write.", "return", "ioutil", ".", "RemoveAll", "(", "j", ".", "dir", ")", "\n", "}" ]

[ "clear", "completely", "removes", "the", "journal", "directory", "." ]

[ "func", "(", "j", "*", "diskJournal", ")", "move", "(", "newDir", "string", ")", "(", "oldDir", "string", ",", "err", "error", ")", "{", "err", "=", "ioutil", ".", "Rename", "(", "j", ".", "dir", ",", "newDir", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "ioutil", ".", "IsNotExist", "(", "err", ")", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "oldDir", "=", "j", ".", "dir", "\n", "j", ".", "dir", "=", "newDir", "\n", "return", "oldDir", ",", "nil", "\n", "}" ]

[ "move", "moves", "the", "journal", "to", "the", "given", "directory", "which", "should", "share", "the", "same", "parent", "directory", "as", "the", "current", "journal", "directory", "." ]

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

[ "Download", "PGP", "keys", "for", "tracked", "users", "and", "update", "the", "local", "GPG", "keyring", ".", "If", "usernames", "is", "nonempty", "update", "only", "those", "users", "." ]

[ "func", "(", "c", "PGPClient", ")", "PGPExport", "(", "ctx", "context", ".", "Context", ",", "__arg", "PGPExportArg", ")", "(", "res", "[", "]", "KeyInfo", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Exports", "active", "PGP", "keys", ".", "Only", "allows", "armored", "export", "." ]

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

[ "Select", "an", "existing", "key", "and", "add", "to", "Keybase", "." ]

[ "func", "(", "c", "PGPClient", ")", "PGPStorageDismiss", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "err", "error", ")", "{", "__arg", ":=", "PGPStorageDismissArg", "{", "SessionID", ":", "sessionID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Dismiss", "the", "PGP", "unlock", "via", "secret_store_file", "notification", "." ]

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

[ "push", "the", "PGP", "key", "that", "matches", "the", "given", "fingerprints", "from", "GnuPG", "to", "KBFS", ".", "If", "it", "is", "empty", "then", "push", "all", "matching", "PGP", "keys", "in", "the", "user", "s", "sigchain", "." ]

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

[ "pull", "the", "given", "PGP", "keys", "from", "KBFS", "to", "the", "local", "GnuPG", "keychain", ".", "If", "it", "is", "empty", "then", "attempt", "to", "pull", "all", "matching", "PGP", "keys", "in", "the", "user", "s", "sigchain", "." ]

[ "func", "(", "h", "*", "PGPHandler", ")", "PGPStorageDismiss", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "error", "{", "username", ":=", "h", ".", "G", "(", ")", ".", "Env", ".", "GetUsername", "(", ")", "\n", "if", "username", ".", "IsNil", "(", ")", "{", "return", "libkb", ".", "NewNoUsernameError", "(", ")", "\n", "}", "\n\n", "key", ":=", "libkb", ".", "DbKeyNotificationDismiss", "(", "libkb", ".", "NotificationDismissPGPPrefix", ",", "username", ")", "\n", "return", "h", ".", "G", "(", ")", ".", "LocalDb", ".", "PutRaw", "(", "key", ",", "[", "]", "byte", "(", "libkb", ".", "NotificationDismissPGPValue", ")", ")", "\n", "}" ]

[ "Set", "the", "PGP", "storage", "notification", "dismiss", "flag", "in", "the", "local", "DB", "." ]

[ "func", "NewMountInterrupter", "(", "log", "logger", ".", "Logger", ")", "*", "MountInterrupter", "{", "return", "&", "MountInterrupter", "{", "done", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "log", ":", "log", "}", "\n", "}" ]

[ "NewMountInterrupter", "creates", "a", "new", "MountInterrupter", "." ]

[ "func", "(", "mi", "*", "MountInterrupter", ")", "MountAndSetUnmount", "(", "mounter", "Mounter", ")", "error", "{", "mi", ".", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "mi", ".", "Lock", "(", ")", "\n", "defer", "mi", ".", "Unlock", "(", ")", "\n", "select", "{", "case", "<-", "mi", ".", "done", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "default", ":", "}", "\n", "err", ":=", "mounter", ".", "Mount", "(", ")", "\n", "if", "err", "!=", "nil", "{", "mi", ".", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "mi", ".", "fun", "=", "mounter", ".", "Unmount", "\n", "mi", ".", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "MountAndSetUnmount", "calls", "Mount", "and", "sets", "the", "unmount", "function", "to", "be", "called", "once", "if", "mount", "succeeds", ".", "If", "Done", "has", "already", "been", "called", "MountAndSetUnmount", "returns", "an", "error", "." ]

[ "func", "(", "mi", "*", "MountInterrupter", ")", "Done", "(", ")", "error", "{", "mi", ".", "Lock", "(", ")", "\n", "defer", "mi", ".", "Unlock", "(", ")", "\n", "if", "mi", ".", "fun", "!=", "nil", "{", "err", ":=", "mi", ".", "fun", "(", ")", "\n", "if", "err", "!=", "nil", "{", "mi", ".", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "mi", ".", "once", ".", "Do", "(", "func", "(", ")", "{", "close", "(", "mi", ".", "done", ")", "\n", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "Done", "signals", "Wait", "and", "runs", "the", "unmounter", "if", "set", "by", "MountAndSetUnmount", ".", "It", "can", "be", "called", "multiple", "times", "with", "no", "harm", ".", "Each", "call", "triggers", "a", "call", "to", "the", "unmounter", "." ]

[ "func", "(", "e", "simpleFSError", ")", "ToStatus", "(", ")", "keybase1", ".", "Status", "{", "return", "keybase1", ".", "Status", "{", "Name", ":", "e", ".", "reason", ",", "Code", ":", "int", "(", "keybase1", ".", "StatusCode_SCGeneric", ")", ",", "Desc", ":", "e", ".", "Error", "(", ")", ",", "}", "\n", "}" ]

[ "ToStatus", "implements", "the", "keybase1", ".", "ToStatusAble", "interface", "for", "simpleFSError" ]

[ "func", "NewSimpleFS", "(", "appStateUpdater", "env", ".", "AppStateUpdater", ",", "config", "libkbfs", ".", "Config", ")", "keybase1", ".", "SimpleFSInterface", "{", "return", "newSimpleFS", "(", "appStateUpdater", ",", "config", ")", "\n", "}" ]

[ "NewSimpleFS", "creates", "a", "new", "SimpleFS", "instance", "." ]

[ "func", "remoteTlfAndPath", "(", "path", "keybase1", ".", "Path", ")", "(", "t", "tlf", ".", "Type", ",", "tlfName", ",", "middlePath", ",", "finalElem", "string", ",", "err", "error", ")", "{", "ps", ",", "err", ":=", "splitPathFromKbfsPath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "Private", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "switch", "{", "case", "len", "(", "ps", ")", "<", "2", ":", "return", "tlf", ".", "Private", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "errInvalidRemotePath", "\n", "case", "ps", "[", "0", "]", "==", "`private`", ":", "t", "=", "tlf", ".", "Private", "\n", "case", "ps", "[", "0", "]", "==", "`public`", ":", "t", "=", "tlf", ".", "Public", "\n", "case", "ps", "[", "0", "]", "==", "`team`", ":", "t", "=", "tlf", ".", "SingleTeam", "\n", "default", ":", "return", "tlf", ".", "Private", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "errInvalidRemotePath", "\n", "}", "\n", "if", "len", "(", "ps", ")", ">=", "3", "{", "finalElem", "=", "ps", "[", "len", "(", "ps", ")", "-", "1", "]", "\n", "middlePath", "=", "stdpath", ".", "Join", "(", "ps", "[", "2", ":", "len", "(", "ps", ")", "-", "1", "]", "...", ")", "\n", "}", "\n", "return", "t", ",", "ps", "[", "1", "]", ",", "middlePath", ",", "finalElem", ",", "nil", "\n", "}" ]

[ "remoteTlfAndPath", "decodes", "a", "remote", "path", "for", "us", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSListRecursiveToDepth", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "SimpleFSListRecursiveToDepthArg", ")", "error", "{", "return", "k", ".", "startAsync", "(", "ctx", ",", "arg", ".", "OpID", ",", "keybase1", ".", "AsyncOps_LIST_RECURSIVE_TO_DEPTH", ",", "keybase1", ".", "NewOpDescriptionWithListRecursiveToDepth", "(", "keybase1", ".", "ListToDepthArgs", "{", "OpID", ":", "arg", ".", "OpID", ",", "Path", ":", "arg", ".", "Path", ",", "Filter", ":", "arg", ".", "Filter", ",", "Depth", ":", "arg", ".", "Depth", ",", "}", ")", ",", "k", ".", "listRecursiveToDepth", "(", "arg", ".", "OpID", ",", "arg", ".", "Path", ",", "arg", ".", "Filter", ",", "arg", ".", "Depth", ",", "arg", ".", "RefreshSubscription", ")", ",", ")", "\n", "}" ]

[ "SimpleFSListRecursiveToDepth", "-", "Begin", "recursive", "list", "of", "items", "in", "directory", "at", "path", "up", "to", "a", "given", "depth", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSReadList", "(", "_", "context", ".", "Context", ",", "opid", "keybase1", ".", "OpID", ")", "(", "keybase1", ".", "SimpleFSListResult", ",", "error", ")", "{", "k", ".", "lock", ".", "Lock", "(", ")", "\n", "res", ",", "_", ":=", "k", ".", "handles", "[", "opid", "]", "\n", "var", "x", "interface", "{", "}", "\n", "if", "res", "!=", "nil", "{", "x", "=", "res", ".", "async", "\n", "res", ".", "async", "=", "nil", "\n", "}", "\n", "k", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "lr", ",", "ok", ":=", "x", ".", "(", "keybase1", ".", "SimpleFSListResult", ")", "\n", "if", "!", "ok", "{", "return", "keybase1", ".", "SimpleFSListResult", "{", "}", ",", "errNoResult", "\n", "}", "\n\n", "return", "lr", ",", "nil", "\n", "}" ]

[ "SimpleFSReadList", "-", "Get", "list", "of", "Paths", "in", "progress", ".", "Can", "indicate", "status", "of", "pending", "to", "get", "more", "entries", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSListFavorites", "(", "ctx", "context", ".", "Context", ")", "(", "keybase1", ".", "FavoritesResult", ",", "error", ")", "{", "return", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "GetFavoritesAll", "(", "ctx", ")", "\n", "}" ]

[ "SimpleFSListFavorites", "lists", "the", "favorite", "new", "and", "ignored", "folders", "of", "the", "logged", "in", "user", "getting", "its", "data", "from", "the", "KBFS", "Favorites", "cache", ".", "If", "the", "cache", "is", "stale", "this", "will", "trigger", "a", "network", "request", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSSymlink", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "SimpleFSSymlinkArg", ")", "(", "err", "error", ")", "{", "// This is not async.", "ctx", ",", "err", "=", "k", ".", "startSyncOp", "(", "ctx", ",", "\"", "\"", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "k", ".", "doneSyncOp", "(", "ctx", ",", "err", ")", "}", "(", ")", "\n\n", "destFS", ",", "finalDestElem", ",", "err", ":=", "k", ".", "getFS", "(", "ctx", ",", "arg", ".", "Link", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "destFS", ".", "Symlink", "(", "arg", ".", "Target", ",", "finalDestElem", ")", "\n", "return", "err", "\n", "}" ]

[ "SimpleFSSymlink", "starts", "making", "a", "symlink", "of", "a", "file", "or", "directory" ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSGetRevisions", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "SimpleFSGetRevisionsArg", ")", "(", "err", "error", ")", "{", "return", "k", ".", "startAsync", "(", "ctx", ",", "arg", ".", "OpID", ",", "keybase1", ".", "AsyncOps_GET_REVISIONS", ",", "keybase1", ".", "NewOpDescriptionWithGetRevisions", "(", "keybase1", ".", "GetRevisionsArgs", "{", "OpID", ":", "arg", ".", "OpID", ",", "Path", ":", "arg", ".", "Path", ",", "SpanType", ":", "arg", ".", "SpanType", ",", "}", ")", ",", "func", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "revs", ",", "err", ":=", "k", ".", "doGetRevisions", "(", "ctx", ",", "arg", ".", "OpID", ",", "arg", ".", "Path", ",", "arg", ".", "SpanType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "k", ".", "setResult", "(", "arg", ".", "OpID", ",", "keybase1", ".", "GetRevisionsResult", "{", "Revisions", ":", "revs", ",", "// For don't set any progress indicators. If we decide we want", "// to display partial results, we can fix this later.", "}", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "SimpleFSGetRevisions", "-", "Get", "revisions", "for", "a", "file" ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSCancel", "(", "_", "context", ".", "Context", ",", "opid", "keybase1", ".", "OpID", ")", "error", "{", "k", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "lock", ".", "Unlock", "(", ")", "\n", "delete", "(", "k", ".", "handles", ",", "opid", ")", "\n", "w", ",", "ok", ":=", "k", ".", "inProgress", "[", "opid", "]", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "delete", "(", "k", ".", "inProgress", ",", "opid", ")", "\n", "w", ".", "cancel", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "SimpleFSCancel", "starts", "to", "cancel", "op", "with", "the", "given", "opid", ".", "Also", "remove", "any", "pending", "references", "of", "opid", "everywhere", ".", "Returns", "before", "cancellation", "is", "guaranteeded", "to", "be", "done", "-", "that", "may", "take", "some", "time", ".", "Currently", "always", "returns", "nil", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSCheck", "(", "_", "context", ".", "Context", ",", "opid", "keybase1", ".", "OpID", ")", "(", "keybase1", ".", "OpProgress", ",", "error", ")", "{", "k", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "k", ".", "lock", ".", "RUnlock", "(", ")", "\n", "if", "p", ",", "ok", ":=", "k", ".", "inProgress", "[", "opid", "]", ";", "ok", "{", "// For now, estimate the ending time purely on the read progress.", "var", "n", ",", "d", "int64", "\n", "progress", ":=", "p", ".", "progress", "\n", "if", "progress", ".", "BytesTotal", ">", "0", "{", "n", "=", "progress", ".", "BytesRead", "\n", "d", "=", "progress", ".", "BytesTotal", "\n", "}", "else", "if", "p", ".", "progress", ".", "FilesTotal", ">", "0", "{", "n", "=", "progress", ".", "FilesRead", "\n", "d", "=", "progress", ".", "FilesTotal", "\n", "}", "\n", "if", "n", ">", "0", "&&", "d", ">", "0", "&&", "!", "progress", ".", "Start", ".", "IsZero", "(", ")", "&&", "progress", ".", "EndEstimate", ".", "IsZero", "(", ")", "{", "// Crudely estimate that the total time for the op is the", "// time spent so far, divided by the fraction of the", "// reading that's been done.", "start", ":=", "keybase1", ".", "FromTime", "(", "progress", ".", "Start", ")", "\n", "timeRunning", ":=", "k", ".", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "Sub", "(", "start", ")", "\n", "fracDone", ":=", "float64", "(", "n", ")", "/", "float64", "(", "d", ")", "\n", "totalTimeEstimate", ":=", "time", ".", "Duration", "(", "float64", "(", "timeRunning", ")", "/", "fracDone", ")", "\n", "progress", ".", "EndEstimate", "=", "keybase1", ".", "ToTime", "(", "start", ".", "Add", "(", "totalTimeEstimate", ")", ")", "\n", "k", ".", "log", ".", "CDebugf", "(", "nil", ",", "\"", "\"", ",", "start", ",", "n", ",", "d", ",", "fracDone", ",", "start", ".", "Add", "(", "totalTimeEstimate", ")", ")", "\n", "}", "\n\n", "return", "progress", ",", "nil", "\n", "}", "else", "if", "_", ",", "ok", ":=", "k", ".", "handles", "[", "opid", "]", ";", "ok", "{", "// Return an empty progress and nil error if there's no async", "// operation pending, but there is still an open handle.", "return", "keybase1", ".", "OpProgress", "{", "}", ",", "nil", "\n", "}", "\n", "return", "keybase1", ".", "OpProgress", "{", "}", ",", "errNoResult", "\n", "}" ]

[ "SimpleFSCheck", "-", "Check", "progress", "of", "pending", "operation", "Progress", "variable", "is", "still", "TBD", ".", "Return", "errNoResult", "if", "no", "operation", "found", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSGetHTTPAddressAndToken", "(", "ctx", "context", ".", "Context", ")", "(", "resp", "keybase1", ".", "SimpleFSGetHTTPAddressAndTokenResponse", ",", "err", "error", ")", "{", "if", "k", ".", "localHTTPServer", "==", "nil", "{", "return", "resp", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "resp", ".", "Token", ",", "err", "=", "k", ".", "localHTTPServer", ".", "NewToken", "(", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "SimpleFSGetHTTPAddressAndTokenResponse", "{", "}", ",", "err", "\n", "}", "\n", "if", "resp", ".", "Address", ",", "err", "=", "k", ".", "localHTTPServer", ".", "Address", "(", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "SimpleFSGetHTTPAddressAndTokenResponse", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "SimpleFSGetHTTPAddressAndToken", "returns", "a", "random", "token", "to", "be", "used", "for", "the", "local", "KBFS", "http", "server", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSUserEditHistory", "(", "ctx", "context", ".", "Context", ")", "(", "res", "[", "]", "keybase1", ".", "FSFolderEditHistory", ",", "err", "error", ")", "{", "session", ",", "err", ":=", "idutil", ".", "GetCurrentSessionIfPossible", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "true", ")", "\n", "// Return empty history if we are not logged in.", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "k", ".", "config", ".", "UserHistory", "(", ")", ".", "Get", "(", "string", "(", "session", ".", "Name", ")", ")", ",", "nil", "\n", "}" ]

[ "SimpleFSUserEditHistory", "returns", "the", "edit", "history", "for", "the", "logged", "-", "in", "user", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSFolderEditHistory", "(", "ctx", "context", ".", "Context", ",", "path", "keybase1", ".", "Path", ")", "(", "res", "keybase1", ".", "FSFolderEditHistory", ",", "err", "error", ")", "{", "ctx", "=", "k", ".", "makeContext", "(", "ctx", ")", "\n", "fb", ",", "_", ",", "err", ":=", "k", ".", "getFolderBranchFromPath", "(", "ctx", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "FSFolderEditHistory", "{", "}", ",", "err", "\n", "}", "\n", "if", "fb", "==", "(", "data", ".", "FolderBranch", "{", "}", ")", "{", "return", "keybase1", ".", "FSFolderEditHistory", "{", "}", ",", "nil", "\n", "}", "\n\n", "// Now get the edit history.", "return", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "GetEditHistory", "(", "ctx", ",", "fb", ")", "\n", "}" ]

[ "SimpleFSFolderEditHistory", "returns", "the", "edit", "history", "for", "the", "given", "TLF", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSReset", "(", "ctx", "context", ".", "Context", ",", "path", "keybase1", ".", "Path", ")", "error", "{", "t", ",", "tlfName", ",", "_", ",", "_", ",", "err", ":=", "remoteTlfAndPath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "tlfHandle", ",", "err", ":=", "libkbfs", ".", "GetHandleFromFolderNameAndType", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "k", ".", "config", ".", "MDOps", "(", ")", ",", "k", ".", "config", ",", "tlfName", ",", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "Reset", "(", "ctx", ",", "tlfHandle", ")", "\n", "}" ]

[ "SimpleFSReset", "resets", "the", "given", "TLF", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "LocalChange", "(", "ctx", "context", ".", "Context", ",", "node", "libkbfs", ".", "Node", ",", "_", "libkbfs", ".", "WriteRange", ")", "{", "k", ".", "subscribeLock", ".", "RLock", "(", ")", "\n", "defer", "k", ".", "subscribeLock", ".", "RUnlock", "(", ")", "\n", "if", "node", ".", "GetFolderBranch", "(", ")", "==", "k", ".", "subscribeCurrFB", "{", "k", ".", "config", ".", "Reporter", "(", ")", ".", "NotifyPathUpdated", "(", "ctx", ",", "k", ".", "subscribeCurrTlfPathFromGUI", ")", "\n", "}", "\n", "}" ]

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

[ "func", "(", "k", "*", "SimpleFS", ")", "BatchChanges", "(", "ctx", "context", ".", "Context", ",", "changes", "[", "]", "libkbfs", ".", "NodeChange", ",", "_", "[", "]", "libkbfs", ".", "NodeID", ")", "{", "// Don't take any locks while processing these notifications,", "// since it risks deadlock.", "fbs", ":=", "make", "(", "map", "[", "data", ".", "FolderBranch", "]", "bool", ",", "1", ")", "\n", "for", "_", ",", "nc", ":=", "range", "changes", "{", "fbs", "[", "nc", ".", "Node", ".", "GetFolderBranch", "(", ")", "]", "=", "true", "\n", "}", "\n\n", "go", "func", "(", ")", "{", "k", ".", "subscribeLock", ".", "RLock", "(", ")", "\n", "defer", "k", ".", "subscribeLock", ".", "RUnlock", "(", ")", "\n", "if", "fbs", "[", "k", ".", "subscribeCurrFB", "]", "{", "k", ".", "config", ".", "Reporter", "(", ")", ".", "NotifyPathUpdated", "(", "ctx", ",", "k", ".", "subscribeCurrTlfPathFromGUI", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

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

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSGetUserQuotaUsage", "(", "ctx", "context", ".", "Context", ")", "(", "res", "keybase1", ".", "SimpleFSQuotaUsage", ",", "err", "error", ")", "{", "ctx", "=", "k", ".", "makeContext", "(", "ctx", ")", "\n", "status", ",", "_", ",", "err", ":=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "Status", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "SimpleFSQuotaUsage", "{", "}", ",", "err", "\n", "}", "\n", "res", ".", "UsageBytes", "=", "status", ".", "UsageBytes", "\n", "res", ".", "ArchiveBytes", "=", "status", ".", "ArchiveBytes", "\n", "res", ".", "LimitBytes", "=", "status", ".", "LimitBytes", "\n", "res", ".", "GitUsageBytes", "=", "status", ".", "GitUsageBytes", "\n", "res", ".", "GitArchiveBytes", "=", "status", ".", "GitArchiveBytes", "\n", "res", ".", "GitLimitBytes", "=", "status", ".", "GitLimitBytes", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "SimpleFSGetUserQuotaUsage", "returns", "the", "quota", "usage", "information", "for", "the", "logged", "-", "in", "user", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSGetTeamQuotaUsage", "(", "ctx", "context", ".", "Context", ",", "teamName", "keybase1", ".", "TeamName", ")", "(", "res", "keybase1", ".", "SimpleFSQuotaUsage", ",", "err", "error", ")", "{", "ctx", "=", "k", ".", "makeContext", "(", "ctx", ")", "\n", "path", ":=", "keybase1", ".", "NewPathWithKbfs", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "teamName", ".", "String", "(", ")", ")", ")", "\n", "fb", ",", "_", ",", "err", ":=", "k", ".", "getFolderBranchFromPath", "(", "ctx", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "SimpleFSQuotaUsage", "{", "}", ",", "err", "\n", "}", "\n", "if", "fb", "==", "(", "data", ".", "FolderBranch", "{", "}", ")", "{", "return", "keybase1", ".", "SimpleFSQuotaUsage", "{", "}", ",", "nil", "\n", "}", "\n\n", "status", ",", "_", ",", "err", ":=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "FolderStatus", "(", "ctx", ",", "fb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "SimpleFSQuotaUsage", "{", "}", ",", "err", "\n", "}", "\n\n", "res", ".", "UsageBytes", "=", "status", ".", "UsageBytes", "\n", "res", ".", "ArchiveBytes", "=", "status", ".", "ArchiveBytes", "\n", "res", ".", "LimitBytes", "=", "status", ".", "LimitBytes", "\n", "res", ".", "GitUsageBytes", "=", "status", ".", "GitUsageBytes", "\n", "res", ".", "GitArchiveBytes", "=", "status", ".", "GitArchiveBytes", "\n", "res", ".", "GitLimitBytes", "=", "status", ".", "GitLimitBytes", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "SimpleFSGetTeamQuotaUsage", "returns", "the", "quota", "usage", "information", "for", "the", "given", "team", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSFolderSyncConfigAndStatus", "(", "ctx", "context", ".", "Context", ",", "path", "keybase1", ".", "Path", ")", "(", "keybase1", ".", "FolderSyncConfigAndStatus", ",", "error", ")", "{", "ctx", "=", "k", ".", "makeContext", "(", "ctx", ")", "\n", "_", ",", "config", ",", "err", ":=", "k", ".", "getSyncConfig", "(", "ctx", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "FolderSyncConfigAndStatus", "{", "}", ",", "err", "\n", "}", "\n", "res", ":=", "keybase1", ".", "FolderSyncConfigAndStatus", "{", "Config", ":", "config", "}", "\n\n", "if", "config", ".", "Mode", "!=", "keybase1", ".", "FolderSyncMode_DISABLED", "{", "fs", ",", "finalElem", ",", "err", ":=", "k", ".", "getFSIfExists", "(", "ctx", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "// Use LStat so we don't follow symlinks.", "fi", ",", "err", ":=", "fs", ".", "Lstat", "(", "finalElem", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "if", "kmg", ",", "ok", ":=", "fi", ".", "Sys", "(", ")", ".", "(", "libfs", ".", "KBFSMetadataForSimpleFSGetter", ")", ";", "ok", "{", "metadata", ",", "err", ":=", "kmg", ".", "KBFSMetadataForSimpleFS", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "FolderSyncConfigAndStatus", "{", "}", ",", "err", "\n", "}", "\n", "res", ".", "Status", ".", "PrefetchStatus", "=", "metadata", ".", "PrefetchStatus", "\n", "res", ".", "Status", ".", "PrefetchProgress", "=", "metadata", ".", "PrefetchProgress", ".", "ToProtocolProgress", "(", "k", ".", "config", ".", "Clock", "(", ")", ")", "\n\n", "dbc", ":=", "k", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "libfs", ",", "ok", ":=", "fs", ".", "(", "*", "libfs", ".", "FS", ")", "\n", "if", "dbc", "!=", "nil", "&&", "ok", "{", "size", ",", "err", ":=", "dbc", ".", "GetTlfSize", "(", "ctx", ",", "libfs", ".", "RootNode", "(", ")", ".", "GetFolderBranch", "(", ")", ".", "Tlf", ",", "libkbfs", ".", "DiskBlockSyncCache", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "res", ".", "Status", ".", "StoredBytesTotal", "=", "int64", "(", "size", ")", "\n", "}", "\n", "}", "else", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "fi", ".", "Sys", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "res", ".", "Status", ".", "LocalDiskBytesAvailable", ",", "res", ".", "Status", ".", "LocalDiskBytesTotal", "=", "k", ".", "getLocalDiskStats", "(", "ctx", ")", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "SimpleFSFolderSyncConfigAndStatus", "gets", "the", "given", "folder", "s", "sync", "config", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSSetFolderSyncConfig", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "SimpleFSSetFolderSyncConfigArg", ")", "error", "{", "ctx", "=", "k", ".", "makeContext", "(", "ctx", ")", "\n", "tlfID", ",", "_", ",", "err", ":=", "k", ".", "getSyncConfig", "(", "ctx", ",", "arg", ".", "Path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "SetSyncConfig", "(", "ctx", ",", "tlfID", ",", "arg", ".", "Config", ")", "\n", "return", "err", "\n", "}" ]

[ "SimpleFSSetFolderSyncConfig", "implements", "the", "SimpleFSInterface", "." ]

[ "func", "(", "k", "*", "SimpleFS", ")", "SimpleFSClearConflictState", "(", "ctx", "context", ".", "Context", ",", "path", "keybase1", ".", "Path", ")", "error", "{", "ctx", "=", "k", ".", "makeContext", "(", "ctx", ")", "\n", "t", ",", "tlfName", ",", "_", ",", "_", ",", "err", ":=", "remoteTlfAndPath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "tlfHandle", ",", "err", ":=", "libkbfs", ".", "GetHandleFromFolderNameAndType", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "k", ".", "config", ".", "MDOps", "(", ")", ",", "k", ".", "config", ",", "tlfName", ",", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "tlfID", ":=", "tlfHandle", ".", "TlfID", "(", ")", "\n", "return", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "ClearConflictView", "(", "ctx", ",", "tlfID", ")", "\n", "}" ]

[ "SimpleFSClearConflictState", "implements", "the", "SimpleFS", "interface", "." ]

[ "func", "handleCommonSpecialFile", "(", "name", "string", ",", "fs", "*", "FS", ",", "entryValid", "*", "time", ".", "Duration", ")", "fs", ".", "Node", "{", "switch", "name", "{", "case", "libkbfs", ".", "ErrorFile", ":", "return", "NewErrorFile", "(", "fs", ",", "entryValid", ")", "\n", "case", "libfs", ".", "MetricsFileName", ":", "return", "NewMetricsFile", "(", "fs", ",", "entryValid", ")", "\n", "case", "libfs", ".", "ProfileListDirName", ":", "return", "ProfileList", "{", "}", "\n", "case", "libfs", ".", "ResetCachesFileName", ":", "return", "&", "ResetCachesFile", "{", "fs", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "handleCommonSpecialFile", "handles", "special", "files", "that", "are", "present", "both", "within", "a", "TLF", "and", "outside", "a", "TLF", "." ]

[ "func", "handleTLFSpecialFile", "(", "name", "string", ",", "folder", "*", "Folder", ",", "entryValid", "*", "time", ".", "Duration", ")", "fs", ".", "Node", "{", "specialNode", ":=", "handleCommonSpecialFile", "(", "name", ",", "folder", ".", "fs", ",", "entryValid", ")", "\n", "if", "specialNode", "!=", "nil", "{", "return", "specialNode", "\n", "}", "\n\n", "switch", "name", "{", "case", "libfs", ".", "UpdateHistoryFileName", ":", "return", "NewUpdateHistoryFile", "(", "folder", ",", "entryValid", ")", "\n\n", "case", "libfs", ".", "EditHistoryName", ":", "return", "NewTlfEditHistoryFile", "(", "folder", ",", "entryValid", ")", "\n\n", "case", "libfs", ".", "UnstageFileName", ":", "return", "&", "UnstageFile", "{", "folder", ":", "folder", ",", "}", "\n\n", "case", "libfs", ".", "DisableUpdatesFileName", ":", "return", "&", "UpdatesFile", "{", "folder", ":", "folder", ",", "}", "\n\n", "case", "libfs", ".", "EnableUpdatesFileName", ":", "return", "&", "UpdatesFile", "{", "folder", ":", "folder", ",", "enable", ":", "true", ",", "}", "\n\n", "case", "libfs", ".", "RekeyFileName", ":", "return", "&", "RekeyFile", "{", "folder", ":", "folder", ",", "}", "\n\n", "case", "libfs", ".", "ReclaimQuotaFileName", ":", "return", "&", "ReclaimQuotaFile", "{", "folder", ":", "folder", ",", "}", "\n\n", "case", "libfs", ".", "SyncFromServerFileName", ":", "// Don't cache the node so that the next lookup of", "// this file will force the dir to be re-checked", "// (i.e., loadDirHelper will be called again).", "*", "entryValid", "=", "0", "\n", "return", "&", "SyncFromServerFile", "{", "folder", ":", "folder", ",", "}", "\n\n", "case", "libfs", ".", "EnableJournalFileName", ":", "return", "&", "JournalControlFile", "{", "folder", ":", "folder", ",", "action", ":", "libfs", ".", "JournalEnable", ",", "}", "\n\n", "case", "libfs", ".", "FlushJournalFileName", ":", "return", "&", "JournalControlFile", "{", "folder", ":", "folder", ",", "action", ":", "libfs", ".", "JournalFlush", ",", "}", "\n\n", "case", "libfs", ".", "PauseJournalBackgroundWorkFileName", ":", "return", "&", "JournalControlFile", "{", "folder", ":", "folder", ",", "action", ":", "libfs", ".", "JournalPauseBackgroundWork", ",", "}", "\n\n", "case", "libfs", ".", "ResumeJournalBackgroundWorkFileName", ":", "return", "&", "JournalControlFile", "{", "folder", ":", "folder", ",", "action", ":", "libfs", ".", "JournalResumeBackgroundWork", ",", "}", "\n\n", "case", "libfs", ".", "DisableJournalFileName", ":", "return", "&", "JournalControlFile", "{", "folder", ":", "folder", ",", "action", ":", "libfs", ".", "JournalDisable", ",", "}", "\n\n", "case", "libfs", ".", "EnableSyncFileName", ":", "return", "&", "SyncControlFile", "{", "folder", ":", "folder", ",", "action", ":", "libfs", ".", "SyncEnable", ",", "}", "\n\n", "case", "libfs", ".", "DisableSyncFileName", ":", "return", "&", "SyncControlFile", "{", "folder", ":", "folder", ",", "action", ":", "libfs", ".", "SyncDisable", ",", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "handleTLFSpecialFile", "handles", "special", "files", "that", "are", "within", "a", "TLF", "." ]

[ "func", "MakeCPUProfileFilename", "(", "dir", "string", ",", "start", "time", ".", "Time", ",", "duration", "time", ".", "Duration", ")", "string", "{", "return", "makeProfileFilename", "(", "cpuProfilePrefix", ",", "dir", ",", "start", ",", "duration", ")", "\n", "}" ]

[ "MakeCPUProfileFilename", "returns", "a", "filename", "to", "use", "for", "a", "CPU", "profile", "file", "in", "the", "given", "directory", "with", "the", "given", "start", "time", "and", "duration", "." ]

[ "func", "MakeTraceFilename", "(", "dir", "string", ",", "start", "time", ".", "Time", ",", "duration", "time", ".", "Duration", ")", "string", "{", "return", "makeProfileFilename", "(", "tracePrefix", ",", "dir", ",", "start", ",", "duration", ")", "\n", "}" ]

[ "MakeTraceFilename", "returns", "a", "filename", "to", "use", "for", "a", "trace", "file", "in", "the", "given", "directory", "with", "the", "given", "start", "time", "and", "duration", "." ]

[ "func", "(", "s", "NaclSigInfo", ")", "verifyWithPayload", "(", "payload", "[", "]", "byte", ",", "checkPayloadEquality", "bool", ")", "(", "*", "NaclSigningKeyPublic", ",", "error", ")", "{", "key", ":=", "KIDToNaclSigningKeyPublic", "(", "s", ".", "Kid", ")", "\n", "if", "key", "==", "nil", "{", "return", "nil", ",", "BadKeyError", "{", "}", "\n", "}", "\n", "if", "payload", "==", "nil", "{", "return", "nil", ",", "newVerificationErrorWithString", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "payload", ")", "==", "0", "{", "return", "nil", ",", "newVerificationErrorWithString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "checkPayloadEquality", "&&", "s", ".", "Payload", "!=", "nil", "&&", "!", "SecureByteArrayEq", "(", "payload", ",", "s", ".", "Payload", ")", "{", "return", "nil", ",", "newVerificationErrorWithString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "switch", "s", ".", "Version", "{", "case", "0", ",", "1", ":", "if", "!", "key", ".", "Verify", "(", "payload", ",", "s", ".", "Sig", ")", "{", "return", "nil", ",", "newVerificationErrorWithString", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "2", ":", "if", "!", "s", ".", "Prefix", ".", "IsWhitelisted", "(", ")", "{", "return", "nil", ",", "newVerificationErrorWithString", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "key", ".", "Verify", "(", "s", ".", "Prefix", ".", "Prefix", "(", "payload", ")", ",", "s", ".", "Sig", ")", "{", "return", "nil", ",", "newVerificationErrorWithString", "(", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "nil", ",", "UnhandledSignatureError", "{", "s", ".", "Version", "}", "\n", "}", "\n\n", "return", "key", ",", "nil", "\n", "}" ]

[ "verifyWithPayload", "verifies", "the", "NaclSigInfo", "s", "with", "the", "payload", "payload", ".", "Note", "that", "s", "may", "or", "may", "not", "have", "a", "payload", "already", "baked", "into", "it", ".", "If", "it", "does", "and", "checkPayloadEquality", "is", "true", "then", "we", "assert", "that", "the", "baked", "-", "in", "payload", "is", "equal", "to", "the", "specified", "payload", ".", "We", "ll", "only", "pass", "false", "for", "this", "flag", "from", "just", "above", "to", "avoid", "checking", "that", "s", ".", "Payload", "==", "s", ".", "Payload", "which", "we", "know", "it", "does", ".", "We", "need", "this", "unfortunate", "complexity", "because", "some", "signatures", "the", "client", "tries", "to", "verify", "are", "attached", "meaning", "the", "payload", "comes", "along", "with", "the", "sig", "info", ".", "And", "in", "other", "cases", "the", "signatures", "are", "detached", "meaning", "they", "are", "supplied", "out", "-", "of", "-", "band", ".", "This", "function", "handles", "both", "cases", "." ]

[ "func", "NewInfiniteChannelWrapper", "(", ")", "*", "InfiniteChannelWrapper", "{", "ch", ":=", "&", "InfiniteChannelWrapper", "{", "InfiniteChannel", ":", "channels", ".", "NewInfiniteChannel", "(", ")", ",", "input", ":", "make", "(", "chan", "interface", "{", "}", ",", "defaultInfiniteBufferSize", ")", ",", "shutdownCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "go", "ch", ".", "run", "(", ")", "\n", "return", "ch", "\n", "}" ]

[ "NewInfiniteChannelWrapper", "returns", "a", "wrapper", "around", "a", "new", "infinite", "channel", "." ]

[ "func", "(", "f", "*", "JSONConfigFile", ")", "Check", "(", ")", "error", "{", "return", "PickFirstError", "(", "// Feel free to add others here..", "func", "(", ")", "error", "{", "_", ",", "err", ":=", "f", ".", "GetRunMode", "(", ")", "\n", "return", "err", "\n", "}", "(", ")", ",", ")", "\n", "}" ]

[ "Check", "looks", "inside", "the", "JSON", "file", "to", "see", "if", "any", "fields", "are", "poorly", "specified" ]

[ "func", "(", "f", "*", "JSONConfigFile", ")", "getUserConfigWithLock", "(", ")", "(", "ret", "*", "UserConfig", ",", "err", "error", ")", "{", "var", "s", "string", "\n", "if", "ret", "=", "f", ".", "userConfigWrapper", ".", "userConfig", ";", "ret", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "s", ",", "err", "=", "f", ".", "jw", ".", "AtKey", "(", "\"", "\"", ")", ".", "GetString", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "nu", ":=", "NewNormalizedUsername", "(", "s", ")", "\n", "if", "ret", ",", "err", "=", "f", ".", "GetUserConfigForUsername", "(", "nu", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "else", "if", "ret", "!=", "nil", "{", "f", ".", "userConfigWrapper", ".", "userConfig", "=", "ret", "\n", "}", "else", "{", "err", "=", "ConfigError", "{", "f", ".", "filename", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ")", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "GetUserConfig", "looks", "for", "the", "current_user", "field", "to", "see", "if", "there", "s", "a", "corresponding", "user", "object", "in", "the", "users", "table", ".", "There", "really", "should", "be", "." ]

[ "func", "(", "f", "*", "JSONConfigFile", ")", "NukeUser", "(", "nu", "NormalizedUsername", ")", "error", "{", "f", ".", "userConfigWrapper", ".", "Lock", "(", ")", "\n", "defer", "f", ".", "userConfigWrapper", ".", "Unlock", "(", ")", "\n\n", "if", "cu", ":=", "f", ".", "getCurrentUser", "(", ")", ";", "nu", ".", "IsNil", "(", ")", "||", "cu", ".", "Eq", "(", "nu", ")", "{", "err", ":=", "f", ".", "jw", ".", "DeleteValueAtPath", "(", "\"", "\"", ")", "\n", "f", ".", "userConfigWrapper", ".", "userConfig", "=", "nil", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "nu", ".", "IsNil", "(", ")", "{", "nu", "=", "cu", "\n", "}", "\n", "}", "\n\n", "if", "!", "f", ".", "jw", ".", "AtKey", "(", "\"", "\"", ")", ".", "AtKey", "(", "nu", ".", "String", "(", ")", ")", ".", "IsNil", "(", ")", "{", "err", ":=", "f", ".", "jw", ".", "DeleteValueAtPath", "(", "\"", "\"", "+", "nu", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "f", ".", "Save", "(", ")", "\n", "}" ]

[ "NukeUser", "deletes", "the", "given", "user", "from", "the", "config", "file", "or", "if", "the", "given", "user", "is", "empty", "deletes", "the", "current", "user", "from", "the", "config", "file", "." ]

[ "func", "(", "f", "*", "JSONConfigFile", ")", "GetUserConfigForUsername", "(", "nu", "NormalizedUsername", ")", "(", "*", "UserConfig", ",", "error", ")", "{", "if", "uc", ":=", "f", ".", "copyUserConfigIfForUsername", "(", "nu", ")", ";", "uc", "!=", "nil", "{", "return", "uc", ",", "nil", "\n", "}", "\n", "return", "ImportUserConfigFromJSONWrapper", "(", "f", ".", "jw", ".", "AtKey", "(", "\"", "\"", ")", ".", "AtKey", "(", "nu", ".", "String", "(", ")", ")", ")", "\n", "}" ]

[ "GetUserConfigForUsername", "sees", "if", "there", "s", "a", "UserConfig", "object", "for", "the", "given", "username", "previously", "stored", "." ]

[ "func", "(", "f", "*", "JSONConfigFile", ")", "GetUserConfigForUID", "(", "u", "keybase1", ".", "UID", ")", "(", "*", "UserConfig", ",", "error", ")", "{", "if", "uc", ":=", "f", ".", "copyUserConfigIfForUID", "(", "u", ")", ";", "uc", "!=", "nil", "{", "return", "uc", ",", "nil", "\n", "}", "\n\n", "d", ":=", "f", ".", "jw", ".", "AtKey", "(", "\"", "\"", ")", "\n", "keys", ",", "_", ":=", "d", ".", "Keys", "(", ")", "\n", "for", "_", ",", "key", ":=", "range", "keys", "{", "uc", ",", "err", ":=", "f", ".", "GetUserConfigForUsername", "(", "NewNormalizedUsername", "(", "key", ")", ")", "\n", "if", "err", "==", "nil", "&&", "uc", "!=", "nil", "&&", "uc", ".", "GetUID", "(", ")", ".", "Equal", "(", "u", ")", "{", "return", "uc", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "GetUserConfigForUID", "sees", "if", "there", "s", "a", "UserConfig", "object", "for", "the", "given", "UIDs", "previously", "stored", "." ]

[ "func", "(", "f", "*", "JSONConfigFile", ")", "SetDeviceID", "(", "did", "keybase1", ".", "DeviceID", ")", "(", "err", "error", ")", "{", "f", ".", "userConfigWrapper", ".", "Lock", "(", ")", "\n", "defer", "f", ".", "userConfigWrapper", ".", "Unlock", "(", ")", "\n\n", "f", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\\n", "\"", ",", "did", ")", "\n", "var", "u", "*", "UserConfig", "\n", "if", "u", ",", "err", "=", "f", ".", "getUserConfigWithLock", "(", ")", ";", "err", "!=", "nil", "{", "}", "else", "if", "u", "==", "nil", "{", "err", "=", "NoUserConfigError", "{", "}", "\n", "}", "else", "{", "u", ".", "SetDevice", "(", "did", ")", "\n", "err", "=", "f", ".", "setUserConfigWithLock", "(", "u", ",", "true", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "SetDeviceID", "sets", "the", "device", "field", "of", "the", "UserConfig", "object" ]

[ "func", "(", "p", "*", "CommandLine", ")", "ChooseCommand", "(", "cmd", "Command", ",", "name", "string", ",", "ctx", "*", "cli", ".", "Context", ")", "{", "p", ".", "cmd", "=", "cmd", "\n", "p", ".", "name", "=", "name", "\n", "p", ".", "ctx", "=", "ctx", "\n", "}" ]

[ "Called", "back", "from", "inside", "our", "subcommands", "when", "they", "re", "picked", "..." ]

[ "func", "(", "p", "*", "CommandLine", ")", "AddHelpTopics", "(", "topics", "[", "]", "cli", ".", "HelpTopic", ")", "{", "p", ".", "app", ".", "HelpTopics", "=", "append", "(", "p", ".", "app", ".", "HelpTopics", ",", "topics", "...", ")", "\n", "}" ]

[ "AddHelpTopics", "appends", "topics", "to", "the", "list", "of", "help", "topics", "for", "this", "app", "." ]

[ "func", "NewBlockServerMemory", "(", "log", "logger", ".", "Logger", ")", "*", "BlockServerMemory", "{", "return", "&", "BlockServerMemory", "{", "log", ",", "sync", ".", "RWMutex", "{", "}", ",", "make", "(", "map", "[", "kbfsblock", ".", "ID", "]", "blockMemEntry", ")", ",", "}", "\n", "}" ]

[ "NewBlockServerMemory", "constructs", "a", "new", "BlockServerMemory", "that", "stores", "its", "data", "in", "memory", "." ]

[ "func", "(", "b", "*", "BlockServerMemory", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ",", "_", "DiskBlockCacheType", ")", "(", "data", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ")", "\n", "b", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "b", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "if", "b", ".", "m", "==", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "errBlockServerMemoryShutdown", "\n", "}", "\n\n", "entry", ",", "ok", ":=", "b", ".", "m", "[", "id", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "kbfsblock", ".", "ServerErrorBlockNonExistent", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ")", "}", "\n", "}", "\n\n", "if", "entry", ".", "tlfID", "!=", "tlfID", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "entry", ".", "tlfID", ",", "tlfID", ")", "\n", "}", "\n\n", "exists", ",", "_", ",", "err", ":=", "entry", ".", "refs", ".", "checkExists", "(", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n", "if", "!", "exists", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "blockNonExistentError", "{", "id", "}", "\n", "}", "\n\n", "return", "entry", ".", "blockData", ",", "entry", ".", "keyServerHalf", ",", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerMemory", ")", "doPut", "(", "isRegularPut", "bool", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ",", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "err", "=", "validateBlockPut", "(", "isRegularPut", ",", "id", ",", "context", ",", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "b", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "if", "b", ".", "m", "==", "nil", "{", "return", "errBlockServerMemoryShutdown", "\n", "}", "\n\n", "var", "refs", "blockRefMap", "\n", "if", "entry", ",", "ok", ":=", "b", ".", "m", "[", "id", "]", ";", "ok", "{", "// If the entry already exists, everything should be", "// the same, except for possibly additional", "// references.", "if", "entry", ".", "tlfID", "!=", "tlfID", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "entry", ".", "tlfID", ",", "tlfID", ")", "\n", "}", "\n\n", "// We checked that buf hashes to id, so no need to", "// check that it's equal to entry.data (since that was", "// presumably already checked previously).", "if", "isRegularPut", "&&", "entry", ".", "keyServerHalf", "!=", "serverHalf", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "entry", ".", "keyServerHalf", ",", "serverHalf", ")", "\n", "}", "\n\n", "refs", "=", "entry", ".", "refs", "\n", "}", "else", "{", "data", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "buf", ")", ")", "\n", "copy", "(", "data", ",", "buf", ")", "\n", "refs", "=", "make", "(", "blockRefMap", ")", "\n", "b", ".", "m", "[", "id", "]", "=", "blockMemEntry", "{", "tlfID", ":", "tlfID", ",", "blockData", ":", "data", ",", "keyServerHalf", ":", "serverHalf", ",", "refs", ":", "refs", ",", "}", "\n", "}", "\n\n", "return", "refs", ".", "put", "(", "context", ",", "liveBlockRef", ",", "\"", "\"", ")", "\n", "}" ]

[ "doPut", "consolidates", "the", "put", "logic", "for", "implementing", "both", "the", "Put", "and", "PutAgain", "interface", "." ]

[ "func", "(", "b", "*", "BlockServerMemory", ")", "PutAgain", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ",", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "_", "DiskBlockCacheType", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ",", "len", "(", "buf", ")", ")", "\n\n", "return", "b", ".", "doPut", "(", "false", ",", "tlfID", ",", "id", ",", "context", ",", "buf", ",", "serverHalf", ")", "\n", "}" ]

[ "PutAgain", "implements", "the", "BlockServer", "interface", "for", "BlockServerMemory", "." ]

[ "func", "(", "b", "*", "BlockServerMemory", ")", "AddBlockReference", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ")", "\n\n", "b", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "if", "b", ".", "m", "==", "nil", "{", "return", "errBlockServerMemoryShutdown", "\n", "}", "\n\n", "entry", ",", "ok", ":=", "b", ".", "m", "[", "id", "]", "\n", "if", "!", "ok", "{", "return", "kbfsblock", ".", "ServerErrorBlockNonExistent", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "id", ")", "}", "\n", "}", "\n\n", "if", "entry", ".", "tlfID", "!=", "tlfID", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "entry", ".", "tlfID", ",", "tlfID", ")", "\n", "}", "\n\n", "return", "entry", ".", "refs", ".", "put", "(", "context", ",", "liveBlockRef", ",", "\"", "\"", ")", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerMemory", ")", "RemoveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "liveCounts", "map", "[", "kbfsblock", ".", "ID", "]", "int", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ",", "contexts", ")", "\n", "liveCounts", "=", "make", "(", "map", "[", "kbfsblock", ".", "ID", "]", "int", ")", "\n", "for", "id", ",", "idContexts", ":=", "range", "contexts", "{", "count", ",", "err", ":=", "b", ".", "removeBlockReference", "(", "tlfID", ",", "id", ",", "idContexts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "liveCounts", "[", "id", "]", "=", "count", "\n", "}", "\n", "return", "liveCounts", ",", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerMemory", ")", "ArchiveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ",", "contexts", ")", "\n\n", "for", "id", ",", "idContexts", ":=", "range", "contexts", "{", "for", "_", ",", "context", ":=", "range", "idContexts", "{", "err", ":=", "b", ".", "archiveBlockReference", "(", "tlfID", ",", "id", ",", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerMemory", ")", "GetLiveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "liveCounts", "map", "[", "kbfsblock", ".", "ID", "]", "int", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ",", "contexts", ")", "\n\n", "b", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "if", "b", ".", "m", "==", "nil", "{", "return", "nil", ",", "errBlockServerMemoryShutdown", "\n", "}", "\n\n", "liveCounts", "=", "make", "(", "map", "[", "kbfsblock", ".", "ID", "]", "int", ")", "\n", "for", "id", ":=", "range", "contexts", "{", "count", ":=", "0", "\n", "entry", ",", "ok", ":=", "b", ".", "m", "[", "id", "]", "\n", "if", "ok", "{", "count", "=", "entry", ".", "refs", ".", "getLiveCount", "(", ")", "\n", "}", "\n", "liveCounts", "[", "id", "]", "=", "count", "\n", "}", "\n", "return", "liveCounts", ",", "nil", "\n", "}" ]

[ "GetLiveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerMemory", "." ]

[ "func", "(", "b", "*", "BlockServerMemory", ")", "IsUnflushed", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "_", "kbfsblock", ".", "ID", ")", "(", "bool", ",", "error", ")", "{", "b", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "b", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "if", "b", ".", "m", "==", "nil", "{", "return", "false", ",", "errBlockServerMemoryShutdown", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerMemory", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "{", "b", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "lock", ".", "Unlock", "(", ")", "\n", "// Make further accesses error out.", "b", ".", "m", "=", "nil", "\n", "}" ]

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

[ "func", "NewKeyCacheMeasured", "(", "delegate", "KeyCache", ",", "r", "metrics", ".", "Registry", ")", "KeyCacheMeasured", "{", "getTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "putTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "// TODO: Implement RatioGauge (", "// http://metrics.dropwizard.io/3.1.0/manual/core/#ratio-gauges", "// ) so we can actually display a hit ratio.", "hitCountMeter", ":=", "metrics", ".", "GetOrRegisterMeter", "(", "\"", "\"", ",", "r", ")", "\n", "return", "KeyCacheMeasured", "{", "delegate", ":", "delegate", ",", "getTimer", ":", "getTimer", ",", "putTimer", ":", "putTimer", ",", "hitCountMeter", ":", "hitCountMeter", ",", "}", "\n", "}" ]

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

[ "func", "(", "b", "KeyCacheMeasured", ")", "GetTLFCryptKey", "(", "tlfID", "tlf", ".", "ID", ",", "keyGen", "kbfsmd", ".", "KeyGen", ")", "(", "key", "kbfscrypto", ".", "TLFCryptKey", ",", "err", "error", ")", "{", "b", ".", "getTimer", ".", "Time", "(", "func", "(", ")", "{", "key", ",", "err", "=", "b", ".", "delegate", ".", "GetTLFCryptKey", "(", "tlfID", ",", "keyGen", ")", "\n", "}", ")", "\n", "if", "err", "==", "nil", "{", "b", ".", "hitCountMeter", ".", "Mark", "(", "1", ")", "\n", "}", "\n", "return", "key", ",", "err", "\n", "}" ]

[ "GetTLFCryptKey", "implements", "the", "KeyCache", "interface", "for", "KeyCacheMeasured", "." ]

[ "func", "(", "b", "KeyCacheMeasured", ")", "PutTLFCryptKey", "(", "tlfID", "tlf", ".", "ID", ",", "keyGen", "kbfsmd", ".", "KeyGen", ",", "key", "kbfscrypto", ".", "TLFCryptKey", ")", "(", "err", "error", ")", "{", "b", ".", "putTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "b", ".", "delegate", ".", "PutTLFCryptKey", "(", "tlfID", ",", "keyGen", ",", "key", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "PutTLFCryptKey", "implements", "the", "KeyCache", "interface", "for", "KeyCacheMeasured", "." ]

[ "func", "mountpointMatchesRunmode", "(", "mp", ",", "runmode", "string", ")", "bool", "{", "i", ":=", "strings", ".", "Index", "(", "mp", ",", "runmode", ")", "\n", "if", "i", "<", "0", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "mp", ")", "==", "i", "+", "len", "(", "runmode", ")", "||", "mp", "[", "i", "+", "len", "(", "runmode", ")", "]", "==", "'/'", "||", "mp", "[", "i", "+", "len", "(", "runmode", ")", "]", "==", "' '", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "mountpointMatchesRunmode", "returns", "true", "if", "mp", "contains", "runmode", "at", "the", "end", "of", "a", "component", "of", "the", "path", "or", "followed", "by", "a", "space", "." ]

[ "func", "SignJSON", "(", "jw", "*", "jsonw", ".", "Wrapper", ",", "key", "GenericKey", ")", "(", "out", "string", ",", "id", "keybase1", ".", "SigID", ",", "lid", "LinkID", ",", "err", "error", ")", "{", "var", "tmp", "[", "]", "byte", "\n", "if", "tmp", ",", "err", "=", "jw", ".", "Marshal", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "out", ",", "id", ",", "err", "=", "key", ".", "SignToString", "(", "tmp", ")", "\n", "lid", "=", "ComputeLinkID", "(", "tmp", ")", "\n", "return", "\n", "}" ]

[ "SimpleSignJson", "marshals", "the", "given", "Json", "structure", "and", "then", "signs", "it", "." ]

[ "func", "PerUserKeyProof", "(", "m", "MetaContext", ",", "me", "*", "User", ",", "pukSigKID", "keybase1", ".", "KID", ",", "pukEncKID", "keybase1", ".", "KID", ",", "generation", "keybase1", ".", "PerUserKeyGeneration", ",", "signingKey", "GenericKey", ")", "(", "*", "ProofMetadataRes", ",", "error", ")", "{", "if", "me", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ret", ",", "err", ":=", "ProofMetadata", "{", "Me", ":", "me", ",", "LinkType", ":", "LinkTypePerUserKey", ",", "SigningKey", ":", "signingKey", ",", "}", ".", "ToJSON2", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "pukSection", ":=", "jsonw", ".", "NewDictionary", "(", ")", "\n", "pukSection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewString", "(", "pukSigKID", ".", "String", "(", ")", ")", ")", "\n", "pukSection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewString", "(", "pukEncKID", ".", "String", "(", ")", ")", ")", "\n", "pukSection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewInt", "(", "int", "(", "generation", ")", ")", ")", "\n", "// The caller is responsible for overwriting reverse_sig after signing.", "pukSection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewNil", "(", ")", ")", "\n\n", "body", ":=", "ret", ".", "J", ".", "AtKey", "(", "\"", "\"", ")", "\n", "body", ".", "SetKey", "(", "\"", "\"", ",", "pukSection", ")", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "PerUserKeyProof", "creates", "a", "proof", "introducing", "a", "new", "per", "-", "user", "-", "key", "generation", ".", "signingKey", "is", "the", "key", "signing", "in", "this", "new", "key", ".", "Not", "to", "be", "confused", "with", "the", "derived", "per", "-", "user", "-", "key", "signing", "key", "." ]

[ "func", "StellarProof", "(", "m", "MetaContext", ",", "me", "*", "User", ",", "walletAddress", "stellar1", ".", "AccountID", ",", "signingKey", "GenericKey", ")", "(", "*", "ProofMetadataRes", ",", "error", ")", "{", "if", "me", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "walletPubKey", ",", "err", ":=", "MakeNaclSigningKeyPairFromStellarAccountID", "(", "walletAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "walletKID", ":=", "walletPubKey", ".", "GetKID", "(", ")", "\n\n", "ret", ",", "err", ":=", "ProofMetadata", "{", "Me", ":", "me", ",", "LinkType", ":", "LinkTypeWalletStellar", ",", "SigningKey", ":", "signingKey", ",", "SigVersion", ":", "KeybaseSignatureV2", ",", "IgnoreIfUnsupported", ":", "SigIgnoreIfUnsupported", "(", "true", ")", ",", "}", ".", "ToJSON2", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "walletSection", ":=", "jsonw", ".", "NewDictionary", "(", ")", "\n", "walletSection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewString", "(", "walletAddress", ".", "String", "(", ")", ")", ")", "\n", "walletSection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewString", "(", "string", "(", "WalletNetworkStellar", ")", ")", ")", "\n\n", "// Inner links can be hidden. To prevent an attacker from figuring out the", "// contents from the hash of the inner link, add 18 random bytes.", "entropy", ",", "err", ":=", "LinkEntropy", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "walletSection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewString", "(", "entropy", ")", ")", "\n\n", "walletKeySection", ":=", "jsonw", ".", "NewDictionary", "(", ")", "\n", "walletKeySection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewString", "(", "walletKID", ".", "String", "(", ")", ")", ")", "\n", "// The caller is responsible for overwriting reverse_sig after signing.", "walletKeySection", ".", "SetKey", "(", "\"", "\"", ",", "jsonw", ".", "NewNil", "(", ")", ")", "\n\n", "body", ":=", "ret", ".", "J", ".", "AtKey", "(", "\"", "\"", ")", "\n", "body", ".", "SetKey", "(", "\"", "\"", ",", "walletSection", ")", "\n", "body", ".", "SetKey", "(", "\"", "\"", ",", "walletKeySection", ")", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "StellarProof", "creates", "a", "proof", "of", "a", "stellar", "wallet", "." ]

[ "func", "DecodeRootMetadata", "(", "codec", "kbfscodec", ".", "Codec", ",", "tlfID", "tlf", ".", "ID", ",", "ver", ",", "max", "MetadataVer", ",", "buf", "[", "]", "byte", ")", "(", "MutableRootMetadata", ",", "error", ")", "{", "rmd", ",", "err", ":=", "makeMutableRootMetadataForDecode", "(", "codec", ",", "tlfID", ",", "ver", ",", "max", ",", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "codec", ".", "Decode", "(", "buf", ",", "rmd", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "ver", "<", "ImplicitTeamsVer", "&&", "tlfID", ".", "Type", "(", ")", "!=", "tlf", ".", "SingleTeam", "&&", "rmd", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "ver", ")", "\n", "}", "\n", "return", "rmd", ",", "nil", "\n", "}" ]

[ "DecodeRootMetadata", "deserializes", "a", "metadata", "block", "into", "the", "specified", "versioned", "structure", "." ]

[ "func", "DumpRootMetadata", "(", "codec", "kbfscodec", ".", "Codec", ",", "rmd", "RootMetadata", ")", "(", "string", ",", "error", ")", "{", "serializedRMD", ",", "err", ":=", "codec", ".", "Encode", "(", "rmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// Make a copy so we can zero out SerializedPrivateMetadata.", "rmdCopy", ",", "err", ":=", "rmd", ".", "DeepCopy", "(", "codec", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "rmdCopy", ".", "SetSerializedPrivateMetadata", "(", "nil", ")", "\n", "s", ":=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\\n", "\"", ",", "rmd", ".", "RevisionNumber", "(", ")", ",", "len", "(", "serializedRMD", ")", ",", "len", "(", "rmd", ".", "GetSerializedPrivateMetadata", "(", ")", ")", ",", "rmd", ".", "Version", "(", ")", ")", "\n", "s", "+=", "DumpConfig", "(", ")", ".", "Sdump", "(", "rmdCopy", ")", "\n", "return", "s", ",", "nil", "\n", "}" ]

[ "DumpRootMetadata", "returns", "a", "detailed", "dump", "of", "the", "given", "RootMetadata", "s", "contents", "." ]

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

[ "Adds", "a", "folder", "to", "a", "user", "s", "list", "of", "favorite", "folders", "." ]

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

[ "Removes", "a", "folder", "from", "a", "user", "s", "list", "of", "favorite", "folders", "." ]

[ "func", "(", "c", "FavoriteClient", ")", "GetFavorites", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "res", "FavoritesResult", ",", "err", "error", ")", "{", "__arg", ":=", "GetFavoritesArg", "{", "SessionID", ":", "sessionID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Returns", "all", "of", "a", "user", "s", "favorite", "folders", "." ]

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

[ "NewCmdWatchdog2", "constructs", "watchdog", "command" ]

[ "func", "(", "dpk", "DevicePublicKeys", ")", "Equals", "(", "other", "DevicePublicKeys", ")", "bool", "{", "if", "len", "(", "dpk", ")", "!=", "len", "(", "other", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "k", ":=", "range", "dpk", "{", "if", "!", "other", "[", "k", "]", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "Equals", "returns", "whether", "both", "sets", "of", "keys", "are", "equal", "." ]

[ "func", "(", "udpk", "UserDevicePublicKeys", ")", "Equals", "(", "other", "UserDevicePublicKeys", ")", "bool", "{", "if", "len", "(", "udpk", ")", "!=", "len", "(", "other", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "u", ",", "dpk", ":=", "range", "udpk", "{", "if", "!", "dpk", ".", "Equals", "(", "other", "[", "u", "]", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "Equals", "returns", "whether", "both", "sets", "of", "users", "are", "equal", "and", "they", "all", "have", "corresponding", "equal", "sets", "of", "keys", "." ]

[ "func", "(", "serverHalves", "UserDeviceKeyServerHalves", ")", "MergeUsers", "(", "other", "UserDeviceKeyServerHalves", ")", "(", "UserDeviceKeyServerHalves", ",", "error", ")", "{", "merged", ":=", "make", "(", "UserDeviceKeyServerHalves", ",", "len", "(", "serverHalves", ")", "+", "len", "(", "other", ")", ")", "\n", "for", "uid", ",", "deviceServerHalves", ":=", "range", "serverHalves", "{", "merged", "[", "uid", "]", "=", "deviceServerHalves", "\n", "}", "\n", "for", "uid", ",", "deviceServerHalves", ":=", "range", "other", "{", "if", "_", ",", "ok", ":=", "merged", "[", "uid", "]", ";", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uid", ")", "\n", "}", "\n", "merged", "[", "uid", "]", "=", "deviceServerHalves", "\n", "}", "\n", "return", "merged", ",", "nil", "\n", "}" ]

[ "MergeUsers", "returns", "a", "UserDeviceKeyServerHalves", "that", "contains", "all", "the", "users", "in", "serverHalves", "and", "other", "which", "must", "be", "disjoint", ".", "This", "isn", "t", "a", "deep", "copy", "." ]

[ "func", "(", "info", "ServerHalfRemovalInfo", ")", "MergeUsers", "(", "other", "ServerHalfRemovalInfo", ")", "(", "ServerHalfRemovalInfo", ",", "error", ")", "{", "merged", ":=", "make", "(", "ServerHalfRemovalInfo", ",", "len", "(", "info", ")", "+", "len", "(", "other", ")", ")", "\n", "for", "uid", ",", "removalInfo", ":=", "range", "info", "{", "merged", "[", "uid", "]", "=", "removalInfo", "\n", "}", "\n", "for", "uid", ",", "removalInfo", ":=", "range", "other", "{", "if", "_", ",", "ok", ":=", "merged", "[", "uid", "]", ";", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uid", ")", "\n", "}", "\n", "merged", "[", "uid", "]", "=", "removalInfo", "\n", "}", "\n", "return", "merged", ",", "nil", "\n", "}" ]

[ "MergeUsers", "returns", "a", "ServerHalfRemovalInfo", "that", "contains", "all", "the", "users", "in", "info", "and", "other", "which", "must", "be", "disjoint", ".", "This", "isn", "t", "a", "deep", "copy", "." ]

[ "func", "(", "j", "journalBlockCache", ")", "CheckForKnownPtr", "(", "tlfID", "tlf", ".", "ID", ",", "block", "*", "data", ".", "FileBlock", ")", "(", "data", ".", "BlockPointer", ",", "error", ")", "{", "_", ",", "ok", ":=", "j", ".", "jManager", ".", "getTLFJournal", "(", "tlfID", ",", "nil", ")", "\n", "if", "!", "ok", "{", "return", "j", ".", "BlockCache", ".", "CheckForKnownPtr", "(", "tlfID", ",", "block", ")", "\n", "}", "\n\n", "// Temporarily disable de-duping for the journal server until", "// KBFS-1149 is fixed. (See also", "// journalBlockServer.AddReference.)", "return", "data", ".", "BlockPointer", "{", "}", ",", "nil", "\n", "}" ]

[ "CheckForKnownPtr", "implements", "BlockCache", "." ]

[ "func", "(", "c", "*", "CmdSimpleFSHistory", ")", "ParseArgv", "(", "ctx", "*", "cli", ".", "Context", ")", "error", "{", "c", ".", "deletes", "=", "ctx", ".", "Bool", "(", "\"", "\"", ")", "\n\n", "if", "len", "(", "ctx", ".", "Args", "(", ")", ")", ">", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "else", "if", "len", "(", "ctx", ".", "Args", "(", ")", ")", "==", "1", "{", "p", ",", "err", ":=", "makeSimpleFSPath", "(", "ctx", ".", "Args", "(", ")", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "path", "=", "p", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ParseArgv", "gets", "the", "optional", "path", "if", "any", "." ]

[ "func", "(", "s", "*", "searchSession", ")", "searchConv", "(", "ctx", "context", ".", "Context", ",", "convID", "chat1", ".", "ConversationID", ")", "(", "msgIDs", "[", "]", "chat1", ".", "MessageID", ",", "err", "error", ")", "{", "defer", "s", ".", "indexer", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "convID", ")", ")", "(", ")", "\n", "var", "allMsgIDs", "mapset", ".", "Set", "\n", "for", "token", ":=", "range", "s", ".", "tokens", "{", "matchedIDs", ":=", "mapset", ".", "NewThreadUnsafeSet", "(", ")", "\n", "idMap", ",", "err", ":=", "s", ".", "indexer", ".", "store", ".", "GetHits", "(", "ctx", ",", "s", ".", "uid", ",", "convID", ",", "token", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "msgID", ":=", "range", "idMap", "{", "matchedIDs", ".", "Add", "(", "msgID", ")", "\n", "}", "\n", "if", "allMsgIDs", "==", "nil", "{", "allMsgIDs", "=", "matchedIDs", "\n", "}", "else", "{", "allMsgIDs", "=", "allMsgIDs", ".", "Intersect", "(", "matchedIDs", ")", "\n", "if", "allMsgIDs", ".", "Cardinality", "(", ")", "==", "0", "{", "// no matches in this conversation..", "return", "nil", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "msgIDSlice", ":=", "msgIDsFromSet", "(", "allMsgIDs", ")", "\n\n", "// Sort so we can truncate if necessary, returning the newest results first.", "sort", ".", "Sort", "(", "utils", ".", "ByMsgID", "(", "msgIDSlice", ")", ")", "\n", "return", "msgIDSlice", ",", "nil", "\n", "}" ]

[ "searchConv", "finds", "all", "messages", "that", "match", "the", "given", "set", "of", "tokens", "and", "opts", "results", "are", "ordered", "desc", "by", "msg", "id", "." ]

[ "func", "(", "s", "*", "searchSession", ")", "preSearch", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "defer", "s", ".", "indexer", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "for", "_", ",", "conv", ":=", "range", "s", ".", "convList", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n", "s", ".", "updateInboxIndex", "(", "ctx", ",", "conv", ".", "Conv", ")", "\n", "switch", "s", ".", "opts", ".", "ReindexMode", "{", "case", "chat1", ".", "ReIndexingMode_POSTSEARCH_SYNC", ":", "fullyIndexed", ",", "err", ":=", "s", ".", "convFullyIndexed", "(", "ctx", ",", "conv", ".", "Conv", ")", "\n", "if", "err", "!=", "nil", "||", "!", "fullyIndexed", "{", "if", "err", "!=", "nil", "{", "s", ".", "indexer", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "s", ".", "reindexConvs", "=", "append", "(", "s", ".", "reindexConvs", ",", "conv", ".", "GetConvID", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "percentIndexed", ",", "err", ":=", "s", ".", "inboxIndexStatus", ".", "updateUI", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "s", ".", "indexer", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "percentIndexed", ")", "\n\n", "for", "_", ",", "conv", ":=", "range", "s", ".", "convList", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n", "switch", "s", ".", "opts", ".", "ReindexMode", "{", "case", "chat1", ".", "ReIndexingMode_PRESEARCH_SYNC", ":", "if", "err", ":=", "s", ".", "reindexConvWithUIUpdate", "(", "ctx", ",", "conv", ")", ";", "err", "!=", "nil", "{", "s", ".", "indexer", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "conv", ".", "GetName", "(", ")", ",", "conv", ".", "GetConvID", "(", ")", ",", "err", ")", "\n", "s", ".", "inboxIndexStatus", ".", "rmConv", "(", "conv", ".", "Conv", ")", "\n", "continue", "\n", "}", "\n", "s", ".", "updateInboxIndex", "(", "ctx", ",", "conv", ".", "Conv", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "preSearch", "is", "the", "first", "pipeline", "stage", "blocking", "on", "reindexing", "conversations", "if", "PRESEARCH_SYNC", "is", "set", ".", "As", "conversations", "are", "processed", "they", "are", "passed", "to", "the", "search", "stage", "via", "preSearchCh", "." ]

[ "func", "(", "s", "*", "searchSession", ")", "search", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "defer", "s", ".", "indexer", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "for", "_", ",", "conv", ":=", "range", "s", ".", "convList", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n", "if", "err", ":=", "s", ".", "searchConvWithUIUpdate", "(", "ctx", ",", "conv", ".", "GetConvID", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "s", ".", "searchDone", "(", "ctx", ",", "\"", "\"", ")", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "search", "performs", "the", "actual", "search", "on", "each", "conversation", "after", "it", "completes", "preSearch", "via", "preSearchCh" ]

[ "func", "(", "s", "*", "searchSession", ")", "postSearch", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "defer", "s", ".", "indexer", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "switch", "s", ".", "opts", ".", "ReindexMode", "{", "case", "chat1", ".", "ReIndexingMode_POSTSEARCH_SYNC", ":", "default", ":", "return", "nil", "\n", "}", "\n", "for", "_", ",", "convID", ":=", "range", "s", ".", "reindexConvs", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n", "conv", ":=", "s", ".", "getConv", "(", "convID", ")", "\n", "// ignore any fully indexed convs since we respect", "// opts.MaxConvsSearched", "fullyIndexed", ",", "err", ":=", "s", ".", "convFullyIndexed", "(", "ctx", ",", "conv", ".", "Conv", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "fullyIndexed", "{", "continue", "\n", "}", "\n", "if", "err", ":=", "s", ".", "reindexConvWithUIUpdate", "(", "ctx", ",", "conv", ")", ";", "err", "!=", "nil", "{", "s", ".", "indexer", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "conv", ".", "GetName", "(", ")", ",", "conv", ".", "GetConvID", "(", ")", ",", "err", ")", "\n", "s", ".", "inboxIndexStatus", ".", "rmConv", "(", "conv", ".", "Conv", ")", "\n", "continue", "\n", "}", "\n", "if", "s", ".", "searchDone", "(", "ctx", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "if", "err", ":=", "s", ".", "searchConvWithUIUpdate", "(", "ctx", ",", "convID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "postSearch", "is", "the", "final", "pipeline", "stage", "reindexing", "conversations", "if", "POSTSEARCH_SYNC", "is", "set", "." ]

[ "func", "(", "p", "*", "progressWriter", ")", "initialReport", "(", ")", "{", "if", "p", ".", "progress", "==", "nil", "{", "return", "\n", "}", "\n\n", "p", ".", "progress", "(", "0", ",", "p", ".", "total", ")", "\n", "}" ]

[ "send", "0%", "progress" ]

[ "func", "LoadScanProofsIgnore", "(", "filepath", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "filepath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "f", ")", "\n", "scanner", ".", "Split", "(", "bufio", ".", "ScanLines", ")", "\n", "var", "ignored", "[", "]", "string", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "x", ":=", "strings", ".", "TrimSpace", "(", "scanner", ".", "Text", "(", ")", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "x", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "ignored", "=", "append", "(", "ignored", ",", "x", ")", "\n", "}", "\n", "return", "ignored", ",", "nil", "\n", "}" ]

[ "LoadScanProofsIgnore", "loads", "an", "ignore", "file", "and", "returns", "the", "list", "of", "proofids", "to", "ignore", "." ]

[ "func", "(", "c", "ChatChannel", ")", "Valid", "(", ")", "bool", "{", "if", "len", "(", "c", ".", "Name", ")", "==", "0", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "c", ".", "MembersType", ")", ">", "0", "&&", "!", "isValidMembersType", "(", "c", ".", "MembersType", ")", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Valid", "returns", "true", "if", "the", "ChatChannel", "has", "at", "least", "a", "Name", "." ]

[ "func", "(", "j", "*", "tlfJournal", ")", "doBackgroundWork", "(", "ctx", "context", ".", "Context", ")", "<-", "chan", "error", "{", "errCh", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "// TODO: Handle panics.", "go", "func", "(", ")", "{", "defer", "j", ".", "wg", ".", "Done", "(", ")", "\n", "errCh", "<-", "j", ".", "flush", "(", "ctx", ")", "\n", "close", "(", "errCh", ")", "\n", "}", "(", ")", "\n", "return", "errCh", "\n", "}" ]

[ "doBackgroundWork", "currently", "only", "does", "auto", "-", "flushing", ".", "It", "assumes", "that", "ctx", "is", "canceled", "when", "the", "background", "processing", "should", "stop", "." ]