Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "(", "w", "*", "WalletState", ")", "Shutdown", "(", ")", "error", "{", "w", ".", "shutdownOnce", ".", "Do", "(", "func", "(", ")", "{", "mctx", ":=", "libkb", ".", "NewMetaContextBackground", "(", "w", ".", "G", "(", ")", ")", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "w", ".", "Lock", "(", ")", "\n", "w", ".", "resetWithLock", "(", "mctx", ")", "\n", "close", "(", "w", ".", "refreshReqs", ")", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "select", "{", "case", "<-", "w", ".", "backgroundDone", ":", "case", "<-", "time", ".", "After", "(", "5", "*", "time", ".", "Second", ")", ":", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "w", ".", "Unlock", "(", ")", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "Shutdown", "terminates", "any", "background", "operations", "and", "cleans", "up", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "SeqnoUnlock", "(", ")", "{", "w", ".", "Lock", "(", ")", "\n", "w", ".", "seqnoMu", ".", "Unlock", "(", ")", "\n", "w", ".", "seqnoLockHeld", "=", "false", "\n", "w", ".", "Unlock", "(", ")", "\n", "}" ]

[ "SeqnoUnlock", "releases", "the", "lock", "on", "seqno", "operations", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "BaseFee", "(", "mctx", "libkb", ".", "MetaContext", ")", "uint64", "{", "return", "w", ".", "options", ".", "BaseFee", "(", "mctx", ",", "w", ")", "\n", "}" ]

[ "BaseFee", "returns", "stellard", "s", "current", "suggestion", "for", "the", "base", "operation", "fee", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "AccountName", "(", "accountID", "stellar1", ".", "AccountID", ")", "(", "string", ",", "error", ")", "{", "a", ",", "ok", ":=", "w", ".", "accountState", "(", "accountID", ")", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "ErrAccountNotFound", "\n", "}", "\n\n", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n\n", "return", "a", ".", "name", ",", "nil", "\n", "}" ]

[ "AccountName", "returns", "the", "name", "for", "an", "account", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "IsPrimary", "(", "accountID", "stellar1", ".", "AccountID", ")", "(", "bool", ",", "error", ")", "{", "a", ",", "ok", ":=", "w", ".", "accountState", "(", "accountID", ")", "\n", "if", "!", "ok", "{", "return", "false", ",", "ErrAccountNotFound", "\n", "}", "\n\n", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n\n", "return", "a", ".", "isPrimary", ",", "nil", "\n", "}" ]

[ "IsPrimary", "returns", "true", "if", "an", "account", "is", "the", "primary", "account", "for", "the", "user", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "accountState", "(", "accountID", "stellar1", ".", "AccountID", ")", "(", "*", "AccountState", ",", "bool", ")", "{", "w", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "Unlock", "(", ")", "\n\n", "a", ",", "ok", ":=", "w", ".", "accounts", "[", "accountID", "]", "\n", "return", "a", ",", "ok", "\n", "}" ]

[ "accountState", "returns", "the", "AccountState", "object", "for", "an", "accountID", ".", "If", "it", "doesn", "t", "exist", "in", "accounts", "it", "will", "return", "nil", "false", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "accountStateBuild", "(", "accountID", "stellar1", ".", "AccountID", ")", "(", "account", "*", "AccountState", ",", "built", "bool", ")", "{", "w", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "Unlock", "(", ")", "\n\n", "a", ",", "ok", ":=", "w", ".", "accounts", "[", "accountID", "]", "\n", "if", "ok", "{", "return", "a", ",", "false", "\n", "}", "\n\n", "a", "=", "newAccountState", "(", "accountID", ",", "w", ".", "Remoter", ",", "w", ".", "refreshReqs", ")", "\n", "w", ".", "accounts", "[", "accountID", "]", "=", "a", "\n\n", "return", "a", ",", "true", "\n", "}" ]

[ "accountStateBuild", "returns", "the", "AccountState", "object", "for", "an", "accountID", ".", "If", "it", "doesn", "t", "exist", "in", "accounts", "it", "will", "make", "an", "empty", "one", "and", "add", "it", "to", "accounts", "before", "returning", "it", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "accountStateRefresh", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ",", "reason", "string", ")", "(", "*", "AccountState", ",", "error", ")", "{", "w", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "Unlock", "(", ")", "\n\n", "a", ",", "ok", ":=", "w", ".", "accounts", "[", "accountID", "]", "\n", "if", "ok", "{", "return", "a", ",", "nil", "\n", "}", "\n\n", "reason", "=", "\"", "\"", "+", "reason", "\n", "a", "=", "newAccountState", "(", "accountID", ",", "w", ".", "Remoter", ",", "w", ".", "refreshReqs", ")", "\n", "mctx", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "w", ".", "G", "(", ")", ")", "\n", "if", "err", ":=", "a", ".", "Refresh", "(", "mctx", ",", "w", ".", "G", "(", ")", ".", "NotifyRouter", ",", "reason", ")", ";", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "accountID", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "w", ".", "accounts", "[", "accountID", "]", "=", "a", "\n\n", "return", "a", ",", "nil", "\n", "}" ]

[ "accountStateRefresh", "returns", "the", "AccountState", "object", "for", "an", "accountID", ".", "If", "it", "doesn", "t", "exist", "in", "accounts", "it", "will", "make", "an", "empty", "one", "add", "it", "to", "accounts", "and", "refresh", "the", "data", "in", "it", "before", "returning", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "Primed", "(", ")", "bool", "{", "w", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "Unlock", "(", ")", "\n", "return", "w", ".", "refreshCount", ">", "0", "\n", "}" ]

[ "Primed", "returns", "true", "if", "the", "WalletState", "has", "been", "refreshed", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "UpdateAccountEntries", "(", "mctx", "libkb", ".", "MetaContext", ",", "reason", "string", ")", "(", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "reason", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "bundle", ",", "err", ":=", "remote", ".", "FetchSecretlessBundle", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "w", ".", "UpdateAccountEntriesWithBundle", "(", "mctx", ",", "reason", ",", "bundle", ")", "\n", "}" ]

[ "UpdateAccountEntries", "gets", "the", "bundle", "from", "the", "server", "and", "updates", "the", "individual", "account", "entries", "with", "the", "server", "s", "bundle", "information", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "UpdateAccountEntriesWithBundle", "(", "mctx", "libkb", ".", "MetaContext", ",", "reason", "string", ",", "bundle", "*", "stellar1", ".", "Bundle", ")", "(", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "reason", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "if", "bundle", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "active", ":=", "make", "(", "map", "[", "stellar1", ".", "AccountID", "]", "bool", ")", "\n", "for", "_", ",", "account", ":=", "range", "bundle", ".", "Accounts", "{", "a", ",", "_", ":=", "w", ".", "accountStateBuild", "(", "account", ".", "AccountID", ")", "\n", "a", ".", "updateEntry", "(", "account", ")", "\n", "active", "[", "account", ".", "AccountID", "]", "=", "true", "\n", "}", "\n\n", "// clean out any unusued accounts", "w", ".", "Lock", "(", ")", "\n", "for", "accountID", ":=", "range", "w", ".", "accounts", "{", "if", "active", "[", "accountID", "]", "{", "continue", "\n", "}", "\n", "delete", "(", "w", ".", "accounts", ",", "accountID", ")", "\n", "}", "\n", "w", ".", "Unlock", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "UpdateAccountEntriesWithBundle", "updates", "the", "individual", "account", "entries", "with", "the", "bundle", "information", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "RefreshAll", "(", "mctx", "libkb", ".", "MetaContext", ",", "reason", "string", ")", "error", "{", "_", ",", "err", ":=", "w", ".", "refreshGroup", ".", "Do", "(", "\"", "\"", ",", "func", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "doErr", ":=", "w", ".", "refreshAll", "(", "mctx", ",", "reason", ")", "\n", "return", "nil", ",", "doErr", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "RefreshAll", "refreshes", "all", "the", "accounts", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "Refresh", "(", "mctx", "libkb", ".", "MetaContext", ",", "accountID", "stellar1", ".", "AccountID", ",", "reason", "string", ")", "error", "{", "a", ",", "ok", ":=", "w", ".", "accountState", "(", "accountID", ")", "\n", "if", "!", "ok", "{", "return", "ErrAccountNotFound", "\n", "}", "\n", "return", "a", ".", "Refresh", "(", "mctx", ",", "w", ".", "G", "(", ")", ".", "NotifyRouter", ",", "reason", ")", "\n", "}" ]

[ "Refresh", "gets", "all", "the", "data", "from", "the", "server", "for", "an", "account", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "backgroundRefresh", "(", ")", "{", "w", ".", "backgroundDone", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "for", "accountID", ":=", "range", "w", ".", "refreshReqs", "{", "a", ",", "ok", ":=", "w", ".", "accountState", "(", "accountID", ")", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "a", ".", "RLock", "(", ")", "\n", "rt", ":=", "a", ".", "rtime", "\n", "a", ".", "RUnlock", "(", ")", "\n\n", "mctx", ":=", "libkb", ".", "NewMetaContextBackground", "(", "w", ".", "G", "(", ")", ")", ".", "WithLogTag", "(", "\"", "\"", ")", "\n", "if", "time", ".", "Since", "(", "rt", ")", "<", "120", "*", "time", ".", "Second", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "accountID", ")", "\n", "continue", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "Refresh", "(", "mctx", ",", "w", ".", "G", "(", ")", ".", "NotifyRouter", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "accountID", ",", "err", ")", "\n", "}", "\n", "}", "\n", "close", "(", "w", ".", "backgroundDone", ")", "\n", "}" ]

[ "backgroundRefresh", "gets", "any", "refresh", "requests", "and", "will", "refresh", "the", "account", "state", "if", "sufficient", "time", "has", "passed", "since", "the", "last", "refresh", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "AccountSeqno", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "uint64", ",", "error", ")", "{", "a", ",", "err", ":=", "w", ".", "accountStateRefresh", "(", "ctx", ",", "accountID", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "a", ".", "AccountSeqno", "(", "ctx", ")", "\n", "}" ]

[ "AccountSeqno", "is", "an", "override", "of", "remoter", "s", "AccountSeqno", "that", "uses", "the", "stored", "value", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "AccountSeqnoAndBump", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "uint64", ",", "error", ")", "{", "w", ".", "Lock", "(", ")", "\n", "hasSeqnoLock", ":=", "w", ".", "seqnoLockHeld", "\n", "w", ".", "Unlock", "(", ")", "\n", "if", "!", "hasSeqnoLock", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "a", ",", "err", ":=", "w", ".", "accountStateRefresh", "(", "ctx", ",", "accountID", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "a", ".", "AccountSeqnoAndBump", "(", "ctx", ")", "\n", "}" ]

[ "AccountSeqnoAndBump", "gets", "the", "current", "seqno", "for", "an", "account", "and", "increments", "the", "stored", "value", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "Balances", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "[", "]", "stellar1", ".", "Balance", ",", "error", ")", "{", "a", ",", "ok", ":=", "w", ".", "accountState", "(", "accountID", ")", "\n", "if", "!", "ok", "{", "// Balances is used frequently to get balances for other users,", "// so if accountID isn't in WalletState, just use the remote", "// to get the balances.", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "accountID", ")", "\n", "return", "w", ".", "Remoter", ".", "Balances", "(", "ctx", ",", "accountID", ")", "\n", "}", "\n\n", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "accountID", ")", "\n", "return", "a", ".", "Balances", "(", "ctx", ")", "\n", "}" ]

[ "Balances", "is", "an", "override", "of", "remoter", "s", "Balances", "that", "uses", "stored", "data", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "Details", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ")", "(", "stellar1", ".", "AccountDetails", ",", "error", ")", "{", "a", ",", "err", ":=", "w", ".", "accountStateRefresh", "(", "ctx", ",", "accountID", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stellar1", ".", "AccountDetails", "{", "}", ",", "err", "\n", "}", "\n", "details", ",", "err", ":=", "a", ".", "Details", "(", "ctx", ")", "\n", "if", "err", "==", "nil", "&&", "details", ".", "AccountID", "!=", "accountID", "{", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "details", ",", "accountID", ")", "\n", "}", "\n", "return", "details", ",", "err", "\n", "}" ]

[ "Details", "is", "an", "override", "of", "remoter", "s", "Details", "that", "uses", "stored", "data", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "PendingPayments", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ",", "limit", "int", ")", "(", "[", "]", "stellar1", ".", "PaymentSummary", ",", "error", ")", "{", "a", ",", "err", ":=", "w", ".", "accountStateRefresh", "(", "ctx", ",", "accountID", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "payments", ",", "err", ":=", "a", ".", "PendingPayments", "(", "ctx", ",", "limit", ")", "\n", "if", "err", "==", "nil", "{", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "accountID", ",", "len", "(", "payments", ")", ")", "\n", "}", "else", "{", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "accountID", ",", "err", ")", "\n\n", "}", "\n", "return", "payments", ",", "err", "\n", "}" ]

[ "PendingPayments", "is", "an", "override", "of", "remoter", "s", "PendingPayments", "that", "uses", "stored", "data", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "RecentPayments", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ",", "cursor", "*", "stellar1", ".", "PageCursor", ",", "limit", "int", ",", "skipPending", "bool", ")", "(", "stellar1", ".", "PaymentsPage", ",", "error", ")", "{", "useAccountState", ":=", "true", "\n", "if", "limit", "!=", "0", "&&", "limit", "!=", "50", "{", "useAccountState", "=", "false", "\n", "}", "else", "if", "cursor", "!=", "nil", "{", "useAccountState", "=", "false", "\n", "}", "else", "if", "!", "skipPending", "{", "useAccountState", "=", "false", "\n", "}", "\n\n", "if", "!", "useAccountState", "{", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "w", ".", "Remoter", ".", "RecentPayments", "(", "ctx", ",", "accountID", ",", "cursor", ",", "limit", ",", "skipPending", ")", "\n", "}", "\n\n", "a", ",", "err", ":=", "w", ".", "accountStateRefresh", "(", "ctx", ",", "accountID", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stellar1", ".", "PaymentsPage", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "a", ".", "RecentPayments", "(", "ctx", ")", "\n", "}" ]

[ "RecentPayments", "is", "an", "override", "of", "remoter", "s", "RecentPayments", "that", "uses", "stored", "data", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "AddPendingTx", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ",", "txID", "stellar1", ".", "TransactionID", ",", "seqno", "uint64", ")", "error", "{", "a", ",", "ok", ":=", "w", ".", "accountState", "(", "accountID", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "accountID", ")", "\n", "}", "\n\n", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "accountID", ",", "txID", ",", "seqno", ")", "\n\n", "return", "a", ".", "AddPendingTx", "(", "ctx", ",", "txID", ",", "seqno", ")", "\n", "}" ]

[ "AddPendingTx", "adds", "information", "about", "a", "tx", "that", "was", "submitted", "to", "the", "network", ".", "This", "allows", "WalletState", "to", "keep", "track", "of", "anything", "pending", "when", "managing", "the", "account", "seqno", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "SubmitPayment", "(", "ctx", "context", ".", "Context", ",", "post", "stellar1", ".", "PaymentDirectPost", ")", "(", "stellar1", ".", "PaymentResult", ",", "error", ")", "{", "w", ".", "Lock", "(", ")", "\n", "hasSeqnoLock", ":=", "w", ".", "seqnoLockHeld", "\n", "w", ".", "Unlock", "(", ")", "\n", "if", "!", "hasSeqnoLock", "{", "return", "stellar1", ".", "PaymentResult", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "w", ".", "Remoter", ".", "SubmitPayment", "(", "ctx", ",", "post", ")", "\n", "}" ]

[ "SubmitPayment", "is", "an", "override", "of", "remoter", "s", "SubmitPayment", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "SubmitRelayClaim", "(", "ctx", "context", ".", "Context", ",", "post", "stellar1", ".", "RelayClaimPost", ")", "(", "stellar1", ".", "RelayClaimResult", ",", "error", ")", "{", "w", ".", "Lock", "(", ")", "\n", "hasSeqnoLock", ":=", "w", ".", "seqnoLockHeld", "\n", "w", ".", "Unlock", "(", ")", "\n", "if", "!", "hasSeqnoLock", "{", "return", "stellar1", ".", "RelayClaimResult", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "result", ",", "err", ":=", "w", ".", "Remoter", ".", "SubmitRelayClaim", "(", "ctx", ",", "post", ")", "\n", "if", "err", "==", "nil", "{", "mctx", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "w", ".", "G", "(", ")", ")", "\n", "if", "rerr", ":=", "w", ".", "RefreshAll", "(", "mctx", ",", "\"", "\"", ")", ";", "rerr", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "rerr", ")", "\n", "}", "\n", "}", "\n", "return", "result", ",", "err", "\n\n", "}" ]

[ "SubmitRelayClaim", "is", "an", "override", "of", "remoter", "s", "SubmitRelayClaim", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "MarkAsRead", "(", "ctx", "context", ".", "Context", ",", "accountID", "stellar1", ".", "AccountID", ",", "mostRecentID", "stellar1", ".", "TransactionID", ")", "error", "{", "err", ":=", "w", ".", "Remoter", ".", "MarkAsRead", "(", "ctx", ",", "accountID", ",", "mostRecentID", ")", "\n", "if", "err", "==", "nil", "{", "mctx", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "w", ".", "G", "(", ")", ")", "\n", "if", "rerr", ":=", "w", ".", "RefreshAsync", "(", "mctx", ",", "accountID", ",", "\"", "\"", ")", ";", "rerr", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "MarkAsRead", "is", "an", "override", "of", "remoter", "s", "MarkAsRead", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "ExchangeRate", "(", "ctx", "context", ".", "Context", ",", "currency", "string", ")", "(", "stellar1", ".", "OutsideExchangeRate", ",", "error", ")", "{", "w", ".", "Lock", "(", ")", "\n", "existing", ",", "ok", ":=", "w", ".", "rates", "[", "currency", "]", "\n", "w", ".", "Unlock", "(", ")", "\n", "age", ":=", "time", ".", "Since", "(", "existing", ".", "ctime", ")", "\n", "if", "ok", "&&", "age", "<", "1", "*", "time", ".", "Minute", "{", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "currency", ",", "existing", ".", "rate", ",", "age", ")", "\n", "return", "existing", ".", "rate", ",", "nil", "\n", "}", "\n", "if", "ok", "{", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "currency", ",", "age", ")", "\n", "}", "\n", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "currency", ")", "\n\n", "rateRes", ",", "err", ":=", "w", ".", "rateGroup", ".", "Do", "(", "currency", ",", "func", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "w", ".", "Remoter", ".", "ExchangeRate", "(", "ctx", ",", "currency", ")", "\n", "}", ")", "\n", "rate", ",", "ok", ":=", "rateRes", ".", "(", "stellar1", ".", "OutsideExchangeRate", ")", "\n", "if", "!", "ok", "{", "return", "stellar1", ".", "OutsideExchangeRate", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", "==", "nil", "{", "w", ".", "Lock", "(", ")", "\n", "w", ".", "rates", "[", "currency", "]", "=", "rateEntry", "{", "currency", ":", "currency", ",", "rate", ":", "rate", ",", "ctime", ":", "time", ".", "Now", "(", ")", ",", "}", "\n", "w", ".", "Unlock", "(", ")", "\n", "w", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "currency", ",", "rate", ")", "\n", "}", "\n\n", "return", "rate", ",", "err", "\n", "}" ]

[ "ExchangeRate", "is", "an", "overrider", "of", "remoter", "s", "ExchangeRate", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "DumpToLog", "(", "mctx", "libkb", ".", "MetaContext", ")", "{", "mctx", ".", "Debug", "(", "w", ".", "String", "(", ")", ")", "\n", "}" ]

[ "DumpToLog", "outputs", "a", "summary", "of", "WalletState", "to", "the", "debug", "log", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "String", "(", ")", "string", "{", "w", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "Unlock", "(", ")", "\n", "var", "pieces", "[", "]", "string", "\n", "for", "_", ",", "acctState", ":=", "range", "w", ".", "accounts", "{", "pieces", "=", "append", "(", "pieces", ",", "acctState", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "w", ".", "accounts", ")", ",", "strings", ".", "Join", "(", "pieces", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "String", "returns", "a", "string", "representation", "of", "WalletState", "suitable", "for", "debug", "logging", "." ]

[ "func", "(", "w", "*", "WalletState", ")", "Reset", "(", "mctx", "libkb", ".", "MetaContext", ")", "{", "w", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "Unlock", "(", ")", "\n", "w", ".", "resetWithLock", "(", "mctx", ")", "\n", "}" ]

[ "Reset", "clears", "all", "the", "data", "in", "the", "WalletState", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "Refresh", "(", "mctx", "libkb", ".", "MetaContext", ",", "router", "*", "libkb", ".", "NotifyRouter", ",", "reason", "string", ")", "error", "{", "_", ",", "err", ":=", "a", ".", "refreshGroup", ".", "Do", "(", "\"", "\"", ",", "func", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "doErr", ":=", "a", ".", "refresh", "(", "mctx", ",", "router", ",", "reason", ")", "\n", "return", "nil", ",", "doErr", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "Refresh", "updates", "all", "the", "data", "for", "this", "account", "from", "the", "server", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "AccountSeqno", "(", "ctx", "context", ".", "Context", ")", "(", "uint64", ",", "error", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "return", "a", ".", "seqno", ",", "nil", "\n", "}" ]

[ "AccountSeqno", "returns", "the", "seqno", "that", "has", "already", "been", "fetched", "for", "this", "account", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "AccountSeqnoAndBump", "(", "ctx", "context", ".", "Context", ")", "(", "uint64", ",", "error", ")", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n", "result", ":=", "a", ".", "seqno", "\n\n", "// need to keep track that we are going to use this seqno", "// in a tx. This record keeping avoids a race where", "// multiple seqno providers rushing to use seqnos before", "// AddPendingTx is called.", "a", ".", "inuseSeqnos", "[", "result", "]", "=", "inuseSeqno", "{", "ctime", ":", "time", ".", "Now", "(", ")", "}", "\n\n", "a", ".", "seqno", "++", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "AccountSeqnoAndBump", "returns", "the", "seqno", "that", "has", "already", "been", "fetched", "for", "this", "account", ".", "It", "bumps", "the", "seqno", "up", "by", "one", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "AddPendingTx", "(", "ctx", "context", ".", "Context", ",", "txID", "stellar1", ".", "TransactionID", ",", "seqno", "uint64", ")", "error", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n\n", "// remove the inuse seqno since the pendingTx will track it now", "delete", "(", "a", ".", "inuseSeqnos", ",", "seqno", ")", "\n\n", "a", ".", "pendingTxs", "[", "txID", "]", "=", "txPending", "{", "seqno", ":", "seqno", ",", "ctime", ":", "time", ".", "Now", "(", ")", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "AddPendingTx", "adds", "information", "about", "a", "tx", "that", "was", "submitted", "to", "the", "network", ".", "This", "allows", "AccountState", "to", "keep", "track", "of", "anything", "pending", "when", "managing", "the", "account", "seqno", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "RemovePendingTx", "(", "ctx", "context", ".", "Context", ",", "txID", "stellar1", ".", "TransactionID", ")", "error", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n\n", "delete", "(", "a", ".", "pendingTxs", ",", "txID", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "RemovePendingTx", "removes", "a", "pending", "tx", "from", "WalletState", ".", "It", "doesn", "t", "matter", "if", "it", "succeeded", "or", "failed", "just", "that", "it", "is", "done", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "Balances", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "stellar1", ".", "Balance", ",", "error", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "a", ".", "enqueueRefreshReq", "(", ")", "\n", "return", "a", ".", "balances", ",", "nil", "\n", "}" ]

[ "Balances", "returns", "the", "balances", "that", "have", "already", "been", "fetched", "for", "this", "account", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "Details", "(", "ctx", "context", ".", "Context", ")", "(", "stellar1", ".", "AccountDetails", ",", "error", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "a", ".", "enqueueRefreshReq", "(", ")", "\n", "if", "a", ".", "details", "==", "nil", "{", "return", "stellar1", ".", "AccountDetails", "{", "AccountID", ":", "a", ".", "accountID", "}", ",", "nil", "\n", "}", "\n", "return", "*", "a", ".", "details", ",", "nil", "\n", "}" ]

[ "Details", "returns", "the", "account", "details", "that", "have", "already", "been", "fetched", "for", "this", "account", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "PendingPayments", "(", "ctx", "context", ".", "Context", ",", "limit", "int", ")", "(", "[", "]", "stellar1", ".", "PaymentSummary", ",", "error", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "a", ".", "enqueueRefreshReq", "(", ")", "\n", "if", "limit", ">", "0", "&&", "limit", "<", "len", "(", "a", ".", "pending", ")", "{", "return", "a", ".", "pending", "[", ":", "limit", "]", ",", "nil", "\n", "}", "\n", "return", "a", ".", "pending", ",", "nil", "\n", "}" ]

[ "PendingPayments", "returns", "the", "pending", "payments", "that", "have", "already", "been", "fetched", "for", "this", "account", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "RecentPayments", "(", "ctx", "context", ".", "Context", ")", "(", "stellar1", ".", "PaymentsPage", ",", "error", ")", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "a", ".", "enqueueRefreshReq", "(", ")", "\n", "if", "a", ".", "recent", "==", "nil", "{", "return", "stellar1", ".", "PaymentsPage", "{", "}", ",", "nil", "\n", "}", "\n", "return", "*", "a", ".", "recent", ",", "nil", "\n", "}" ]

[ "RecentPayments", "returns", "the", "recent", "payments", "that", "have", "already", "been", "fetched", "for", "this", "account", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "Reset", "(", "mctx", "libkb", ".", "MetaContext", ")", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n\n", "a", ".", "refreshReqs", "=", "nil", "\n", "a", ".", "done", "=", "true", "\n", "}" ]

[ "Reset", "sets", "the", "refreshReqs", "channel", "to", "nil", "so", "nothing", "will", "be", "put", "on", "it", "." ]

[ "func", "(", "a", "*", "AccountState", ")", "String", "(", ")", "string", "{", "a", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "RUnlock", "(", ")", "\n", "if", "a", ".", "recent", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "a", ".", "accountID", ",", "a", ".", "seqno", ",", "len", "(", "a", ".", "balances", ")", ",", "len", "(", "a", ".", "pending", ")", ",", "len", "(", "a", ".", "recent", ".", "Payments", ")", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "a", ".", "accountID", ",", "a", ".", "seqno", ",", "len", "(", "a", ".", "balances", ")", ",", "len", "(", "a", ".", "pending", ")", ")", "\n", "}" ]

[ "String", "returns", "a", "small", "string", "representation", "of", "AccountState", "suitable", "for", "debug", "logging", "." ]

[ "func", "(", "e", "*", "ephemeralGitConfigWithFixedPackWindow", ")", "PackfileWriter", "(", "ch", "plumbing", ".", "StatusChan", ")", "(", "io", ".", "WriteCloser", ",", "error", ")", "{", "return", "e", ".", "pfWriter", ".", "PackfileWriter", "(", "ch", ")", "\n", "}" ]

[ "PackfileWriter", "implements", "the", "storer", ".", "PackfileWriter", "interface", "." ]

[ "func", "(", "e", "*", "ephemeralGitConfigWithFixedPackWindow", ")", "Config", "(", ")", "(", "*", "gogitcfg", ".", "Config", ",", "error", ")", "{", "cfg", ",", "err", ":=", "e", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cfg", ".", "Pack", ".", "Window", "=", "e", ".", "packWindow", "\n", "return", "cfg", ",", "nil", "\n", "}" ]

[ "Config", "implements", "the", "storer", ".", "Storer", "interface", "." ]

[ "func", "(", "e", "*", "ephemeralGitConfigWithFixedPackWindow", ")", "ForEachObjectHash", "(", "f", "func", "(", "plumbing", ".", "Hash", ")", "error", ")", "error", "{", "return", "e", ".", "los", ".", "ForEachObjectHash", "(", "f", ")", "\n", "}" ]

[ "ForEachObjectHash", "implements", "the", "storer", ".", "LooseObjectStorer", "interface", "." ]

[ "func", "(", "e", "*", "ephemeralGitConfigWithFixedPackWindow", ")", "LooseObjectTime", "(", "h", "plumbing", ".", "Hash", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "return", "e", ".", "los", ".", "LooseObjectTime", "(", "h", ")", "\n", "}" ]

[ "LooseObjectHash", "implements", "the", "storer", ".", "LooseObjectStorer", "interface", "." ]

[ "func", "(", "e", "*", "ephemeralGitConfigWithFixedPackWindow", ")", "DeleteLooseObject", "(", "h", "plumbing", ".", "Hash", ")", "error", "{", "return", "e", ".", "los", ".", "DeleteLooseObject", "(", "h", ")", "\n", "}" ]

[ "DeleteLooseObject", "implements", "the", "storer", ".", "LooseObjectStorer", "interface", "." ]

[ "func", "(", "e", "*", "ephemeralGitConfigWithFixedPackWindow", ")", "DeleteOldObjectPackAndIndex", "(", "h", "plumbing", ".", "Hash", ",", "t", "time", ".", "Time", ")", "error", "{", "return", "e", ".", "pos", ".", "DeleteOldObjectPackAndIndex", "(", "h", ",", "t", ")", "\n", "}" ]

[ "DeleteOldObjectPackAndIndex", "implements", "the", "storer", ".", "PackedObjectStorer", "interface", "." ]

[ "func", "NewFolderFromProtocol", "(", "folder", "keybase1", ".", "Folder", ")", "*", "Folder", "{", "name", ":=", "folder", ".", "Name", "\n", "if", "!", "folder", ".", "Private", "{", "// Old versions of the client still use an outdated \"#public\"", "// suffix for favorited public folders. TODO: remove this once", "// those old versions of the client are retired.", "const", "oldPublicSuffix", "=", "tlf", ".", "ReaderSep", "+", "\"", "\"", "\n", "name", "=", "strings", ".", "TrimSuffix", "(", "folder", ".", "Name", ",", "oldPublicSuffix", ")", "\n", "}", "\n\n", "var", "t", "tlf", ".", "Type", "\n", "if", "folder", ".", "FolderType", "==", "keybase1", ".", "FolderType_UNKNOWN", "{", "// Use deprecated boolean", "if", "folder", ".", "Private", "{", "t", "=", "tlf", ".", "Private", "\n", "}", "else", "{", "t", "=", "tlf", ".", "Public", "\n", "}", "\n", "}", "else", "{", "switch", "folder", ".", "FolderType", "{", "case", "keybase1", ".", "FolderType_PRIVATE", ":", "t", "=", "tlf", ".", "Private", "\n", "case", "keybase1", ".", "FolderType_PUBLIC", ":", "t", "=", "tlf", ".", "Public", "\n", "case", "keybase1", ".", "FolderType_TEAM", ":", "// TODO: if we ever support something other than single", "// teams in the favorites list, we'll have to figure out", "// which type the favorite is from its name.", "t", "=", "tlf", ".", "SingleTeam", "\n", "default", ":", "// This shouldn't happen, but just in case the service", "// sends us bad info....", "t", "=", "tlf", ".", "Private", "\n", "}", "\n", "}", "\n\n", "return", "&", "Folder", "{", "Name", ":", "name", ",", "Type", ":", "t", ",", "}", "\n", "}" ]

[ "NewFolderFromProtocol", "creates", "a", "Folder", "from", "a", "keybase1", ".", "Folder", "." ]

[ "func", "(", "f", "Folder", ")", "ToKBFolder", "(", "created", "bool", ")", "keybase1", ".", "Folder", "{", "return", "keybase1", ".", "Folder", "{", "Name", ":", "f", ".", "Name", ",", "FolderType", ":", "f", ".", "Type", ".", "FolderType", "(", ")", ",", "Private", ":", "f", ".", "Type", "!=", "tlf", ".", "Public", ",", "// deprecated", "Created", ":", "created", ",", "}", "\n", "}" ]

[ "ToKBFolder", "creates", "a", "keybase1", ".", "Folder", "from", "a", "Folder", "." ]

[ "func", "DataFrom", "(", "folder", "keybase1", ".", "Folder", ")", "Data", "{", "return", "Data", "{", "Name", ":", "folder", ".", "Name", ",", "FolderType", ":", "folder", ".", "FolderType", ",", "Private", ":", "folder", ".", "Private", ",", "TeamID", ":", "folder", ".", "TeamID", ",", "}", "\n", "}" ]

[ "DataFrom", "returns", "auxiliary", "data", "from", "a", "folder", "sent", "via", "the", "keybase1", "protocol", "." ]

[ "func", "(", "ta", "ToAdd", ")", "ToKBFolder", "(", ")", "keybase1", ".", "Folder", "{", "return", "ta", ".", "Folder", ".", "ToKBFolder", "(", "ta", ".", "Created", ")", "\n", "}" ]

[ "ToKBFolder", "converts", "this", "data", "into", "an", "object", "suitable", "for", "the", "keybase1", "protocol", "." ]

[ "func", "putBlockToServer", "(", "ctx", "context", ".", "Context", ",", "bserv", "BlockServer", ",", "tlfID", "tlf", ".", "ID", ",", "blockPtr", "data", ".", "BlockPointer", ",", "readyBlockData", "data", ".", "ReadyBlockData", ",", "cacheType", "DiskBlockCacheType", ")", "error", "{", "var", "err", "error", "\n", "if", "blockPtr", ".", "RefNonce", "==", "kbfsblock", ".", "ZeroRefNonce", "{", "err", "=", "bserv", ".", "Put", "(", "ctx", ",", "tlfID", ",", "blockPtr", ".", "ID", ",", "blockPtr", ".", "Context", ",", "readyBlockData", ".", "Buf", ",", "readyBlockData", ".", "ServerHalf", ",", "cacheType", ")", "\n", "}", "else", "{", "// non-zero block refnonce means this is a new reference to an", "// existing block.", "err", "=", "bserv", ".", "AddBlockReference", "(", "ctx", ",", "tlfID", ",", "blockPtr", ".", "ID", ",", "blockPtr", ".", "Context", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "putBlockToServer", "either", "puts", "the", "full", "block", "to", "the", "block", "server", "or", "just", "adds", "a", "reference", "depending", "on", "the", "refnonce", "in", "blockPtr", "." ]

[ "func", "(", "s", "*", "Symlink", ")", "GetFileInformation", "(", "ctx", "context", ".", "Context", ",", "fi", "*", "dokan", ".", "FileInfo", ")", "(", "a", "*", "dokan", ".", "Stat", ",", "err", "error", ")", "{", "s", ".", "parent", ".", "folder", ".", "fs", ".", "logEnter", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "s", ".", "parent", ".", "folder", ".", "reportErr", "(", "ctx", ",", "libkbfs", ".", "ReadMode", ",", "err", ")", "}", "(", ")", "\n\n", "_", ",", "_", ",", "err", "=", "s", ".", "parent", ".", "folder", ".", "fs", ".", "config", ".", "KBFSOps", "(", ")", ".", "Lookup", "(", "ctx", ",", "s", ".", "parent", ".", "node", ",", "s", ".", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errToDokan", "(", "err", ")", "\n", "}", "\n\n", "if", "s", ".", "isTargetADirectory", "{", "return", "defaultSymlinkDirInformation", "(", ")", "\n", "}", "\n", "return", "defaultSymlinkFileInformation", "(", ")", "\n", "}" ]

[ "GetFileInformation", "does", "stat", "for", "dokan", "." ]

[ "func", "(", "c", "ConfigClient", ")", "CheckAPIServerOutOfDateWarning", "(", "ctx", "context", ".", "Context", ")", "(", "res", "OutOfDateInfo", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "CheckAPIServerOutOfDateWarningArg", "{", "}", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Check", "whether", "the", "API", "server", "has", "told", "us", "we", "re", "out", "of", "date", "." ]

[ "func", "(", "c", "ConfigClient", ")", "WaitForClient", "(", "ctx", "context", ".", "Context", ",", "__arg", "WaitForClientArg", ")", "(", "res", "bool", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Wait", "for", "client", "type", "to", "connect", "to", "service", "." ]

[ "func", "(", "c", "ConfigClient", ")", "GetUpdateInfo2", "(", "ctx", "context", ".", "Context", ",", "__arg", "GetUpdateInfo2Arg", ")", "(", "res", "UpdateInfo2", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "getUpdateInfo2", "is", "to", "drive", "the", "redbar", "on", "mobile", "and", "desktop", "apps", ".", "The", "redbar", "tells", "you", "if", "you", "are", "critically", "out", "of", "date", "." ]

[ "func", "allActiveDeviceEKMetadata", "(", "mctx", "libkb", ".", "MetaContext", ",", "merkleRoot", "libkb", ".", "MerkleRoot", ")", "(", "metadata", "map", "[", "keybase1", ".", "DeviceID", "]", "keybase1", ".", "DeviceEkMetadata", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "maybeStale", ",", "err", ":=", "allDeviceEKMetadataMaybeStale", "(", "mctx", ",", "merkleRoot", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "active", ":=", "map", "[", "keybase1", ".", "DeviceID", "]", "keybase1", ".", "DeviceEkMetadata", "{", "}", "\n", "for", "deviceID", ",", "metadata", ":=", "range", "maybeStale", "{", "// Check whether the key is stale. This isn't considered an error,", "// since the server doesn't do this check for us. We log these cases", "// and skip them.", "if", "ctimeIsStale", "(", "metadata", ".", "Ctime", ".", "Time", "(", ")", ",", "merkleRoot", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "metadata", ".", "Kid", ",", "deviceID", ")", "\n", "continue", "\n", "}", "\n", "active", "[", "deviceID", "]", "=", "metadata", "\n", "}", "\n\n", "return", "active", ",", "nil", "\n", "}" ]

[ "allActiveDeviceEKMetadata", "fetches", "the", "latest", "deviceEK", "for", "each", "of", "your", "devices", "filtering", "out", "the", "ones", "that", "are", "stale", "." ]

[ "func", "castNoSuchNameError", "(", "err", "error", ",", "repoName", "string", ")", "error", "{", "switch", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "idutil", ".", "NoSuchNameError", ":", "return", "libkb", ".", "RepoDoesntExistError", "{", "Name", ":", "repoName", ",", "}", "\n", "default", ":", "return", "err", "\n", "}", "\n", "}" ]

[ "For", "the", "common", "repo", "doesn", "t", "exist", "case", "use", "the", "error", "type", "that", "the", "client", "can", "recognize", "." ]

[ "func", "CleanOldDeletedRepos", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "tlfHandle", "*", "tlfhandle", ".", "Handle", ")", "(", "err", "error", ")", "{", "fs", ",", "err", ":=", "libfs", ".", "NewFS", "(", "ctx", ",", "config", ",", "tlfHandle", ",", "data", ".", "MasterBranch", ",", "path", ".", "Join", "(", "kbfsRepoDir", ",", "kbfsDeletedReposDir", ")", ",", "\"", "\"", "/* uniq ID isn't used for removals */", ",", "keybase1", ".", "MDPriorityGit", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "idutil", ".", "NoSuchNameError", ":", "// Nothing to clean.", "return", "nil", "\n", "case", "nil", ":", "default", ":", "return", "err", "\n", "}", "\n\n", "deletedRepos", ",", "err", ":=", "fs", ".", "ReadDir", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "len", "(", "deletedRepos", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "now", ":=", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", "\n\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "deletedRepos", ")", ",", "tlfHandle", ".", "GetCanonicalPath", "(", ")", ")", "\n", "defer", "func", "(", ")", "{", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n", "for", "_", ",", "fi", ":=", "range", "deletedRepos", "{", "parts", ":=", "strings", ".", "Split", "(", "fi", ".", "Name", "(", ")", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "<", "2", "{", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "fi", ".", "Name", "(", ")", ")", "\n", "continue", "\n", "}", "\n\n", "deletedTimeUnixNano", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "parts", "[", "len", "(", "parts", ")", "-", "1", "]", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "fi", ".", "Name", "(", ")", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "deletedTime", ":=", "time", ".", "Unix", "(", "0", ",", "deletedTimeUnixNano", ")", "\n", "if", "deletedTime", ".", "Add", "(", "minDeletedAgeForCleaning", ")", ".", "After", "(", "now", ")", "{", "// Repo was deleted too recently.", "continue", "\n", "}", "\n\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "fi", ".", "Name", "(", ")", ")", "\n", "err", "=", "libfs", ".", "RecursiveDelete", "(", "ctx", ",", "fs", ",", "fi", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CleanOldDeletedRepos", "completely", "removes", "any", "deleted", "repos", "that", "have", "been", "deleted", "for", "longer", "than", "minDeletedAgeForCleaning", ".", "The", "caller", "is", "responsible", "for", "syncing", "any", "data", "to", "disk", "if", "desired", "." ]

[ "func", "UpdateRepoMD", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "tlfHandle", "*", "tlfhandle", ".", "Handle", ",", "fs", "billy", ".", "Filesystem", ",", "pushType", "keybase1", ".", "GitPushType", ",", "oldRepoName", "string", ",", "refDataByName", "RefDataByName", ")", "error", "{", "folder", ":=", "tlfHandle", ".", "ToFavorite", "(", ")", ".", "ToKBFolder", "(", "false", ")", "\n\n", "// Get the user-formatted repo name.", "f", ",", "err", ":=", "fs", ".", "Open", "(", "kbfsConfigName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "buf", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ",", "err", ":=", "configFromBytes", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "gitRefMetadata", ":=", "make", "(", "[", "]", "keybase1", ".", "GitRefMetadata", ",", "0", ",", "len", "(", "refDataByName", ")", ")", "\n", "for", "refName", ",", "refData", ":=", "range", "refDataByName", "{", "hasMoreCommits", ":=", "false", "\n", "kbCommits", ":=", "make", "(", "[", "]", "keybase1", ".", "GitCommit", ",", "0", ",", "len", "(", "refData", ".", "Commits", ")", ")", "\n", "for", "_", ",", "c", ":=", "range", "refData", ".", "Commits", "{", "if", "c", "==", "CommitSentinelValue", "{", "// Accept a sentinel value at the end of the commit list that", "// indicates that there would have been more commits, but we", "// stopped due to a cap.", "hasMoreCommits", "=", "true", "\n", "break", "\n", "}", "\n", "kbCommits", "=", "append", "(", "kbCommits", ",", "keybase1", ".", "GitCommit", "{", "CommitHash", ":", "hex", ".", "EncodeToString", "(", "c", ".", "Hash", "[", ":", "]", ")", ",", "Message", ":", "c", ".", "Message", ",", "AuthorName", ":", "c", ".", "Author", ".", "Name", ",", "AuthorEmail", ":", "c", ".", "Author", ".", "Email", ",", "Ctime", ":", "keybase1", ".", "Time", "(", "c", ".", "Author", ".", "When", ".", "Unix", "(", ")", ")", ",", "}", ")", "\n", "}", "\n", "gitRefMetadata", "=", "append", "(", "gitRefMetadata", ",", "keybase1", ".", "GitRefMetadata", "{", "RefName", ":", "string", "(", "refName", ")", ",", "Commits", ":", "kbCommits", ",", "MoreCommitsAvailable", ":", "hasMoreCommits", ",", "IsDelete", ":", "refData", ".", "IsDelete", ",", "}", ")", "\n", "}", "\n", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "err", "=", "config", ".", "KBPKI", "(", ")", ".", "PutGitMetadata", "(", "ctx", ",", "folder", ",", "keybase1", ".", "RepoID", "(", "c", ".", "ID", ".", "String", "(", ")", ")", ",", "keybase1", ".", "GitLocalMetadata", "{", "RepoName", ":", "keybase1", ".", "GitRepoName", "(", "c", ".", "Name", ")", ",", "Refs", ":", "gitRefMetadata", ",", "PushType", ":", "pushType", ",", "PreviousRepoName", ":", "keybase1", ".", "GitRepoName", "(", "oldRepoName", ")", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "// Just log the put error, it shouldn't block the success of", "// the overall git operation.", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "UpdateRepoMD", "lets", "the", "Keybase", "service", "know", "that", "a", "repo", "s", "MD", "has", "been", "updated", "." ]

[ "func", "GetOrCreateRepoAndID", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "tlfHandle", "*", "tlfhandle", ".", "Handle", ",", "repoName", "string", ",", "uniqID", "string", ")", "(", "*", "libfs", ".", "FS", ",", "ID", ",", "error", ")", "{", "return", "getOrCreateRepoAndID", "(", "ctx", ",", "config", ",", "tlfHandle", ",", "repoName", ",", "uniqID", ",", "getOrCreate", ")", "\n", "}" ]

[ "GetOrCreateRepoAndID", "returns", "a", "filesystem", "object", "rooted", "at", "the", "specified", "repo", "along", "with", "the", "stable", "repo", "ID", ".", "If", "the", "repo", "hasn", "t", "been", "created", "yet", "it", "generates", "a", "new", "ID", "and", "creates", "the", "repo", ".", "The", "caller", "is", "responsible", "for", "syncing", "the", "FS", "and", "flushing", "the", "journal", "if", "desired", "." ]

[ "func", "CreateRepoAndID", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "tlfHandle", "*", "tlfhandle", ".", "Handle", ",", "repoName", "string", ")", "(", "ID", ",", "error", ")", "{", "uniqID", ",", "err", ":=", "makeUniqueID", "(", "ctx", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NullID", ",", "err", "\n", "}", "\n\n", "fs", ",", "id", ",", "err", ":=", "getOrCreateRepoAndID", "(", "ctx", ",", "config", ",", "tlfHandle", ",", "repoName", ",", "uniqID", ",", "createOnly", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NullID", ",", "err", "\n", "}", "\n", "err", "=", "fs", ".", "SyncAll", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NullID", ",", "err", "\n", "}", "\n", "return", "id", ",", "err", "\n", "}" ]

[ "CreateRepoAndID", "returns", "a", "new", "stable", "repo", "ID", "for", "the", "provided", "repoName", "in", "the", "given", "TLF", ".", "If", "the", "repo", "has", "already", "been", "created", "it", "returns", "a", "RepoAlreadyExistsError", ".", "If", "repoName", "already", "exists", "but", "is", "a", "symlink", "to", "another", "renamed", "directory", "the", "symlink", "will", "be", "removed", "in", "favor", "of", "the", "new", "repo", ".", "The", "caller", "is", "responsible", "for", "syncing", "the", "FS", "and", "flushing", "the", "journal", "if", "desired", ".", "It", "expects", "the", "config", "object", "to", "be", "unique", "during", "the", "lifetime", "of", "this", "call", "." ]

[ "func", "DeleteRepo", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "tlfHandle", "*", "tlfhandle", ".", "Handle", ",", "repoName", "string", ")", "error", "{", "// Create a unique ID using the verifying key and the `config`", "// object, which should be unique to each call in practice.", "session", ",", "err", ":=", "config", ".", "KBPKI", "(", ")", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "kbfsOps", ":=", "config", ".", "KBFSOps", "(", ")", "\n", "rootNode", ",", "_", ",", "err", ":=", "kbfsOps", ".", "GetOrCreateRootNode", "(", "ctx", ",", "tlfHandle", ",", "data", ".", "MasterBranch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "normalizedRepoName", ":=", "normalizeRepoName", "(", "repoName", ")", "\n\n", "repoNode", ",", "_", ",", "err", ":=", "kbfsOps", ".", "Lookup", "(", "ctx", ",", "rootNode", ",", "kbfsRepoDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "castNoSuchNameError", "(", "err", ",", "repoName", ")", "\n", "}", "\n\n", "_", ",", "_", ",", "err", "=", "kbfsOps", ".", "Lookup", "(", "ctx", ",", "repoNode", ",", "normalizedRepoName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "castNoSuchNameError", "(", "err", ",", "repoName", ")", "\n", "}", "\n\n", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "libkbfs", ".", "CtxAllowNameKey", ",", "kbfsDeletedReposDir", ")", "\n", "deletedReposNode", ",", "err", ":=", "lookupOrCreateDir", "(", "ctx", ",", "config", ",", "repoNode", ",", "kbfsDeletedReposDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// For now, just rename the repo out of the way, using the device", "// ID and the current time in nanoseconds to make uniqueness", "// probable.", "dirSuffix", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "session", ".", "VerifyingKey", ".", "String", "(", ")", ",", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", "\n", "return", "kbfsOps", ".", "Rename", "(", "ctx", ",", "repoNode", ",", "normalizedRepoName", ",", "deletedReposNode", ",", "normalizedRepoName", "+", "dirSuffix", ")", "\n", "}" ]

[ "DeleteRepo", "deletes", "the", "given", "repo", "in", "the", "given", "TLF", ".", "Right", "now", "it", "simply", "moves", "the", "repo", "out", "of", "the", "way", "to", "a", "special", "directory", "to", "allow", "any", "concurrent", "writers", "to", "finish", "their", "pushes", "without", "triggering", "conflict", "resolution", ".", "The", "caller", "is", "responsible", "for", "syncing", "the", "FS", "and", "flushing", "the", "journal", "if", "desired", ".", "It", "expects", "the", "config", "object", "to", "be", "unique", "during", "the", "lifetime", "of", "this", "call", "." ]

[ "func", "NeedsGC", "(", "storage", "storage", ".", "Storer", ",", "options", "GCOptions", ")", "(", "doPackRefs", "bool", ",", "numLooseRefs", "int", ",", "doPruneLoose", ",", "doObjectRepack", "bool", ",", "numObjectPacks", "int", ",", "err", "error", ")", "{", "numLooseRefs", ",", "err", "=", "storage", ".", "CountLooseRefs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "0", ",", "false", ",", "false", ",", "0", ",", "err", "\n", "}", "\n\n", "doPackRefs", "=", "numLooseRefs", ">", "options", ".", "MaxLooseRefs", "\n\n", "if", "options", ".", "PruneMinLooseObjects", ">=", "0", "{", "los", ",", "ok", ":=", "storage", ".", "(", "storer", ".", "LooseObjectStorer", ")", "\n", "if", "!", "ok", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Count the number of loose objects that are older than the", "// expire time, to see if pruning is needed.", "numLooseMaybePrune", ":=", "0", "\n", "err", "=", "los", ".", "ForEachObjectHash", "(", "func", "(", "h", "plumbing", ".", "Hash", ")", "error", "{", "t", ",", "err", ":=", "los", ".", "LooseObjectTime", "(", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "t", ".", "Before", "(", "options", ".", "PruneExpireTime", ")", "{", "numLooseMaybePrune", "++", "\n", "if", "numLooseMaybePrune", ">=", "options", ".", "PruneMinLooseObjects", "{", "doPruneLoose", "=", "true", "\n", "return", "storer", ".", "ErrStop", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "0", ",", "false", ",", "false", ",", "0", ",", "err", "\n", "}", "\n", "}", "\n\n", "pos", ",", "ok", ":=", "storage", ".", "(", "storer", ".", "PackedObjectStorer", ")", "\n", "if", "!", "ok", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "packs", ",", "err", ":=", "pos", ".", "ObjectPacks", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "0", ",", "false", ",", "false", ",", "0", ",", "err", "\n", "}", "\n", "numObjectPacks", "=", "len", "(", "packs", ")", "\n", "doObjectRepack", "=", "options", ".", "MaxObjectPacks", ">=", "0", "&&", "numObjectPacks", ">", "options", ".", "MaxObjectPacks", "\n\n", "return", "doPackRefs", ",", "numLooseRefs", ",", "doPruneLoose", ",", "doObjectRepack", ",", "numObjectPacks", ",", "nil", "\n", "}" ]

[ "NeedsGC", "checks", "the", "given", "repo", "storage", "layer", "against", "the", "given", "options", "to", "see", "what", "kinds", "of", "GC", "are", "needed", "on", "the", "repo", "." ]

[ "func", "LastGCTime", "(", "ctx", "context", ".", "Context", ",", "fs", "billy", ".", "Filesystem", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "fi", ",", "err", ":=", "fs", ".", "Stat", "(", "repoGCLockFileName", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "fi", ".", "ModTime", "(", ")", ",", "nil", "\n", "}" ]

[ "LastGCTime", "returns", "the", "last", "time", "the", "repo", "was", "successfully", "garbage", "-", "collected", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "shutdownLoop", "(", ")", "{", "top", ":", "for", "{", "select", "{", "case", "chInterface", ":=", "<-", "p", ".", "inFlightFetches", ".", "Out", "(", ")", ":", "ch", ":=", "chInterface", ".", "(", "<-", "chan", "error", ")", "\n", "<-", "ch", "\n", "case", "<-", "p", ".", "shutdownCh", ":", "break", "top", "\n", "}", "\n", "}", "\n", "for", "p", ".", "inFlightFetches", ".", "Len", "(", ")", ">", "0", "{", "chInterface", ":=", "<-", "p", ".", "inFlightFetches", ".", "Out", "(", ")", "\n", "ch", ":=", "chInterface", ".", "(", "<-", "chan", "error", ")", "\n", "<-", "ch", "\n", "}", "\n", "p", ".", "almostDoneCh", "<-", "struct", "{", "}", "{", "}", "\n", "}" ]

[ "shutdownLoop", "tracks", "in", "-", "flight", "requests" ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "calculatePriority", "(", "basePriority", "int", ",", "action", "BlockRequestAction", ")", "int", "{", "// A prefetched, non-deep-synced child always gets throttled for", "// now, until we fix the database performance issues.", "if", "basePriority", ">", "throttleRequestPriority", "&&", "!", "action", ".", "DeepSync", "(", ")", "{", "basePriority", "=", "throttleRequestPriority", "\n", "}", "\n", "return", "basePriority", "-", "1", "\n", "}" ]

[ "calculatePriority", "returns", "either", "a", "base", "priority", "for", "an", "unsynced", "TLF", "or", "a", "high", "priority", "for", "a", "synced", "TLF", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "request", "(", "ctx", "context", ".", "Context", ",", "priority", "int", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "info", "data", ".", "BlockInfo", ",", "block", "data", ".", "Block", ",", "lifetime", "data", ".", "BlockCacheLifetime", ",", "parentPtr", "data", ".", "BlockPointer", ",", "isParentNew", "bool", ",", "action", "BlockRequestAction", ",", "idsSeen", "map", "[", "kbfsblock", ".", "ID", "]", "bool", ")", "(", "numBlocks", "int", ",", "numBytesFetched", ",", "numBytesTotal", "uint64", ")", "{", "ptr", ":=", "info", ".", "BlockPointer", "\n", "if", "idsSeen", "[", "ptr", ".", "ID", "]", "{", "return", "0", ",", "0", ",", "0", "\n", "}", "\n", "idsSeen", "[", "ptr", ".", "ID", "]", "=", "true", "\n\n", "// If the prefetch is already waiting, don't make it wait again.", "// Add the parent, however.", "pre", ",", "isPrefetchWaiting", ":=", "p", ".", "prefetches", "[", "ptr", ".", "ID", "]", "\n", "if", "!", "isPrefetchWaiting", "{", "// If the block isn't in the tree, we add it with a block count of 1 (a", "// later TriggerPrefetch will come in and decrement it).", "obseleted", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "req", ":=", "&", "prefetchRequest", "{", "ptr", ",", "info", ".", "EncodedSize", ",", "block", ".", "NewEmptier", "(", ")", ",", "kmd", ",", "priority", ",", "lifetime", ",", "NoPrefetch", ",", "action", ",", "nil", ",", "obseleted", ",", "false", "}", "\n", "pre", "=", "p", ".", "newPrefetch", "(", "1", ",", "uint64", "(", "info", ".", "EncodedSize", ")", ",", "false", ",", "req", ")", "\n", "p", ".", "prefetches", "[", "ptr", ".", "ID", "]", "=", "pre", "\n", "}", "\n", "// If this is a new prefetch, or if we need to update the action,", "// send a new request.", "newAction", ":=", "action", ".", "Combine", "(", "pre", ".", "req", ".", "action", ")", "\n", "if", "!", "isPrefetchWaiting", "||", "pre", ".", "req", ".", "action", "!=", "newAction", "{", "// Update the action to prevent any early cancellation of a", "// previous, non-deeply-synced request, and trigger a new", "// request in case the previous request has already been", "// handled.", "oldAction", ":=", "pre", ".", "req", ".", "action", "\n", "pre", ".", "req", ".", "action", "=", "newAction", "\n", "if", "!", "oldAction", ".", "Sync", "(", ")", "&&", "newAction", ".", "Sync", "(", ")", "{", "p", ".", "incOverallSyncTotalBytes", "(", "pre", ".", "req", ")", "\n", "}", "\n\n", "ch", ":=", "p", ".", "retriever", ".", "Request", "(", "pre", ".", "ctx", ",", "priority", ",", "kmd", ",", "ptr", ",", "block", ".", "NewEmpty", "(", ")", ",", "lifetime", ",", "action", ".", "DelayedCacheCheckAction", "(", ")", ")", "\n", "p", ".", "inFlightFetches", ".", "In", "(", ")", "<-", "ch", "\n", "}", "\n", "parentPre", ",", "isParentWaiting", ":=", "p", ".", "prefetches", "[", "parentPtr", ".", "ID", "]", "\n", "if", "!", "isParentWaiting", "{", "p", ".", "vlog", ".", "CLogf", "(", "pre", ".", "ctx", ",", "libkb", ".", "VLog2", ",", "\"", "\"", "+", "\"", "\"", ",", "parentPtr", ",", "ptr", ".", "ID", ")", "\n", "panic", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n", "if", "pre", ".", "parents", "[", "ptr", ".", "RefNonce", "]", "[", "parentPtr", "]", "==", "nil", "||", "isParentNew", "{", "// The new parent needs its subtree block count increased. This can", "// happen either when:", "// 1. The child doesn't know about the parent when the child is first", "// created above, or the child was previously in the tree but the", "// parent was not (e.g. when there's an updated parent due to a change", "// in a sibling of this child).", "// 2. The parent is newly created but the child _did_ know about it,", "// like when the parent previously had a prefetch but was canceled.", "if", "len", "(", "pre", ".", "parents", "[", "ptr", ".", "RefNonce", "]", ")", "==", "0", "{", "pre", ".", "parents", "[", "ptr", ".", "RefNonce", "]", "=", "make", "(", "map", "[", "data", ".", "BlockPointer", "]", "<-", "chan", "struct", "{", "}", ")", "\n", "}", "\n", "pre", ".", "parents", "[", "ptr", ".", "RefNonce", "]", "[", "parentPtr", "]", "=", "parentPre", ".", "waitCh", "\n", "if", "pre", ".", "subtreeBlockCount", ">", "0", "{", "p", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog2", ",", "\"", "\"", ",", "ptr", ",", "action", ",", "pre", ".", "subtreeBlockCount", ",", "isParentNew", ")", "\n", "}", "\n", "return", "pre", ".", "subtreeBlockCount", ",", "pre", ".", "SubtreeBytesFetched", ",", "pre", ".", "SubtreeBytesTotal", "\n", "}", "\n", "return", "0", ",", "0", ",", "0", "\n", "}" ]

[ "request", "maps", "the", "parent", "-", ">", "child", "block", "relationship", "in", "the", "prefetcher", "and", "it", "triggers", "child", "prefetches", "that", "aren", "t", "already", "in", "progress", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "handleCriticalRequests", "(", ")", "{", "for", "{", "// Fulfill any status requests since the user could be waiting", "// for them.", "select", "{", "case", "req", ":=", "<-", "p", ".", "prefetchStatusCh", ".", "Out", "(", ")", ":", "p", ".", "handleStatusRequest", "(", "req", ".", "(", "*", "prefetchStatusRequest", ")", ")", "\n", "default", ":", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "handleCriticalRequests", "should", "be", "called", "periodically", "during", "any", "long", "prefetch", "requests", "to", "make", "sure", "we", "handle", "critical", "requests", "quickly", ".", "These", "are", "requests", "that", "are", "required", "to", "be", "run", "in", "the", "main", "processing", "goroutine", "but", "won", "t", "interfere", "with", "whatever", "request", "we", "re", "in", "the", "middle", "of", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "ProcessBlockForPrefetch", "(", "ctx", "context", ".", "Context", ",", "ptr", "data", ".", "BlockPointer", ",", "block", "data", ".", "Block", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "priority", "int", ",", "lifetime", "data", ".", "BlockCacheLifetime", ",", "prefetchStatus", "PrefetchStatus", ",", "action", "BlockRequestAction", ")", "{", "req", ":=", "&", "prefetchRequest", "{", "ptr", ",", "block", ".", "GetEncodedSize", "(", ")", ",", "block", ".", "NewEmptier", "(", ")", ",", "kmd", ",", "priority", ",", "lifetime", ",", "prefetchStatus", ",", "action", ",", "nil", ",", "nil", ",", "false", "}", "\n", "if", "prefetchStatus", "==", "FinishedPrefetch", "{", "// Finished prefetches can always be short circuited.", "// If we're here, then FinishedPrefetch is already cached.", "}", "else", "if", "!", "action", ".", "Prefetch", "(", "block", ")", "{", "// Only high priority requests can trigger prefetches. Leave the", "// prefetchStatus unchanged, but cache anyway.", "p", ".", "retriever", ".", "PutInCaches", "(", "ctx", ",", "ptr", ",", "kmd", ".", "TlfID", "(", ")", ",", "block", ",", "lifetime", ",", "prefetchStatus", ",", "action", ".", "CacheType", "(", ")", ")", "\n", "}", "else", "{", "// Note that here we are caching `TriggeredPrefetch`, but the request", "// will still reflect the passed-in `prefetchStatus`, since that's the", "// one the prefetching goroutine needs to decide what to do with.", "err", ":=", "p", ".", "cacheOrCancelPrefetch", "(", "ctx", ",", "ptr", ",", "kmd", ".", "TlfID", "(", ")", ",", "block", ",", "lifetime", ",", "TriggeredPrefetch", ",", "action", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "p", ".", "triggerPrefetch", "(", "req", ")", "\n", "}" ]

[ "ProcessBlockForPrefetch", "triggers", "a", "prefetch", "if", "appropriate", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "WaitChannelForBlockPrefetch", "(", "ctx", "context", ".", "Context", ",", "ptr", "data", ".", "BlockPointer", ")", "(", "waitCh", "<-", "chan", "struct", "{", "}", ",", "err", "error", ")", "{", "c", ":=", "make", "(", "chan", "(", "<-", "chan", "struct", "{", "}", ")", ",", "1", ")", "\n", "req", ":=", "&", "prefetchRequest", "{", "ptr", ",", "0", ",", "nil", ",", "nil", ",", "0", ",", "data", ".", "TransientEntry", ",", "0", ",", "BlockRequestSolo", ",", "c", ",", "nil", ",", "false", "}", "\n\n", "select", "{", "case", "p", ".", "prefetchRequestCh", ".", "In", "(", ")", "<-", "req", ":", "case", "<-", "p", ".", "shutdownCh", ":", "return", "nil", ",", "errPrefetcherAlreadyShutDown", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "nil", ",", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "// Wait for response.", "select", "{", "case", "waitCh", ":=", "<-", "c", ":", "return", "waitCh", ",", "nil", "\n", "case", "<-", "p", ".", "shutdownCh", ":", "return", "nil", ",", "errPrefetcherAlreadyShutDown", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "nil", ",", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "WaitChannelForBlockPrefetch", "implements", "the", "Prefetcher", "interface", "for", "blockPrefetcher", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "Status", "(", "ctx", "context", ".", "Context", ",", "ptr", "data", ".", "BlockPointer", ")", "(", "PrefetchProgress", ",", "error", ")", "{", "c", ":=", "make", "(", "chan", "PrefetchProgress", ",", "1", ")", "\n", "req", ":=", "&", "prefetchStatusRequest", "{", "ptr", ",", "c", "}", "\n\n", "select", "{", "case", "p", ".", "prefetchStatusCh", ".", "In", "(", ")", "<-", "req", ":", "case", "<-", "p", ".", "shutdownCh", ":", "return", "PrefetchProgress", "{", "}", ",", "errPrefetcherAlreadyShutDown", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "PrefetchProgress", "{", "}", ",", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "// Wait for response.", "select", "{", "case", "status", ":=", "<-", "c", ":", "return", "status", ",", "nil", "\n", "case", "<-", "p", ".", "shutdownCh", ":", "return", "PrefetchProgress", "{", "}", ",", "errPrefetcherAlreadyShutDown", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "PrefetchProgress", "{", "}", ",", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "Status", "implements", "the", "Prefetcher", "interface", "for", "blockPrefetcher", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "OverallSyncStatus", "(", ")", "PrefetchProgress", "{", "p", ".", "overallSyncStatusLock", ".", "RLock", "(", ")", "\n", "defer", "p", ".", "overallSyncStatusLock", ".", "RUnlock", "(", ")", "\n", "return", "p", ".", "overallSyncStatus", "\n", "}" ]

[ "OverallSyncStatus", "implements", "the", "Prefetcher", "interface", "for", "blockPrefetcher", "." ]

[ "func", "(", "p", "*", "blockPrefetcher", ")", "Shutdown", "(", ")", "<-", "chan", "struct", "{", "}", "{", "p", ".", "shutdownOnce", ".", "Do", "(", "func", "(", ")", "{", "close", "(", "p", ".", "shutdownCh", ")", "\n", "}", ")", "\n", "return", "p", ".", "doneCh", "\n", "}" ]

[ "Shutdown", "implements", "the", "Prefetcher", "interface", "for", "blockPrefetcher", "." ]

[ "func", "NewNotifyRouter", "(", "g", "*", "GlobalContext", ")", "*", "NotifyRouter", "{", "return", "&", "NotifyRouter", "{", "Contextified", ":", "NewContextified", "(", "g", ")", ",", "cm", ":", "g", ".", "ConnectionManager", ",", "state", ":", "make", "(", "map", "[", "ConnectionID", "]", "keybase1", ".", "NotificationChannels", ")", ",", "listeners", ":", "make", "(", "map", "[", "NotifyListenerID", "]", "NotifyListener", ")", ",", "}", "\n", "}" ]

[ "NewNotifyRouter", "makes", "a", "new", "notification", "router", ";", "we", "should", "only", "make", "one", "of", "these", "per", "process", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "GetChannels", "(", "i", "ConnectionID", ")", "keybase1", ".", "NotificationChannels", "{", "return", "n", ".", "getNotificationChannels", "(", "i", ")", "\n", "}" ]

[ "GetChannels", "retrieves", "which", "notification", "channels", "a", "connection", "is", "interested", "it", "given", "its", "ID", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "AddConnection", "(", "xp", "rpc", ".", "Transporter", ",", "ch", "chan", "error", ")", "ConnectionID", "{", "if", "n", "==", "nil", "{", "return", "0", "\n", "}", "\n", "id", ":=", "n", ".", "cm", ".", "AddConnection", "(", "xp", ",", "ch", ")", "\n", "n", ".", "setNotificationChannels", "(", "id", ",", "keybase1", ".", "NotificationChannels", "{", "}", ")", "\n", "return", "id", "\n", "}" ]

[ "AddConnection", "should", "be", "called", "every", "time", "there", "s", "a", "new", "RPC", "connection", "established", "for", "this", "server", ".", "The", "caller", "should", "pass", "in", "the", "Transporter", "and", "also", "the", "channel", "that", "will", "get", "messages", "when", "the", "channel", "closes", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "SetChannels", "(", "i", "ConnectionID", ",", "nc", "keybase1", ".", "NotificationChannels", ")", "{", "n", ".", "setNotificationChannels", "(", "i", ",", "nc", ")", "\n", "}" ]

[ "SetChannels", "sets", "which", "notification", "channels", "are", "interested", "for", "the", "connection", "with", "the", "given", "connection", "ID", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleLogout", "(", "ctx", "context", ".", "Context", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "defer", "CTrace", "(", "ctx", ",", "n", ".", "G", "(", ")", ".", "Log", ",", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ")", "(", ")", "\n", "ctx", "=", "CopyTagsToBackground", "(", "ctx", ")", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAllDetails", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ",", "d", "*", "keybase1", ".", "ClientDetails", ")", "bool", "{", "// If the connection wants the `Session` notification type", "registered", ":=", "false", "\n", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Session", "{", "registered", "=", "true", "\n", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `LoggedOut` RPC", "(", "keybase1", ".", "NotifySessionClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "LoggedOut", "(", "ctx", ")", "\n", "}", "(", ")", "\n", "}", "\n", "desc", ":=", "\"", "\"", "\n", "if", "d", "!=", "nil", "{", "desc", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "*", "d", ")", "\n", "}", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "desc", ",", "registered", ")", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "Logout", "(", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleLogout", "is", "called", "whenever", "the", "current", "user", "logged", "out", ".", "It", "will", "broadcast", "the", "message", "to", "all", "connections", "who", "care", "about", "such", "a", "message", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleLogin", "(", "ctx", "context", ".", "Context", ",", "u", "string", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "u", ")", "\n", "// For all connections we currently have open...", "ctx", "=", "CopyTagsToBackground", "(", "ctx", ")", "\n", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Session` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Session", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `LoggedIn` RPC", "(", "keybase1", ".", "NotifySessionClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "LoggedIn", "(", "ctx", ",", "u", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "Login", "(", "u", ")", "\n", "}", ")", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "}" ]

[ "HandleLogin", "is", "called", "whenever", "a", "user", "logs", "in", ".", "It", "will", "broadcast", "the", "message", "to", "all", "connections", "who", "care", "about", "such", "a", "message", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleTrackingChanged", "(", "uid", "keybase1", ".", "UID", ",", "username", "NormalizedUsername", ",", "isTracking", "bool", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "arg", ":=", "keybase1", ".", "TrackingChangedArg", "{", "Uid", ":", "uid", ",", "Username", ":", "username", ".", "String", "(", ")", ",", "IsTracking", ":", "isTracking", ",", "}", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Tracking` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Tracking", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `TrackingChanged` RPC with the user's UID", "(", "keybase1", ".", "NotifyTrackingClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "TrackingChanged", "(", "context", ".", "Background", "(", ")", ",", "arg", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "TrackingChanged", "(", "uid", ",", "username", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleTrackingChanged", "is", "called", "whenever", "we", "have", "a", "new", "tracking", "or", "untracking", "chain", "link", "related", "to", "a", "given", "user", ".", "It", "will", "broadcast", "the", "messages", "to", "all", "curious", "listeners", ".", "isTracking", "is", "set", "to", "true", "if", "current", "user", "is", "tracking", "uid", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleBadgeState", "(", "badgeState", "keybase1", ".", "BadgeState", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Badges` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Badges", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `BadgeState` RPC with the badge state", "(", "keybase1", ".", "NotifyBadgesClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "BadgeState", "(", "context", ".", "Background", "(", ")", ",", "badgeState", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "BadgeState", "(", "badgeState", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleBadgeState", "is", "called", "whenever", "the", "badge", "state", "changes", "It", "will", "broadcast", "the", "messages", "to", "all", "curious", "listeners", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSOnlineStatusChanged", "(", "online", "bool", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `kbfs` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfs", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `FSOnlineStatusChanged` RPC with the", "// notification", "(", "keybase1", ".", "NotifyFSClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSOnlineStatusChanged", "(", "context", ".", "Background", "(", ")", ",", "online", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSOnlineStatusChanged", "(", "online", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSOnlineStatusChanged", "is", "called", "when", "KBFS", "s", "online", "status", "changes", ".", "It", "will", "broadcast", "the", "messages", "to", "all", "curious", "listeners", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSOverallSyncStatusChanged", "(", "status", "keybase1", ".", "FolderSyncStatus", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `kbfs` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfs", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `FSOnlineStatusChanged` RPC with the", "// notification", "(", "keybase1", ".", "NotifyFSClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSOverallSyncStatusChanged", "(", "context", ".", "Background", "(", ")", ",", "status", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSOverallSyncStatusChanged", "(", "status", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSOverallSyncStatusChanged", "is", "called", "when", "the", "overall", "sync", "status", "changes", ".", "It", "will", "broadcast", "the", "messages", "to", "all", "curious", "listeners", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSActivity", "(", "activity", "keybase1", ".", "FSNotification", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Kbfsdesktop` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfsdesktop", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `FSActivity` RPC with the notification", "(", "keybase1", ".", "NotifyFSClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSActivity", "(", "context", ".", "Background", "(", ")", ",", "activity", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSActivity", "(", "activity", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSActivity", "is", "called", "for", "any", "KBFS", "notification", ".", "It", "will", "broadcast", "the", "messages", "to", "all", "curious", "listeners", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSPathUpdated", "(", "path", "string", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Kbfs` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfs", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `FSPathUpdated` RPC with the notification", "(", "keybase1", ".", "NotifyFSClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSPathUpdated", "(", "context", ".", "Background", "(", ")", ",", "path", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSPathUpdated", "(", "path", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSPathUpdated", "is", "called", "for", "any", "path", "update", "notification", ".", "It", "will", "broadcast", "the", "messages", "to", "all", "curious", "listeners", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSEditListResponse", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "FSEditListArg", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n\n", "// We have to make sure the context survives until all subsequent", "// RPCs launched in this method are done. So we wait until", "// the last completes before returning.", "var", "wg", "sync", ".", "WaitGroup", "\n\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Kbfslegacy` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfslegacy", "{", "// In the background do...", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "// A send of a `FSEditListResponse` RPC with the notification", "(", "keybase1", ".", "NotifyFSClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSEditListResponse", "(", "context", ".", "Background", "(", ")", ",", "keybase1", ".", "FSEditListResponseArg", "{", "Edits", ":", "arg", ".", "Edits", ",", "RequestID", ":", "arg", ".", "RequestID", ",", "}", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "wg", ".", "Wait", "(", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSEditListResponse", "(", "arg", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSEditListResponse", "is", "called", "for", "KBFS", "edit", "list", "response", "notifications", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSEditListRequest", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "FSEditListRequest", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n\n", "// See above", "var", "wg", "sync", ".", "WaitGroup", "\n\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Kbfslegacy` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfslegacy", "{", "wg", ".", "Add", "(", "1", ")", "\n", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `FSEditListRequest` RPC with the notification", "(", "keybase1", ".", "NotifyFSRequestClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSEditListRequest", "(", "context", ".", "Background", "(", ")", ",", "arg", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "wg", ".", "Wait", "(", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSEditListRequest", "(", "arg", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSEditListRequest", "is", "called", "for", "KBFS", "edit", "list", "request", "notifications", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSSyncStatus", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "FSSyncStatusArg", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Kbfslegacy` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfslegacy", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `FSSyncStatusResponse` RPC with the notification", "(", "keybase1", ".", "NotifyFSClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSSyncStatusResponse", "(", "context", ".", "Background", "(", ")", ",", "keybase1", ".", "FSSyncStatusResponseArg", "{", "Status", ":", "arg", ".", "Status", ",", "RequestID", ":", "arg", ".", "RequestID", "}", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSSyncStatusResponse", "(", "arg", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSSyncStatus", "is", "called", "for", "KBFS", "sync", "status", "notifications", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleFSSyncEvent", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "FSPathSyncStatus", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Kbfs` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Kbfs", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `FSSyncActivity` RPC with the notification", "(", "keybase1", ".", "NotifyFSClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "FSSyncActivity", "(", "context", ".", "Background", "(", ")", ",", "arg", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "FSSyncEvent", "(", "arg", ")", "\n", "}", ")", "\n", "}" ]

[ "HandleFSSyncEvent", "is", "called", "for", "KBFS", "sync", "event", "notifications", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleDeviceCloneNotification", "(", "newClones", "int", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Deviceclone` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Deviceclone", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `DeviceCloneCountChanged` RPC with the number of newly discovered clones", "(", "keybase1", ".", "NotifyDeviceCloneClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "DeviceCloneCountChanged", "(", "context", ".", "Background", "(", ")", ",", "newClones", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "DeviceCloneCountChanged", "(", "newClones", ")", "\n", "}", ")", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "HandleDeviceCloneNotification", "is", "called", "when", "a", "run", "of", "the", "device", "clone", "status", "update", "finds", "a", "newly", "-", "added", "possible", "clone", ".", "It", "will", "broadcast", "the", "messages", "to", "all", "curious", "listeners", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandlePaperKeyCached", "(", "uid", "keybase1", ".", "UID", ",", "encKID", "keybase1", ".", "KID", ",", "sigKID", "keybase1", ".", "KID", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "arg", ":=", "keybase1", ".", "PaperKeyCachedArg", "{", "Uid", ":", "uid", ",", "EncKID", ":", "encKID", ",", "SigKID", ":", "sigKID", ",", "}", "\n", "var", "wg", "sync", ".", "WaitGroup", "\n\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Favorites` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Paperkeys", "{", "wg", ".", "Add", "(", "1", ")", "\n", "// In the background do...", "go", "func", "(", ")", "{", "(", "keybase1", ".", "NotifyPaperKeyClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "PaperKeyCached", "(", "context", ".", "Background", "(", ")", ",", "arg", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "wg", ".", "Wait", "(", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "PaperKeyCached", "(", "uid", ",", "encKID", ",", "sigKID", ")", "\n", "}", ")", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "HandlePaperKeyCached", "is", "called", "whenever", "a", "paper", "key", "is", "cached", "in", "response", "to", "a", "rekey", "harassment", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleKeyfamilyChanged", "(", "uid", "keybase1", ".", "UID", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Favorites` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Keyfamily", "{", "// In the background do...", "go", "func", "(", ")", "{", "(", "keybase1", ".", "NotifyKeyfamilyClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "KeyfamilyChanged", "(", "context", ".", "Background", "(", ")", ",", "uid", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "KeyfamilyChanged", "(", "uid", ")", "\n", "}", ")", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "HandleKeyfamilyChanged", "is", "called", "whenever", "a", "user", "s", "keyfamily", "changes", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleServiceShutdown", "(", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "var", "wg", "sync", ".", "WaitGroup", "\n\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Service` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Service", "{", "// In the background do...", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "(", "keybase1", ".", "NotifyServiceClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "Shutdown", "(", "context", ".", "Background", "(", ")", ",", "int", "(", "n", ".", "G", "(", ")", ".", "ExitCode", ")", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "done", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "go", "func", "(", ")", "{", "wg", ".", "Wait", "(", ")", "\n", "close", "(", "done", ")", "\n", "}", "(", ")", "\n\n", "// timeout after 4s (launchd will SIGKILL after 5s)", "select", "{", "case", "<-", "done", ":", "case", "<-", "time", ".", "After", "(", "4", "*", "time", ".", "Second", ")", ":", "n", ".", "G", "(", ")", ".", "Log", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "HandleServiceShutdown", "is", "called", "whenever", "the", "service", "shuts", "down", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleAppExit", "(", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "App", "{", "go", "func", "(", ")", "{", "(", "keybase1", ".", "NotifyAppClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "Exit", "(", "context", ".", "Background", "(", ")", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "HandleAppExit", "is", "called", "whenever", "an", "app", "exit", "command", "is", "issued" ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandlePGPKeyInSecretStoreFile", "(", ")", "{", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "PGP", "{", "go", "func", "(", ")", "{", "(", "keybase1", ".", "NotifyPGPClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "PGPKeyInSecretStoreFile", "(", "context", ".", "Background", "(", ")", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "PGPKeyInSecretStoreFile", "(", ")", "\n", "}", ")", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "HandlePGPKeyInSecretStoreFile", "is", "called", "to", "notify", "a", "user", "that", "they", "have", "a", "PGP", "key", "that", "is", "unlockable", "by", "a", "secret", "stored", "in", "a", "file", "in", "their", "home", "directory", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleTeamChangedByBothKeys", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "teamName", "string", ",", "latestSeqno", "keybase1", ".", "Seqno", ",", "implicitTeam", "bool", ",", "changes", "keybase1", ".", "TeamChangeSet", ")", "{", "n", ".", "HandleTeamChangedByID", "(", "ctx", ",", "teamID", ",", "latestSeqno", ",", "implicitTeam", ",", "changes", ")", "\n", "n", ".", "HandleTeamChangedByName", "(", "ctx", ",", "teamName", ",", "latestSeqno", ",", "implicitTeam", ",", "changes", ")", "\n", "}" ]

[ "teamID", "and", "teamName", "are", "not", "necessarily", "the", "same", "team" ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleTeamListUnverifiedChanged", "(", "ctx", "context", ".", "Context", ",", "teamName", "string", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "teamName", ")", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Team` notifications", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Team", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `TeamListUnverifiedChanged` RPC", "(", "keybase1", ".", "NotifyUnverifiedTeamListClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "TeamListUnverifiedChanged", "(", "context", ".", "Background", "(", ")", ",", "teamName", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "TeamListUnverifiedChanged", "(", "teamName", ")", "\n", "}", ")", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "teamName", ")", "\n", "}" ]

[ "HandleTeamListUnverifiedChanged", "is", "called", "when", "a", "notification", "is", "received", "from", "gregor", "that", "we", "think", "might", "be", "of", "interest", "to", "the", "UI", "specifically", "the", "parts", "of", "the", "UI", "that", "update", "using", "the", "TeamListUnverified", "rpc", "." ]

[ "func", "(", "n", "*", "NotifyRouter", ")", "HandleRootAuditError", "(", "msg", "string", ")", "{", "if", "n", "==", "nil", "{", "return", "\n", "}", "\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "// For all connections we currently have open...", "n", ".", "cm", ".", "ApplyAll", "(", "func", "(", "id", "ConnectionID", ",", "xp", "rpc", ".", "Transporter", ")", "bool", "{", "// If the connection wants the `Session` notification type", "if", "n", ".", "getNotificationChannels", "(", "id", ")", ".", "Audit", "{", "// In the background do...", "go", "func", "(", ")", "{", "// A send of a `RootAuditError` RPC", "(", "keybase1", ".", "NotifyAuditClient", "{", "Cli", ":", "rpc", ".", "NewClient", "(", "xp", ",", "NewContextifiedErrorUnwrapper", "(", "n", ".", "G", "(", ")", ")", ",", "nil", ")", ",", "}", ")", ".", "RootAuditError", "(", "context", ".", "Background", "(", ")", ",", "msg", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n\n", "n", ".", "runListeners", "(", "func", "(", "listener", "NotifyListener", ")", "{", "listener", ".", "RootAuditError", "(", "msg", ")", "\n", "}", ")", "\n\n", "n", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "RootAuditError", "is", "called", "when", "the", "merkle", "root", "auditor", "finds", "an", "invalid", "skip", "sequence", "in", "a", "random", "old", "block", "." ]

[ "func", "NewKex2Provisioner", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "secret", "kex2", ".", "Secret", ",", "pps", "*", "libkb", ".", "PassphraseStream", ")", "*", "Kex2Provisioner", "{", "e", ":=", "&", "Kex2Provisioner", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "secret", ":", "secret", ",", "secretCh", ":", "make", "(", "chan", "kex2", ".", "Secret", ")", ",", "}", "\n", "if", "pps", "!=", "nil", "{", "e", ".", "pps", "=", "pps", ".", "Export", "(", ")", "\n", "}", "\n\n", "return", "e", "\n", "}" ]

[ "NewKex2Provisioner", "creates", "a", "Kex2Provisioner", "engine", "." ]

[ "func", "(", "e", "*", "Kex2Provisioner", ")", "Run", "(", "m", "libkb", ".", "MetaContext", ")", "error", "{", "// The guard is acquired later, after the potentially long pause by the user.", "defer", "m", ".", "G", "(", ")", ".", "LocalSigchainGuard", "(", ")", ".", "Clear", "(", "m", ".", "Ctx", "(", ")", ",", "\"", "\"", ")", "\n\n", "// before starting provisioning, need to load some information:", "if", "err", ":=", "e", ".", "loadMe", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "e", ".", "loadSecretKeys", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// get current passphrase stream if necessary:", "if", "e", ".", "pps", ".", "PassphraseStream", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "pps", ",", "err", ":=", "libkb", ".", "GetPassphraseStreamStored", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "e", ".", "pps", "=", "pps", ".", "Export", "(", ")", "\n", "}", "\n\n", "// Go's context.Context needed by some kex2 callback functions", "m", "=", "m", ".", "EnsureCtx", "(", ")", "\n", "e", ".", "mctx", "=", "m", "\n\n", "deviceID", ":=", "m", ".", "G", "(", ")", ".", "Env", ".", "GetDeviceID", "(", ")", "\n\n", "// all set: start provisioner", "karg", ":=", "kex2", ".", "KexBaseArg", "{", "Ctx", ":", "m", ".", "Ctx", "(", ")", ",", "LogCtx", ":", "newKex2LogContext", "(", "m", ".", "G", "(", ")", ")", ",", "Mr", ":", "libkb", ".", "NewKexRouter", "(", "m", ")", ",", "DeviceID", ":", "deviceID", ",", "Secret", ":", "e", ".", "secret", ",", "SecretChannel", ":", "e", ".", "secretCh", ",", "Timeout", ":", "60", "*", "time", ".", "Minute", ",", "}", "\n", "parg", ":=", "kex2", ".", "ProvisionerArg", "{", "KexBaseArg", ":", "karg", ",", "Provisioner", ":", "e", ",", "HelloTimeout", ":", "15", "*", "time", ".", "Second", ",", "}", "\n", "if", "err", ":=", "kex2", ".", "RunProvisioner", "(", "parg", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "m", ".", "G", "(", ")", ".", "LocalSigchainGuard", "(", ")", ".", "Clear", "(", "m", ".", "Ctx", "(", ")", ",", "\"", "\"", ")", "\n\n", "// successfully provisioned the other device", "sarg", ":=", "keybase1", ".", "ProvisionerSuccessArg", "{", "DeviceName", ":", "e", ".", "provisioneeDeviceName", ",", "DeviceType", ":", "e", ".", "provisioneeDeviceType", ",", "}", "\n", "return", "m", ".", "UIs", "(", ")", ".", "ProvisionUI", ".", "ProvisionerSuccess", "(", "context", ".", "Background", "(", ")", ",", "sarg", ")", "\n", "}" ]

[ "Run", "starts", "the", "provisioner", "engine", "." ]

[ "func", "(", "e", "*", "Kex2Provisioner", ")", "GetHelloArg", "(", ")", "(", "arg", "keybase1", ".", "HelloArg", ",", "err", "error", ")", "{", "// Pull the metaContext out of the this object, since we can't pass it through the", "// kex2/provisioner interface", "m", ":=", "e", ".", "mctx", "\n\n", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "m", ".", "UIs", "(", ")", ".", "ProvisionUI", ".", "DisplaySecretExchanged", "(", "context", ".", "Background", "(", ")", ",", "0", ")", "\n\n", "// get a session token that device Y can use", "mctx", ":=", "libkb", ".", "NewMetaContextBackground", "(", "e", ".", "G", "(", ")", ")", "\n", "tokener", ",", "err", ":=", "libkb", ".", "NewSessionTokener", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "arg", ",", "err", "\n", "}", "\n", "token", ",", "csrf", ":=", "tokener", ".", "Tokens", "(", ")", "\n\n", "// generate a skeleton key proof", "sigBody", ",", "err", ":=", "e", ".", "skeletonProof", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "arg", ",", "err", "\n", "}", "\n\n", "// return the HelloArg", "arg", "=", "keybase1", ".", "HelloArg", "{", "Uid", ":", "e", ".", "me", ".", "GetUID", "(", ")", ",", "Pps", ":", "e", ".", "pps", ",", "Token", ":", "keybase1", ".", "SessionToken", "(", "token", ")", ",", "Csrf", ":", "keybase1", ".", "CsrfToken", "(", "csrf", ")", ",", "SigBody", ":", "sigBody", ",", "}", "\n", "return", "arg", ",", "nil", "\n", "}" ]

[ "GetHelloArg", "implements", "GetHelloArg", "in", "kex2", ".", "Provisioner", "." ]