id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
160,600 | keybase/client | go/protocol/keybase1/crypto.go | SignToString | func (c CryptoClient) SignToString(ctx context.Context, __arg SignToStringArg) (res string, err error) {
err = c.Cli.Call(ctx, "keybase.1.crypto.signToString", []interface{}{__arg}, &res)
return
} | go | func (c CryptoClient) SignToString(ctx context.Context, __arg SignToStringArg) (res string, err error) {
err = c.Cli.Call(ctx, "keybase.1.crypto.signToString", []interface{}{__arg}, &res)
return
} | [
"func",
"(",
"c",
"CryptoClient",
")",
"SignToString",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"SignToStringArg",
")",
"(",
"res",
"string",
",",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"[",
"]",
"interface",
"{",
"}",
"{",
"__arg",
"}",
",",
"&",
"res",
")",
"\n",
"return",
"\n",
"}"
] | // Same as the above except the full marshaled and encoded NaclSigInfo. | [
"Same",
"as",
"the",
"above",
"except",
"the",
"full",
"marshaled",
"and",
"encoded",
"NaclSigInfo",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/crypto.go#L249-L252 |
160,601 | keybase/client | go/libkb/skb.go | DebugDumpKey | func DebugDumpKey(g *GlobalContext, name string, b []byte) {
tmp, err := ioutil.TempFile(os.TempDir(), "dump-"+name)
if err != nil {
g.Log.Warning("Failed to dumpKey %s: %s", name, err)
return
}
g.Log.Notice("DUMPKEY %s -> %s", name, tmp.Name())
buf := bytes.NewBuffer(b)
io.Copy(tmp, buf)
tmp.Close()
} | go | func DebugDumpKey(g *GlobalContext, name string, b []byte) {
tmp, err := ioutil.TempFile(os.TempDir(), "dump-"+name)
if err != nil {
g.Log.Warning("Failed to dumpKey %s: %s", name, err)
return
}
g.Log.Notice("DUMPKEY %s -> %s", name, tmp.Name())
buf := bytes.NewBuffer(b)
io.Copy(tmp, buf)
tmp.Close()
} | [
"func",
"DebugDumpKey",
"(",
"g",
"*",
"GlobalContext",
",",
"name",
"string",
",",
"b",
"[",
"]",
"byte",
")",
"{",
"tmp",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"os",
".",
"TempDir",
"(",
")",
",",
"\"",
"\"",
"+",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"g",
".",
"Log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"name",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"g",
".",
"Log",
".",
"Notice",
"(",
"\"",
"\"",
",",
"name",
",",
"tmp",
".",
"Name",
"(",
")",
")",
"\n",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"b",
")",
"\n",
"io",
".",
"Copy",
"(",
"tmp",
",",
"buf",
")",
"\n",
"tmp",
".",
"Close",
"(",
")",
"\n",
"}"
] | // DebugDumpKey is used only in debugging. For now it's not in
// use but we might need it in the future. | [
"DebugDumpKey",
"is",
"used",
"only",
"in",
"debugging",
".",
"For",
"now",
"it",
"s",
"not",
"in",
"use",
"but",
"we",
"might",
"need",
"it",
"in",
"the",
"future",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/skb.go#L30-L40 |
160,602 | keybase/client | go/stellar/global.go | KickAutoClaimRunner | func (s *Stellar) KickAutoClaimRunner(mctx libkb.MetaContext, trigger gregor.MsgID) {
// Create the ACR if one does not exist.
mctx.Debug("KickAutoClaimRunner(trigger:%v)", trigger)
s.autoClaimRunnerLock.Lock()
defer s.autoClaimRunnerLock.Unlock()
if s.autoClaimRunner == nil {
s.autoClaimRunner = NewAutoClaimRunner(s.walletState)
}
s.autoClaimRunner.Kick(mctx, trigger)
} | go | func (s *Stellar) KickAutoClaimRunner(mctx libkb.MetaContext, trigger gregor.MsgID) {
// Create the ACR if one does not exist.
mctx.Debug("KickAutoClaimRunner(trigger:%v)", trigger)
s.autoClaimRunnerLock.Lock()
defer s.autoClaimRunnerLock.Unlock()
if s.autoClaimRunner == nil {
s.autoClaimRunner = NewAutoClaimRunner(s.walletState)
}
s.autoClaimRunner.Kick(mctx, trigger)
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"KickAutoClaimRunner",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"trigger",
"gregor",
".",
"MsgID",
")",
"{",
"// Create the ACR if one does not exist.",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
",",
"trigger",
")",
"\n",
"s",
".",
"autoClaimRunnerLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"autoClaimRunnerLock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"autoClaimRunner",
"==",
"nil",
"{",
"s",
".",
"autoClaimRunner",
"=",
"NewAutoClaimRunner",
"(",
"s",
".",
"walletState",
")",
"\n",
"}",
"\n",
"s",
".",
"autoClaimRunner",
".",
"Kick",
"(",
"mctx",
",",
"trigger",
")",
"\n",
"}"
] | // `trigger` is optional, and is of the gregor message that caused the kick. | [
"trigger",
"is",
"optional",
"and",
"is",
"of",
"the",
"gregor",
"message",
"that",
"caused",
"the",
"kick",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L175-L184 |
160,603 | keybase/client | go/stellar/global.go | UpdateUnreadCount | func (s *Stellar) UpdateUnreadCount(ctx context.Context, accountID stellar1.AccountID, unread int) error {
if s.badger == nil {
s.G().Log.CDebugf(ctx, "Stellar Global has no badger")
return nil
}
s.badger.SetWalletAccountUnreadCount(ctx, accountID, unread)
return nil
} | go | func (s *Stellar) UpdateUnreadCount(ctx context.Context, accountID stellar1.AccountID, unread int) error {
if s.badger == nil {
s.G().Log.CDebugf(ctx, "Stellar Global has no badger")
return nil
}
s.badger.SetWalletAccountUnreadCount(ctx, accountID, unread)
return nil
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"UpdateUnreadCount",
"(",
"ctx",
"context",
".",
"Context",
",",
"accountID",
"stellar1",
".",
"AccountID",
",",
"unread",
"int",
")",
"error",
"{",
"if",
"s",
".",
"badger",
"==",
"nil",
"{",
"s",
".",
"G",
"(",
")",
".",
"Log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"s",
".",
"badger",
".",
"SetWalletAccountUnreadCount",
"(",
"ctx",
",",
"accountID",
",",
"unread",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpdateUnreadCount will take the unread count for an account id and
// update the badger. | [
"UpdateUnreadCount",
"will",
"take",
"the",
"unread",
"count",
"for",
"an",
"account",
"id",
"and",
"update",
"the",
"badger",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L225-L233 |
160,604 | keybase/client | go/stellar/global.go | SpecMiniChatPayments | func (s *Stellar) SpecMiniChatPayments(mctx libkb.MetaContext, payments []libkb.MiniChatPayment) (*libkb.MiniChatPaymentSummary, error) {
return SpecMiniChatPayments(mctx, s.walletState, payments)
} | go | func (s *Stellar) SpecMiniChatPayments(mctx libkb.MetaContext, payments []libkb.MiniChatPayment) (*libkb.MiniChatPaymentSummary, error) {
return SpecMiniChatPayments(mctx, s.walletState, payments)
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"SpecMiniChatPayments",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"payments",
"[",
"]",
"libkb",
".",
"MiniChatPayment",
")",
"(",
"*",
"libkb",
".",
"MiniChatPaymentSummary",
",",
"error",
")",
"{",
"return",
"SpecMiniChatPayments",
"(",
"mctx",
",",
"s",
".",
"walletState",
",",
"payments",
")",
"\n",
"}"
] | // SpecMiniChatPayments creates a summary of the amounts that a list of MiniChatPayments will
// result in. | [
"SpecMiniChatPayments",
"creates",
"a",
"summary",
"of",
"the",
"amounts",
"that",
"a",
"list",
"of",
"MiniChatPayments",
"will",
"result",
"in",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L244-L246 |
160,605 | keybase/client | go/stellar/global.go | HandleOobm | func (s *Stellar) HandleOobm(ctx context.Context, obm gregor.OutOfBandMessage) (bool, error) {
if obm.System() == nil {
return false, errors.New("nil system in out of band message")
}
// make a new background context for the handlers
mctx := libkb.NewMetaContextBackground(s.G()).WithLogTag("WAOOBM")
// all of these handlers should be in goroutines so they don't block the
// oobm handler thread.
switch obm.System().String() {
case "internal.reconnect":
go s.handleReconnect(mctx)
// returning false, nil here so that others can handle this one too
return false, nil
case stellar1.PushPaymentStatus:
go s.handlePaymentStatus(mctx, obm)
return true, nil
case stellar1.PushPaymentNotification:
go s.handlePaymentNotification(mctx, obm)
return true, nil
case stellar1.PushRequestStatus:
go s.handleRequestStatus(mctx, obm)
return true, nil
}
return false, nil
} | go | func (s *Stellar) HandleOobm(ctx context.Context, obm gregor.OutOfBandMessage) (bool, error) {
if obm.System() == nil {
return false, errors.New("nil system in out of band message")
}
// make a new background context for the handlers
mctx := libkb.NewMetaContextBackground(s.G()).WithLogTag("WAOOBM")
// all of these handlers should be in goroutines so they don't block the
// oobm handler thread.
switch obm.System().String() {
case "internal.reconnect":
go s.handleReconnect(mctx)
// returning false, nil here so that others can handle this one too
return false, nil
case stellar1.PushPaymentStatus:
go s.handlePaymentStatus(mctx, obm)
return true, nil
case stellar1.PushPaymentNotification:
go s.handlePaymentNotification(mctx, obm)
return true, nil
case stellar1.PushRequestStatus:
go s.handleRequestStatus(mctx, obm)
return true, nil
}
return false, nil
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"HandleOobm",
"(",
"ctx",
"context",
".",
"Context",
",",
"obm",
"gregor",
".",
"OutOfBandMessage",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"obm",
".",
"System",
"(",
")",
"==",
"nil",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// make a new background context for the handlers",
"mctx",
":=",
"libkb",
".",
"NewMetaContextBackground",
"(",
"s",
".",
"G",
"(",
")",
")",
".",
"WithLogTag",
"(",
"\"",
"\"",
")",
"\n\n",
"// all of these handlers should be in goroutines so they don't block the",
"// oobm handler thread.",
"switch",
"obm",
".",
"System",
"(",
")",
".",
"String",
"(",
")",
"{",
"case",
"\"",
"\"",
":",
"go",
"s",
".",
"handleReconnect",
"(",
"mctx",
")",
"\n",
"// returning false, nil here so that others can handle this one too",
"return",
"false",
",",
"nil",
"\n",
"case",
"stellar1",
".",
"PushPaymentStatus",
":",
"go",
"s",
".",
"handlePaymentStatus",
"(",
"mctx",
",",
"obm",
")",
"\n",
"return",
"true",
",",
"nil",
"\n",
"case",
"stellar1",
".",
"PushPaymentNotification",
":",
"go",
"s",
".",
"handlePaymentNotification",
"(",
"mctx",
",",
"obm",
")",
"\n",
"return",
"true",
",",
"nil",
"\n",
"case",
"stellar1",
".",
"PushRequestStatus",
":",
"go",
"s",
".",
"handleRequestStatus",
"(",
"mctx",
",",
"obm",
")",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // HandleOobm will handle any out of band gregor messages for stellar. | [
"HandleOobm",
"will",
"handle",
"any",
"out",
"of",
"band",
"gregor",
"messages",
"for",
"stellar",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L249-L277 |
160,606 | keybase/client | go/stellar/global.go | hasAcceptedDisclaimer | func (s *Stellar) hasAcceptedDisclaimer(ctx context.Context) (bool, error) {
log := func(format string, args ...interface{}) {
s.G().Log.CDebugf(ctx, "Stellar.hasAcceptedDisclaimer "+format, args...)
}
uv, err := s.G().GetMeUV(ctx)
if err != nil {
return false, err
}
s.disclaimerLock.Lock()
defer s.disclaimerLock.Unlock()
// Check memory
memAccepted := s.disclaimerAccepted != nil && s.disclaimerAccepted.Eq(uv)
log("mem -> %v", memAccepted)
if memAccepted {
return true, nil
}
// Check disk
dbKey := libkb.DbKey{
Typ: libkb.DBStellarDisclaimer,
Key: uv.String(),
}
var dbEntry hasAcceptedDisclaimerDBEntry
found, err := s.G().LocalDb.GetInto(&dbEntry, dbKey)
log("disk -> [found:%v err:(%v) v:%v accepted:%v]", found, err, dbEntry.Version, dbEntry.Accepted)
if err == nil && found && dbEntry.Version == 1 && dbEntry.Accepted {
err = s.informAcceptedDisclaimerLocked(ctx)
if err != nil {
log("store -> err:(%v)", err)
}
return true, nil
}
// Check remote
accepted, err := remote.GetAcceptedDisclaimer(ctx, s.G())
log("remote -> [err:(%v) accepted:%v]", err, accepted)
if err != nil {
return false, err
}
if accepted {
err = s.informAcceptedDisclaimerLocked(ctx)
if err != nil {
log("store -> err:(%v)", err)
}
}
return accepted, nil
} | go | func (s *Stellar) hasAcceptedDisclaimer(ctx context.Context) (bool, error) {
log := func(format string, args ...interface{}) {
s.G().Log.CDebugf(ctx, "Stellar.hasAcceptedDisclaimer "+format, args...)
}
uv, err := s.G().GetMeUV(ctx)
if err != nil {
return false, err
}
s.disclaimerLock.Lock()
defer s.disclaimerLock.Unlock()
// Check memory
memAccepted := s.disclaimerAccepted != nil && s.disclaimerAccepted.Eq(uv)
log("mem -> %v", memAccepted)
if memAccepted {
return true, nil
}
// Check disk
dbKey := libkb.DbKey{
Typ: libkb.DBStellarDisclaimer,
Key: uv.String(),
}
var dbEntry hasAcceptedDisclaimerDBEntry
found, err := s.G().LocalDb.GetInto(&dbEntry, dbKey)
log("disk -> [found:%v err:(%v) v:%v accepted:%v]", found, err, dbEntry.Version, dbEntry.Accepted)
if err == nil && found && dbEntry.Version == 1 && dbEntry.Accepted {
err = s.informAcceptedDisclaimerLocked(ctx)
if err != nil {
log("store -> err:(%v)", err)
}
return true, nil
}
// Check remote
accepted, err := remote.GetAcceptedDisclaimer(ctx, s.G())
log("remote -> [err:(%v) accepted:%v]", err, accepted)
if err != nil {
return false, err
}
if accepted {
err = s.informAcceptedDisclaimerLocked(ctx)
if err != nil {
log("store -> err:(%v)", err)
}
}
return accepted, nil
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"hasAcceptedDisclaimer",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"bool",
",",
"error",
")",
"{",
"log",
":=",
"func",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"G",
"(",
")",
".",
"Log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
"+",
"format",
",",
"args",
"...",
")",
"\n",
"}",
"\n",
"uv",
",",
"err",
":=",
"s",
".",
"G",
"(",
")",
".",
"GetMeUV",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"s",
".",
"disclaimerLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"disclaimerLock",
".",
"Unlock",
"(",
")",
"\n",
"// Check memory",
"memAccepted",
":=",
"s",
".",
"disclaimerAccepted",
"!=",
"nil",
"&&",
"s",
".",
"disclaimerAccepted",
".",
"Eq",
"(",
"uv",
")",
"\n",
"log",
"(",
"\"",
"\"",
",",
"memAccepted",
")",
"\n",
"if",
"memAccepted",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"// Check disk",
"dbKey",
":=",
"libkb",
".",
"DbKey",
"{",
"Typ",
":",
"libkb",
".",
"DBStellarDisclaimer",
",",
"Key",
":",
"uv",
".",
"String",
"(",
")",
",",
"}",
"\n",
"var",
"dbEntry",
"hasAcceptedDisclaimerDBEntry",
"\n",
"found",
",",
"err",
":=",
"s",
".",
"G",
"(",
")",
".",
"LocalDb",
".",
"GetInto",
"(",
"&",
"dbEntry",
",",
"dbKey",
")",
"\n",
"log",
"(",
"\"",
"\"",
",",
"found",
",",
"err",
",",
"dbEntry",
".",
"Version",
",",
"dbEntry",
".",
"Accepted",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"found",
"&&",
"dbEntry",
".",
"Version",
"==",
"1",
"&&",
"dbEntry",
".",
"Accepted",
"{",
"err",
"=",
"s",
".",
"informAcceptedDisclaimerLocked",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"// Check remote",
"accepted",
",",
"err",
":=",
"remote",
".",
"GetAcceptedDisclaimer",
"(",
"ctx",
",",
"s",
".",
"G",
"(",
")",
")",
"\n",
"log",
"(",
"\"",
"\"",
",",
"err",
",",
"accepted",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"accepted",
"{",
"err",
"=",
"s",
".",
"informAcceptedDisclaimerLocked",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"accepted",
",",
"nil",
"\n",
"}"
] | // For a UV, accepted starts out false and transitions to true. It never becomes false again.
// A cached true is returned, but a false always hits the server. | [
"For",
"a",
"UV",
"accepted",
"starts",
"out",
"false",
"and",
"transitions",
"to",
"true",
".",
"It",
"never",
"becomes",
"false",
"again",
".",
"A",
"cached",
"true",
"is",
"returned",
"but",
"a",
"false",
"always",
"hits",
"the",
"server",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L356-L400 |
160,607 | keybase/client | go/stellar/global.go | stopBuildPayment | func (s *Stellar) stopBuildPayment(mctx libkb.MetaContext, bid stellar1.BuildPaymentID) {
mctx.Debug("Stellar.stopBuildPayment(%v)", bid)
if bid.IsNil() {
s.buildPaymentSlot.Stop()
return
}
s.bidLock.Lock()
defer s.bidLock.Unlock()
for _, entry := range s.bids {
if entry.Bid.Eq(bid) {
if entry.Stopped {
mctx.Debug("payment already stopped")
return
}
entry.Slot.Shutdown()
entry.Stopped = true
mctx.Debug("payment shutdown")
return
}
}
mctx.Debug("payment not found to stop")
} | go | func (s *Stellar) stopBuildPayment(mctx libkb.MetaContext, bid stellar1.BuildPaymentID) {
mctx.Debug("Stellar.stopBuildPayment(%v)", bid)
if bid.IsNil() {
s.buildPaymentSlot.Stop()
return
}
s.bidLock.Lock()
defer s.bidLock.Unlock()
for _, entry := range s.bids {
if entry.Bid.Eq(bid) {
if entry.Stopped {
mctx.Debug("payment already stopped")
return
}
entry.Slot.Shutdown()
entry.Stopped = true
mctx.Debug("payment shutdown")
return
}
}
mctx.Debug("payment not found to stop")
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"stopBuildPayment",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"bid",
"stellar1",
".",
"BuildPaymentID",
")",
"{",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
",",
"bid",
")",
"\n",
"if",
"bid",
".",
"IsNil",
"(",
")",
"{",
"s",
".",
"buildPaymentSlot",
".",
"Stop",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"s",
".",
"bidLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"bidLock",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"entry",
":=",
"range",
"s",
".",
"bids",
"{",
"if",
"entry",
".",
"Bid",
".",
"Eq",
"(",
"bid",
")",
"{",
"if",
"entry",
".",
"Stopped",
"{",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"entry",
".",
"Slot",
".",
"Shutdown",
"(",
")",
"\n",
"entry",
".",
"Stopped",
"=",
"true",
"\n",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // stopBuildPayment stops a bid forever. | [
"stopBuildPayment",
"stops",
"a",
"bid",
"forever",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L454-L475 |
160,608 | keybase/client | go/stellar/global.go | acquireBuildPayment | func (s *Stellar) acquireBuildPayment(mctx1 libkb.MetaContext, bid stellar1.BuildPaymentID, sessionID int) (
mctx libkb.MetaContext, data *buildPaymentData, release func(), err error) {
mctx = mctx1
mctx.Debug("Stellar.acquireBuildPayment(%v)", bid)
release = func() {}
s.bidLock.Lock()
defer s.bidLock.Unlock()
for _, entry := range s.bids {
entry := entry
if !entry.Bid.Eq(bid) {
continue
}
if entry.Stopped {
return mctx, nil, release, fmt.Errorf("This payment might have already been sent. Check your recent payments before trying again.")
}
mctx = mctx.WithCtx(entry.Slot.Use(mctx.Ctx(), sessionID))
if err = mctx.Ctx().Err(); err != nil {
return mctx, nil, release, err
}
err = libkb.AcquireWithContextAndTimeout(mctx.Ctx(), &entry.DataLock, 5*time.Second)
if err != nil {
mctx.Debug("error while attempting to acquire data lock: %v", err)
return mctx, nil, release, err
}
release = libkb.Once(func() {
entry.DataLock.Unlock()
})
return mctx, &entry.Data, release, nil
}
return mctx, nil, release, fmt.Errorf("payment build not found")
} | go | func (s *Stellar) acquireBuildPayment(mctx1 libkb.MetaContext, bid stellar1.BuildPaymentID, sessionID int) (
mctx libkb.MetaContext, data *buildPaymentData, release func(), err error) {
mctx = mctx1
mctx.Debug("Stellar.acquireBuildPayment(%v)", bid)
release = func() {}
s.bidLock.Lock()
defer s.bidLock.Unlock()
for _, entry := range s.bids {
entry := entry
if !entry.Bid.Eq(bid) {
continue
}
if entry.Stopped {
return mctx, nil, release, fmt.Errorf("This payment might have already been sent. Check your recent payments before trying again.")
}
mctx = mctx.WithCtx(entry.Slot.Use(mctx.Ctx(), sessionID))
if err = mctx.Ctx().Err(); err != nil {
return mctx, nil, release, err
}
err = libkb.AcquireWithContextAndTimeout(mctx.Ctx(), &entry.DataLock, 5*time.Second)
if err != nil {
mctx.Debug("error while attempting to acquire data lock: %v", err)
return mctx, nil, release, err
}
release = libkb.Once(func() {
entry.DataLock.Unlock()
})
return mctx, &entry.Data, release, nil
}
return mctx, nil, release, fmt.Errorf("payment build not found")
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"acquireBuildPayment",
"(",
"mctx1",
"libkb",
".",
"MetaContext",
",",
"bid",
"stellar1",
".",
"BuildPaymentID",
",",
"sessionID",
"int",
")",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"data",
"*",
"buildPaymentData",
",",
"release",
"func",
"(",
")",
",",
"err",
"error",
")",
"{",
"mctx",
"=",
"mctx1",
"\n",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
",",
"bid",
")",
"\n",
"release",
"=",
"func",
"(",
")",
"{",
"}",
"\n",
"s",
".",
"bidLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"bidLock",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"entry",
":=",
"range",
"s",
".",
"bids",
"{",
"entry",
":=",
"entry",
"\n",
"if",
"!",
"entry",
".",
"Bid",
".",
"Eq",
"(",
"bid",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"entry",
".",
"Stopped",
"{",
"return",
"mctx",
",",
"nil",
",",
"release",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"mctx",
"=",
"mctx",
".",
"WithCtx",
"(",
"entry",
".",
"Slot",
".",
"Use",
"(",
"mctx",
".",
"Ctx",
"(",
")",
",",
"sessionID",
")",
")",
"\n",
"if",
"err",
"=",
"mctx",
".",
"Ctx",
"(",
")",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"mctx",
",",
"nil",
",",
"release",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"libkb",
".",
"AcquireWithContextAndTimeout",
"(",
"mctx",
".",
"Ctx",
"(",
")",
",",
"&",
"entry",
".",
"DataLock",
",",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"mctx",
",",
"nil",
",",
"release",
",",
"err",
"\n",
"}",
"\n",
"release",
"=",
"libkb",
".",
"Once",
"(",
"func",
"(",
")",
"{",
"entry",
".",
"DataLock",
".",
"Unlock",
"(",
")",
"\n",
"}",
")",
"\n",
"return",
"mctx",
",",
"&",
"entry",
".",
"Data",
",",
"release",
",",
"nil",
"\n",
"}",
"\n",
"return",
"mctx",
",",
"nil",
",",
"release",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // acquireBuildPayment takes ownership of a payment build.
// Returns a new `mctx` that the caller should switch to. Because it runs within the slot.
// When err=nil the caller owns `data` and must release it with `release` when finished.
// When err!=nil data is nil.
// `release` can be called even when err!=nil.
// `mctx` can also be used if err!=nil.
// Callers should `release` soon after their context is canceled. | [
"acquireBuildPayment",
"takes",
"ownership",
"of",
"a",
"payment",
"build",
".",
"Returns",
"a",
"new",
"mctx",
"that",
"the",
"caller",
"should",
"switch",
"to",
".",
"Because",
"it",
"runs",
"within",
"the",
"slot",
".",
"When",
"err",
"=",
"nil",
"the",
"caller",
"owns",
"data",
"and",
"must",
"release",
"it",
"with",
"release",
"when",
"finished",
".",
"When",
"err!",
"=",
"nil",
"data",
"is",
"nil",
".",
"release",
"can",
"be",
"called",
"even",
"when",
"err!",
"=",
"nil",
".",
"mctx",
"can",
"also",
"be",
"used",
"if",
"err!",
"=",
"nil",
".",
"Callers",
"should",
"release",
"soon",
"after",
"their",
"context",
"is",
"canceled",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L484-L514 |
160,609 | keybase/client | go/stellar/global.go | finalizeBuildPayment | func (s *Stellar) finalizeBuildPayment(mctx libkb.MetaContext, bid stellar1.BuildPaymentID) (res *buildPaymentData, err error) {
mctx.Debug("Stellar.finalizeBuildPayment(%v)", bid)
s.bidLock.Lock()
defer s.bidLock.Unlock()
for _, entry := range s.bids {
entry := entry
if !entry.Bid.Eq(bid) {
continue
}
if entry.Stopped {
return nil, fmt.Errorf("This payment might have already been sent. Check your recent payments before trying again.")
}
entry.Slot.Shutdown()
entry.Stopped = true
err = libkb.AcquireWithContextAndTimeout(mctx.Ctx(), &entry.DataLock, 5*time.Second)
if err != nil {
// This likely means something in the Slot is not yielding to its context or forgot to release the lock.
mctx.Debug("error while attempting to acquire data lock: %v", err)
return nil, err
}
res = &entry.Data
entry.DataLock.Unlock()
return res, nil
}
return nil, fmt.Errorf("payment build not found")
} | go | func (s *Stellar) finalizeBuildPayment(mctx libkb.MetaContext, bid stellar1.BuildPaymentID) (res *buildPaymentData, err error) {
mctx.Debug("Stellar.finalizeBuildPayment(%v)", bid)
s.bidLock.Lock()
defer s.bidLock.Unlock()
for _, entry := range s.bids {
entry := entry
if !entry.Bid.Eq(bid) {
continue
}
if entry.Stopped {
return nil, fmt.Errorf("This payment might have already been sent. Check your recent payments before trying again.")
}
entry.Slot.Shutdown()
entry.Stopped = true
err = libkb.AcquireWithContextAndTimeout(mctx.Ctx(), &entry.DataLock, 5*time.Second)
if err != nil {
// This likely means something in the Slot is not yielding to its context or forgot to release the lock.
mctx.Debug("error while attempting to acquire data lock: %v", err)
return nil, err
}
res = &entry.Data
entry.DataLock.Unlock()
return res, nil
}
return nil, fmt.Errorf("payment build not found")
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"finalizeBuildPayment",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"bid",
"stellar1",
".",
"BuildPaymentID",
")",
"(",
"res",
"*",
"buildPaymentData",
",",
"err",
"error",
")",
"{",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
",",
"bid",
")",
"\n",
"s",
".",
"bidLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"bidLock",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"entry",
":=",
"range",
"s",
".",
"bids",
"{",
"entry",
":=",
"entry",
"\n",
"if",
"!",
"entry",
".",
"Bid",
".",
"Eq",
"(",
"bid",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"entry",
".",
"Stopped",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"entry",
".",
"Slot",
".",
"Shutdown",
"(",
")",
"\n",
"entry",
".",
"Stopped",
"=",
"true",
"\n",
"err",
"=",
"libkb",
".",
"AcquireWithContextAndTimeout",
"(",
"mctx",
".",
"Ctx",
"(",
")",
",",
"&",
"entry",
".",
"DataLock",
",",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// This likely means something in the Slot is not yielding to its context or forgot to release the lock.",
"mctx",
".",
"Debug",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"&",
"entry",
".",
"Data",
"\n",
"entry",
".",
"DataLock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // finalizeBuildPayment stops a bid forever and returns its data. | [
"finalizeBuildPayment",
"stops",
"a",
"bid",
"forever",
"and",
"returns",
"its",
"data",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L517-L542 |
160,610 | keybase/client | go/stellar/global.go | BaseFee | func (s *Stellar) BaseFee(mctx libkb.MetaContext) uint64 {
return s.walletState.BaseFee(mctx)
} | go | func (s *Stellar) BaseFee(mctx libkb.MetaContext) uint64 {
return s.walletState.BaseFee(mctx)
} | [
"func",
"(",
"s",
"*",
"Stellar",
")",
"BaseFee",
"(",
"mctx",
"libkb",
".",
"MetaContext",
")",
"uint64",
"{",
"return",
"s",
".",
"walletState",
".",
"BaseFee",
"(",
"mctx",
")",
"\n",
"}"
] | // BaseFee returns the server-suggested base fee per operation. | [
"BaseFee",
"returns",
"the",
"server",
"-",
"suggested",
"base",
"fee",
"per",
"operation",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L549-L551 |
160,611 | keybase/client | go/stellar/global.go | getFederationClient | func getFederationClient(g *libkb.GlobalContext) federation.ClientInterface {
if g.Env.GetRunMode() != libkb.ProductionRunMode {
return federation.DefaultTestNetClient
}
return federation.DefaultPublicNetClient
} | go | func getFederationClient(g *libkb.GlobalContext) federation.ClientInterface {
if g.Env.GetRunMode() != libkb.ProductionRunMode {
return federation.DefaultTestNetClient
}
return federation.DefaultPublicNetClient
} | [
"func",
"getFederationClient",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"federation",
".",
"ClientInterface",
"{",
"if",
"g",
".",
"Env",
".",
"GetRunMode",
"(",
")",
"!=",
"libkb",
".",
"ProductionRunMode",
"{",
"return",
"federation",
".",
"DefaultTestNetClient",
"\n",
"}",
"\n",
"return",
"federation",
".",
"DefaultPublicNetClient",
"\n",
"}"
] | // getFederationClient is a helper function used during
// initialization. | [
"getFederationClient",
"is",
"a",
"helper",
"function",
"used",
"during",
"initialization",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/stellar/global.go#L555-L560 |
160,612 | keybase/client | go/client/cmd_simplefs_write.go | NewCmdSimpleFSWrite | func NewCmdSimpleFSWrite(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "write",
ArgumentHelp: "<path>",
Usage: "write input to file",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdSimpleFSWrite{Contextified: libkb.NewContextified(g)}, "write", c)
cl.SetNoStandalone()
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "a, append",
Usage: "add to existing file",
},
cli.IntFlag{
Name: "b, buffersize",
Value: writeBufSizeDefault,
Usage: "write buffer size",
},
},
}
} | go | func NewCmdSimpleFSWrite(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "write",
ArgumentHelp: "<path>",
Usage: "write input to file",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdSimpleFSWrite{Contextified: libkb.NewContextified(g)}, "write", c)
cl.SetNoStandalone()
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "a, append",
Usage: "add to existing file",
},
cli.IntFlag{
Name: "b, buffersize",
Value: writeBufSizeDefault,
Usage: "write buffer size",
},
},
}
} | [
"func",
"NewCmdSimpleFSWrite",
"(",
"cl",
"*",
"libcmdline",
".",
"CommandLine",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"cli",
".",
"Command",
"{",
"return",
"cli",
".",
"Command",
"{",
"Name",
":",
"\"",
"\"",
",",
"ArgumentHelp",
":",
"\"",
"\"",
",",
"Usage",
":",
"\"",
"\"",
",",
"Action",
":",
"func",
"(",
"c",
"*",
"cli",
".",
"Context",
")",
"{",
"cl",
".",
"ChooseCommand",
"(",
"&",
"CmdSimpleFSWrite",
"{",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
"}",
",",
"\"",
"\"",
",",
"c",
")",
"\n",
"cl",
".",
"SetNoStandalone",
"(",
")",
"\n",
"}",
",",
"Flags",
":",
"[",
"]",
"cli",
".",
"Flag",
"{",
"cli",
".",
"BoolFlag",
"{",
"Name",
":",
"\"",
"\"",
",",
"Usage",
":",
"\"",
"\"",
",",
"}",
",",
"cli",
".",
"IntFlag",
"{",
"Name",
":",
"\"",
"\"",
",",
"Value",
":",
"writeBufSizeDefault",
",",
"Usage",
":",
"\"",
"\"",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewCmdSimpleFSWrite creates a new cli.Command. | [
"NewCmdSimpleFSWrite",
"creates",
"a",
"new",
"cli",
".",
"Command",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/client/cmd_simplefs_write.go#L32-L53 |
160,613 | keybase/client | go/client/cmd_simplefs_write.go | ParseArgv | func (c *CmdSimpleFSWrite) ParseArgv(ctx *cli.Context) error {
nargs := len(ctx.Args())
var err error
c.bufSize = ctx.Int("buffersize")
if ctx.Bool("append") {
c.flags = keybase1.OpenFlags_WRITE | keybase1.OpenFlags_APPEND | keybase1.OpenFlags_EXISTING
} else {
c.flags = keybase1.OpenFlags_WRITE | keybase1.OpenFlags_REPLACE
}
if nargs != 1 {
return fmt.Errorf("write requires a path argument")
}
p, err := makeSimpleFSPath(ctx.Args()[0])
if err != nil {
return err
}
c.path = p
return err
} | go | func (c *CmdSimpleFSWrite) ParseArgv(ctx *cli.Context) error {
nargs := len(ctx.Args())
var err error
c.bufSize = ctx.Int("buffersize")
if ctx.Bool("append") {
c.flags = keybase1.OpenFlags_WRITE | keybase1.OpenFlags_APPEND | keybase1.OpenFlags_EXISTING
} else {
c.flags = keybase1.OpenFlags_WRITE | keybase1.OpenFlags_REPLACE
}
if nargs != 1 {
return fmt.Errorf("write requires a path argument")
}
p, err := makeSimpleFSPath(ctx.Args()[0])
if err != nil {
return err
}
c.path = p
return err
} | [
"func",
"(",
"c",
"*",
"CmdSimpleFSWrite",
")",
"ParseArgv",
"(",
"ctx",
"*",
"cli",
".",
"Context",
")",
"error",
"{",
"nargs",
":=",
"len",
"(",
"ctx",
".",
"Args",
"(",
")",
")",
"\n",
"var",
"err",
"error",
"\n\n",
"c",
".",
"bufSize",
"=",
"ctx",
".",
"Int",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"ctx",
".",
"Bool",
"(",
"\"",
"\"",
")",
"{",
"c",
".",
"flags",
"=",
"keybase1",
".",
"OpenFlags_WRITE",
"|",
"keybase1",
".",
"OpenFlags_APPEND",
"|",
"keybase1",
".",
"OpenFlags_EXISTING",
"\n",
"}",
"else",
"{",
"c",
".",
"flags",
"=",
"keybase1",
".",
"OpenFlags_WRITE",
"|",
"keybase1",
".",
"OpenFlags_REPLACE",
"\n",
"}",
"\n\n",
"if",
"nargs",
"!=",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"p",
",",
"err",
":=",
"makeSimpleFSPath",
"(",
"ctx",
".",
"Args",
"(",
")",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"path",
"=",
"p",
"\n",
"return",
"err",
"\n",
"}"
] | // ParseArgv gets the arguments for this command. | [
"ParseArgv",
"gets",
"the",
"arguments",
"for",
"this",
"command",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/client/cmd_simplefs_write.go#L127-L150 |
160,614 | keybase/client | go/libkb/sync_trackers.go | compact | func (t Trackers) compact() (ret Trackers) {
index := make(map[keybase1.UID]int)
ret.Version = t.Version
for _, el := range t.Trackers {
if _, found := index[el.GetUID()]; !found {
index[el.GetUID()] = el.Status
if el.Status == TrackStatusTracking {
ret.Trackers = append(ret.Trackers, el)
}
}
}
return ret
} | go | func (t Trackers) compact() (ret Trackers) {
index := make(map[keybase1.UID]int)
ret.Version = t.Version
for _, el := range t.Trackers {
if _, found := index[el.GetUID()]; !found {
index[el.GetUID()] = el.Status
if el.Status == TrackStatusTracking {
ret.Trackers = append(ret.Trackers, el)
}
}
}
return ret
} | [
"func",
"(",
"t",
"Trackers",
")",
"compact",
"(",
")",
"(",
"ret",
"Trackers",
")",
"{",
"index",
":=",
"make",
"(",
"map",
"[",
"keybase1",
".",
"UID",
"]",
"int",
")",
"\n\n",
"ret",
".",
"Version",
"=",
"t",
".",
"Version",
"\n\n",
"for",
"_",
",",
"el",
":=",
"range",
"t",
".",
"Trackers",
"{",
"if",
"_",
",",
"found",
":=",
"index",
"[",
"el",
".",
"GetUID",
"(",
")",
"]",
";",
"!",
"found",
"{",
"index",
"[",
"el",
".",
"GetUID",
"(",
")",
"]",
"=",
"el",
".",
"Status",
"\n",
"if",
"el",
".",
"Status",
"==",
"TrackStatusTracking",
"{",
"ret",
".",
"Trackers",
"=",
"append",
"(",
"ret",
".",
"Trackers",
",",
"el",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] | // Remove duplicates and "untrack" statements in the list | [
"Remove",
"duplicates",
"and",
"untrack",
"statements",
"in",
"the",
"list"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/sync_trackers.go#L42-L56 |
160,615 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | NewExtraMetadataV3 | func NewExtraMetadataV3(
wkb TLFWriterKeyBundleV3, rkb TLFReaderKeyBundleV3,
wkbNew, rkbNew bool) *ExtraMetadataV3 {
return &ExtraMetadataV3{wkb, rkb, wkbNew, rkbNew}
} | go | func NewExtraMetadataV3(
wkb TLFWriterKeyBundleV3, rkb TLFReaderKeyBundleV3,
wkbNew, rkbNew bool) *ExtraMetadataV3 {
return &ExtraMetadataV3{wkb, rkb, wkbNew, rkbNew}
} | [
"func",
"NewExtraMetadataV3",
"(",
"wkb",
"TLFWriterKeyBundleV3",
",",
"rkb",
"TLFReaderKeyBundleV3",
",",
"wkbNew",
",",
"rkbNew",
"bool",
")",
"*",
"ExtraMetadataV3",
"{",
"return",
"&",
"ExtraMetadataV3",
"{",
"wkb",
",",
"rkb",
",",
"wkbNew",
",",
"rkbNew",
"}",
"\n",
"}"
] | // NewExtraMetadataV3 creates a new ExtraMetadataV3 given a pair of key bundles | [
"NewExtraMetadataV3",
"creates",
"a",
"new",
"ExtraMetadataV3",
"given",
"a",
"pair",
"of",
"key",
"bundles"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L142-L146 |
160,616 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | DeepCopy | func (extra ExtraMetadataV3) DeepCopy(codec kbfscodec.Codec) (
ExtraMetadata, error) {
wkb, err := extra.wkb.DeepCopy(codec)
if err != nil {
return nil, err
}
rkb, err := extra.rkb.DeepCopy(codec)
if err != nil {
return nil, err
}
return NewExtraMetadataV3(wkb, rkb, extra.wkbNew, extra.rkbNew), nil
} | go | func (extra ExtraMetadataV3) DeepCopy(codec kbfscodec.Codec) (
ExtraMetadata, error) {
wkb, err := extra.wkb.DeepCopy(codec)
if err != nil {
return nil, err
}
rkb, err := extra.rkb.DeepCopy(codec)
if err != nil {
return nil, err
}
return NewExtraMetadataV3(wkb, rkb, extra.wkbNew, extra.rkbNew), nil
} | [
"func",
"(",
"extra",
"ExtraMetadataV3",
")",
"DeepCopy",
"(",
"codec",
"kbfscodec",
".",
"Codec",
")",
"(",
"ExtraMetadata",
",",
"error",
")",
"{",
"wkb",
",",
"err",
":=",
"extra",
".",
"wkb",
".",
"DeepCopy",
"(",
"codec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"rkb",
",",
"err",
":=",
"extra",
".",
"rkb",
".",
"DeepCopy",
"(",
"codec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewExtraMetadataV3",
"(",
"wkb",
",",
"rkb",
",",
"extra",
".",
"wkbNew",
",",
"extra",
".",
"rkbNew",
")",
",",
"nil",
"\n",
"}"
] | // DeepCopy implements the ExtraMetadata interface for ExtraMetadataV3. | [
"DeepCopy",
"implements",
"the",
"ExtraMetadata",
"interface",
"for",
"ExtraMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L159-L170 |
160,617 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | MakeSuccessorCopy | func (extra ExtraMetadataV3) MakeSuccessorCopy(codec kbfscodec.Codec) (
ExtraMetadata, error) {
wkb, err := extra.wkb.DeepCopy(codec)
if err != nil {
return nil, err
}
rkb, err := extra.rkb.DeepCopy(codec)
if err != nil {
return nil, err
}
return NewExtraMetadataV3(wkb, rkb, false, false), nil
} | go | func (extra ExtraMetadataV3) MakeSuccessorCopy(codec kbfscodec.Codec) (
ExtraMetadata, error) {
wkb, err := extra.wkb.DeepCopy(codec)
if err != nil {
return nil, err
}
rkb, err := extra.rkb.DeepCopy(codec)
if err != nil {
return nil, err
}
return NewExtraMetadataV3(wkb, rkb, false, false), nil
} | [
"func",
"(",
"extra",
"ExtraMetadataV3",
")",
"MakeSuccessorCopy",
"(",
"codec",
"kbfscodec",
".",
"Codec",
")",
"(",
"ExtraMetadata",
",",
"error",
")",
"{",
"wkb",
",",
"err",
":=",
"extra",
".",
"wkb",
".",
"DeepCopy",
"(",
"codec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"rkb",
",",
"err",
":=",
"extra",
".",
"rkb",
".",
"DeepCopy",
"(",
"codec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewExtraMetadataV3",
"(",
"wkb",
",",
"rkb",
",",
"false",
",",
"false",
")",
",",
"nil",
"\n",
"}"
] | // MakeSuccessorCopy implements the ExtraMetadata interface for ExtraMetadataV3. | [
"MakeSuccessorCopy",
"implements",
"the",
"ExtraMetadata",
"interface",
"for",
"ExtraMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L173-L184 |
160,618 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | KeyGenerationsToUpdate | func (md *RootMetadataV3) KeyGenerationsToUpdate() (KeyGen, KeyGen) {
latest := md.LatestKeyGeneration()
if latest < FirstValidKeyGen {
return 0, 0
}
// We only keep track of the latest key generation in extra.
return latest, latest + 1
} | go | func (md *RootMetadataV3) KeyGenerationsToUpdate() (KeyGen, KeyGen) {
latest := md.LatestKeyGeneration()
if latest < FirstValidKeyGen {
return 0, 0
}
// We only keep track of the latest key generation in extra.
return latest, latest + 1
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"KeyGenerationsToUpdate",
"(",
")",
"(",
"KeyGen",
",",
"KeyGen",
")",
"{",
"latest",
":=",
"md",
".",
"LatestKeyGeneration",
"(",
")",
"\n",
"if",
"latest",
"<",
"FirstValidKeyGen",
"{",
"return",
"0",
",",
"0",
"\n",
"}",
"\n",
"// We only keep track of the latest key generation in extra.",
"return",
"latest",
",",
"latest",
"+",
"1",
"\n",
"}"
] | // KeyGenerationsToUpdate implements the RootMetadata interface
// for RootMetadataV3. | [
"KeyGenerationsToUpdate",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L265-L272 |
160,619 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | IsValidRekeyRequest | func (md *RootMetadataV3) IsValidRekeyRequest(
codec kbfscodec.Codec, prevBareMd RootMetadata,
user keybase1.UID, prevExtra, extra ExtraMetadata) (
bool, error) {
if !md.IsWriterMetadataCopiedSet() {
// Not a copy.
return false, nil
}
prevMd, ok := prevBareMd.(*RootMetadataV3)
if !ok {
// Not the same type so not a copy.
return false, nil
}
prevExtraV3, ok := prevExtra.(*ExtraMetadataV3)
if !ok {
return false, errors.New("Invalid previous extra metadata")
}
extraV3, ok := extra.(*ExtraMetadataV3)
if !ok {
return false, errors.New("Invalid extra metadata")
}
writerEqual, err := kbfscodec.Equal(
codec, md.WriterMetadata, prevMd.WriterMetadata)
if err != nil {
return false, err
}
if !writerEqual {
// Copy mismatch.
return false, nil
}
onlyUserRKeysChanged, err := md.haveOnlyUserRKeysChanged(
codec, prevMd, user, prevExtraV3.rkb, extraV3.rkb)
if err != nil {
return false, err
}
if !onlyUserRKeysChanged {
// Keys outside of this user's reader key set have changed.
return false, nil
}
return true, nil
} | go | func (md *RootMetadataV3) IsValidRekeyRequest(
codec kbfscodec.Codec, prevBareMd RootMetadata,
user keybase1.UID, prevExtra, extra ExtraMetadata) (
bool, error) {
if !md.IsWriterMetadataCopiedSet() {
// Not a copy.
return false, nil
}
prevMd, ok := prevBareMd.(*RootMetadataV3)
if !ok {
// Not the same type so not a copy.
return false, nil
}
prevExtraV3, ok := prevExtra.(*ExtraMetadataV3)
if !ok {
return false, errors.New("Invalid previous extra metadata")
}
extraV3, ok := extra.(*ExtraMetadataV3)
if !ok {
return false, errors.New("Invalid extra metadata")
}
writerEqual, err := kbfscodec.Equal(
codec, md.WriterMetadata, prevMd.WriterMetadata)
if err != nil {
return false, err
}
if !writerEqual {
// Copy mismatch.
return false, nil
}
onlyUserRKeysChanged, err := md.haveOnlyUserRKeysChanged(
codec, prevMd, user, prevExtraV3.rkb, extraV3.rkb)
if err != nil {
return false, err
}
if !onlyUserRKeysChanged {
// Keys outside of this user's reader key set have changed.
return false, nil
}
return true, nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"IsValidRekeyRequest",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"prevBareMd",
"RootMetadata",
",",
"user",
"keybase1",
".",
"UID",
",",
"prevExtra",
",",
"extra",
"ExtraMetadata",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"!",
"md",
".",
"IsWriterMetadataCopiedSet",
"(",
")",
"{",
"// Not a copy.",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"prevMd",
",",
"ok",
":=",
"prevBareMd",
".",
"(",
"*",
"RootMetadataV3",
")",
"\n",
"if",
"!",
"ok",
"{",
"// Not the same type so not a copy.",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"prevExtraV3",
",",
"ok",
":=",
"prevExtra",
".",
"(",
"*",
"ExtraMetadataV3",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"extraV3",
",",
"ok",
":=",
"extra",
".",
"(",
"*",
"ExtraMetadataV3",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"writerEqual",
",",
"err",
":=",
"kbfscodec",
".",
"Equal",
"(",
"codec",
",",
"md",
".",
"WriterMetadata",
",",
"prevMd",
".",
"WriterMetadata",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"writerEqual",
"{",
"// Copy mismatch.",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"onlyUserRKeysChanged",
",",
"err",
":=",
"md",
".",
"haveOnlyUserRKeysChanged",
"(",
"codec",
",",
"prevMd",
",",
"user",
",",
"prevExtraV3",
".",
"rkb",
",",
"extraV3",
".",
"rkb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"onlyUserRKeysChanged",
"{",
"// Keys outside of this user's reader key set have changed.",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // IsValidRekeyRequest implements the RootMetadata interface for RootMetadataV3. | [
"IsValidRekeyRequest",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L305-L345 |
160,620 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | MergedStatus | func (md *RootMetadataV3) MergedStatus() MergeStatus {
if md.WriterMetadata.WFlags&MetadataFlagUnmerged != 0 {
return Unmerged
}
return Merged
} | go | func (md *RootMetadataV3) MergedStatus() MergeStatus {
if md.WriterMetadata.WFlags&MetadataFlagUnmerged != 0 {
return Unmerged
}
return Merged
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"MergedStatus",
"(",
")",
"MergeStatus",
"{",
"if",
"md",
".",
"WriterMetadata",
".",
"WFlags",
"&",
"MetadataFlagUnmerged",
"!=",
"0",
"{",
"return",
"Unmerged",
"\n",
"}",
"\n",
"return",
"Merged",
"\n",
"}"
] | // MergedStatus implements the RootMetadata interface for RootMetadataV3. | [
"MergedStatus",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L348-L353 |
160,621 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | IsWriter | func (md *RootMetadataV3) IsWriter(
ctx context.Context, user keybase1.UID,
cryptKey kbfscrypto.CryptPublicKey, verifyingKey kbfscrypto.VerifyingKey,
teamMemChecker TeamMembershipChecker, extra ExtraMetadata,
offline keybase1.OfflineAvailability) (bool, error) {
switch md.TypeForKeying() {
case tlf.TeamKeying:
err := md.checkNonPrivateExtra(extra)
if err != nil {
return false, err
}
tid, err := md.WriterMetadata.Writers[0].AsTeam()
if err != nil {
return false, err
}
// TODO: Eventually this will have to use a Merkle sequence
// number to check historic versions.
isWriter, err := teamMemChecker.IsTeamWriter(
ctx, tid, user, verifyingKey, offline)
if err != nil {
return false, err
}
return isWriter, nil
default:
return md.isNonTeamWriter(ctx, user, cryptKey, extra)
}
} | go | func (md *RootMetadataV3) IsWriter(
ctx context.Context, user keybase1.UID,
cryptKey kbfscrypto.CryptPublicKey, verifyingKey kbfscrypto.VerifyingKey,
teamMemChecker TeamMembershipChecker, extra ExtraMetadata,
offline keybase1.OfflineAvailability) (bool, error) {
switch md.TypeForKeying() {
case tlf.TeamKeying:
err := md.checkNonPrivateExtra(extra)
if err != nil {
return false, err
}
tid, err := md.WriterMetadata.Writers[0].AsTeam()
if err != nil {
return false, err
}
// TODO: Eventually this will have to use a Merkle sequence
// number to check historic versions.
isWriter, err := teamMemChecker.IsTeamWriter(
ctx, tid, user, verifyingKey, offline)
if err != nil {
return false, err
}
return isWriter, nil
default:
return md.isNonTeamWriter(ctx, user, cryptKey, extra)
}
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"IsWriter",
"(",
"ctx",
"context",
".",
"Context",
",",
"user",
"keybase1",
".",
"UID",
",",
"cryptKey",
"kbfscrypto",
".",
"CryptPublicKey",
",",
"verifyingKey",
"kbfscrypto",
".",
"VerifyingKey",
",",
"teamMemChecker",
"TeamMembershipChecker",
",",
"extra",
"ExtraMetadata",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"bool",
",",
"error",
")",
"{",
"switch",
"md",
".",
"TypeForKeying",
"(",
")",
"{",
"case",
"tlf",
".",
"TeamKeying",
":",
"err",
":=",
"md",
".",
"checkNonPrivateExtra",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"tid",
",",
"err",
":=",
"md",
".",
"WriterMetadata",
".",
"Writers",
"[",
"0",
"]",
".",
"AsTeam",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"// TODO: Eventually this will have to use a Merkle sequence",
"// number to check historic versions.",
"isWriter",
",",
"err",
":=",
"teamMemChecker",
".",
"IsTeamWriter",
"(",
"ctx",
",",
"tid",
",",
"user",
",",
"verifyingKey",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"isWriter",
",",
"nil",
"\n",
"default",
":",
"return",
"md",
".",
"isNonTeamWriter",
"(",
"ctx",
",",
"user",
",",
"cryptKey",
",",
"extra",
")",
"\n",
"}",
"\n",
"}"
] | // IsWriter implements the RootMetadata interface for RootMetadataV3. | [
"IsWriter",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L438-L466 |
160,622 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | IsReader | func (md *RootMetadataV3) IsReader(
ctx context.Context, user keybase1.UID,
cryptKey kbfscrypto.CryptPublicKey, teamMemChecker TeamMembershipChecker,
extra ExtraMetadata, offline keybase1.OfflineAvailability) (bool, error) {
switch md.TypeForKeying() {
case tlf.PublicKeying:
err := md.checkNonPrivateExtra(extra)
if err != nil {
return false, err
}
return true, nil
case tlf.PrivateKeying:
// Writers are also readers.
isWriter, err := md.isNonTeamWriter(ctx, user, cryptKey, extra)
if err != nil {
return false, err
}
if isWriter {
return true, nil
}
_, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return false, err
}
return rkb.IsReader(user, cryptKey), nil
case tlf.TeamKeying:
err := md.checkNonPrivateExtra(extra)
if err != nil {
return false, err
}
tid, err := md.WriterMetadata.Writers[0].AsTeam()
if err != nil {
return false, err
}
if tid.IsPublic() {
return true, nil
}
// TODO: Eventually this will have to use a Merkle sequence
// number to check historic versions.
isReader, err := teamMemChecker.IsTeamReader(ctx, tid, user, offline)
if err != nil {
return false, err
}
return isReader, nil
default:
panic(fmt.Sprintf("Unknown TLF keying type: %s", md.TypeForKeying()))
}
} | go | func (md *RootMetadataV3) IsReader(
ctx context.Context, user keybase1.UID,
cryptKey kbfscrypto.CryptPublicKey, teamMemChecker TeamMembershipChecker,
extra ExtraMetadata, offline keybase1.OfflineAvailability) (bool, error) {
switch md.TypeForKeying() {
case tlf.PublicKeying:
err := md.checkNonPrivateExtra(extra)
if err != nil {
return false, err
}
return true, nil
case tlf.PrivateKeying:
// Writers are also readers.
isWriter, err := md.isNonTeamWriter(ctx, user, cryptKey, extra)
if err != nil {
return false, err
}
if isWriter {
return true, nil
}
_, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return false, err
}
return rkb.IsReader(user, cryptKey), nil
case tlf.TeamKeying:
err := md.checkNonPrivateExtra(extra)
if err != nil {
return false, err
}
tid, err := md.WriterMetadata.Writers[0].AsTeam()
if err != nil {
return false, err
}
if tid.IsPublic() {
return true, nil
}
// TODO: Eventually this will have to use a Merkle sequence
// number to check historic versions.
isReader, err := teamMemChecker.IsTeamReader(ctx, tid, user, offline)
if err != nil {
return false, err
}
return isReader, nil
default:
panic(fmt.Sprintf("Unknown TLF keying type: %s", md.TypeForKeying()))
}
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"IsReader",
"(",
"ctx",
"context",
".",
"Context",
",",
"user",
"keybase1",
".",
"UID",
",",
"cryptKey",
"kbfscrypto",
".",
"CryptPublicKey",
",",
"teamMemChecker",
"TeamMembershipChecker",
",",
"extra",
"ExtraMetadata",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"bool",
",",
"error",
")",
"{",
"switch",
"md",
".",
"TypeForKeying",
"(",
")",
"{",
"case",
"tlf",
".",
"PublicKeying",
":",
"err",
":=",
"md",
".",
"checkNonPrivateExtra",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"true",
",",
"nil",
"\n",
"case",
"tlf",
".",
"PrivateKeying",
":",
"// Writers are also readers.",
"isWriter",
",",
"err",
":=",
"md",
".",
"isNonTeamWriter",
"(",
"ctx",
",",
"user",
",",
"cryptKey",
",",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"isWriter",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"_",
",",
"rkb",
",",
"err",
":=",
"md",
".",
"getTLFKeyBundles",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"rkb",
".",
"IsReader",
"(",
"user",
",",
"cryptKey",
")",
",",
"nil",
"\n",
"case",
"tlf",
".",
"TeamKeying",
":",
"err",
":=",
"md",
".",
"checkNonPrivateExtra",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"tid",
",",
"err",
":=",
"md",
".",
"WriterMetadata",
".",
"Writers",
"[",
"0",
"]",
".",
"AsTeam",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"tid",
".",
"IsPublic",
"(",
")",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"// TODO: Eventually this will have to use a Merkle sequence",
"// number to check historic versions.",
"isReader",
",",
"err",
":=",
"teamMemChecker",
".",
"IsTeamReader",
"(",
"ctx",
",",
"tid",
",",
"user",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"isReader",
",",
"nil",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"md",
".",
"TypeForKeying",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"}"
] | // IsReader implements the RootMetadata interface for RootMetadataV3. | [
"IsReader",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L469-L520 |
160,623 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | DeepCopy | func (md *RootMetadataV3) DeepCopy(
codec kbfscodec.Codec) (MutableRootMetadata, error) {
var newMd RootMetadataV3
if err := kbfscodec.Update(codec, &newMd, md); err != nil {
return nil, err
}
return &newMd, nil
} | go | func (md *RootMetadataV3) DeepCopy(
codec kbfscodec.Codec) (MutableRootMetadata, error) {
var newMd RootMetadataV3
if err := kbfscodec.Update(codec, &newMd, md); err != nil {
return nil, err
}
return &newMd, nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"DeepCopy",
"(",
"codec",
"kbfscodec",
".",
"Codec",
")",
"(",
"MutableRootMetadata",
",",
"error",
")",
"{",
"var",
"newMd",
"RootMetadataV3",
"\n",
"if",
"err",
":=",
"kbfscodec",
".",
"Update",
"(",
"codec",
",",
"&",
"newMd",
",",
"md",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"newMd",
",",
"nil",
"\n",
"}"
] | // DeepCopy implements the RootMetadata interface for RootMetadataV3. | [
"DeepCopy",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L523-L530 |
160,624 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | MakeSuccessorCopy | func (md *RootMetadataV3) MakeSuccessorCopy(
codec kbfscodec.Codec, extra ExtraMetadata, _ MetadataVer,
_ func() ([]kbfscrypto.TLFCryptKey, error), isReadableAndWriter bool) (
MutableRootMetadata, ExtraMetadata, error) {
var extraCopy ExtraMetadata
if extra != nil {
var err error
extraCopy, err = extra.MakeSuccessorCopy(codec)
if err != nil {
return nil, nil, err
}
}
mdCopy, err := md.DeepCopy(codec)
if err != nil {
return nil, nil, err
}
// TODO: If there is ever a RootMetadataV4 this will need to perform the conversion.
return mdCopy, extraCopy, nil
} | go | func (md *RootMetadataV3) MakeSuccessorCopy(
codec kbfscodec.Codec, extra ExtraMetadata, _ MetadataVer,
_ func() ([]kbfscrypto.TLFCryptKey, error), isReadableAndWriter bool) (
MutableRootMetadata, ExtraMetadata, error) {
var extraCopy ExtraMetadata
if extra != nil {
var err error
extraCopy, err = extra.MakeSuccessorCopy(codec)
if err != nil {
return nil, nil, err
}
}
mdCopy, err := md.DeepCopy(codec)
if err != nil {
return nil, nil, err
}
// TODO: If there is ever a RootMetadataV4 this will need to perform the conversion.
return mdCopy, extraCopy, nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"MakeSuccessorCopy",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"extra",
"ExtraMetadata",
",",
"_",
"MetadataVer",
",",
"_",
"func",
"(",
")",
"(",
"[",
"]",
"kbfscrypto",
".",
"TLFCryptKey",
",",
"error",
")",
",",
"isReadableAndWriter",
"bool",
")",
"(",
"MutableRootMetadata",
",",
"ExtraMetadata",
",",
"error",
")",
"{",
"var",
"extraCopy",
"ExtraMetadata",
"\n",
"if",
"extra",
"!=",
"nil",
"{",
"var",
"err",
"error",
"\n",
"extraCopy",
",",
"err",
"=",
"extra",
".",
"MakeSuccessorCopy",
"(",
"codec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"mdCopy",
",",
"err",
":=",
"md",
".",
"DeepCopy",
"(",
"codec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// TODO: If there is ever a RootMetadataV4 this will need to perform the conversion.",
"return",
"mdCopy",
",",
"extraCopy",
",",
"nil",
"\n",
"}"
] | // MakeSuccessorCopy implements the ImmutableRootMetadata interface for RootMetadataV3. | [
"MakeSuccessorCopy",
"implements",
"the",
"ImmutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L533-L551 |
160,625 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | CheckValidSuccessor | func (md *RootMetadataV3) CheckValidSuccessor(
currID ID, nextMd RootMetadata) error {
// (1) Verify current metadata is non-final.
if md.IsFinal() {
return MetadataIsFinalError{}
}
// (2) Check TLF ID.
if nextMd.TlfID() != md.TlfID() {
return MDTlfIDMismatch{
CurrID: md.TlfID(),
NextID: nextMd.TlfID(),
}
}
// (3) Check revision.
if nextMd.RevisionNumber() != md.RevisionNumber()+1 {
return MDRevisionMismatch{
Rev: nextMd.RevisionNumber(),
Curr: md.RevisionNumber(),
}
}
// (4) Check PrevRoot pointer.
expectedPrevRoot := currID
if nextMd.IsFinal() {
expectedPrevRoot = md.GetPrevRoot()
}
if nextMd.GetPrevRoot() != expectedPrevRoot {
return MDPrevRootMismatch{
prevRoot: nextMd.GetPrevRoot(),
expectedPrevRoot: expectedPrevRoot,
}
}
// (5) Check branch ID.
if md.MergedStatus() == nextMd.MergedStatus() && md.BID() != nextMd.BID() {
return errors.Errorf("Unexpected branch ID on successor: %s vs. %s",
md.BID(), nextMd.BID())
} else if md.MergedStatus() == Unmerged && nextMd.MergedStatus() == Merged {
return errors.New("merged MD can't follow unmerged MD")
}
// (6) Check disk usage.
expectedUsage := md.DiskUsage()
if !nextMd.IsWriterMetadataCopiedSet() {
expectedUsage += nextMd.RefBytes() - nextMd.UnrefBytes()
}
if nextMd.DiskUsage() != expectedUsage {
return MDDiskUsageMismatch{
expectedDiskUsage: expectedUsage,
actualDiskUsage: nextMd.DiskUsage(),
}
}
expectedMDUsage := md.MDDiskUsage()
if !nextMd.IsWriterMetadataCopiedSet() {
expectedMDUsage += nextMd.MDRefBytes()
}
// Add an exception for the case where MDRefBytes is equal, since
// it probably indicates an older client just copied the previous
// MDRefBytes value as an unknown field.
if nextMd.MDDiskUsage() != expectedMDUsage &&
md.MDRefBytes() != nextMd.MDRefBytes() {
return MDDiskUsageMismatch{
expectedDiskUsage: expectedMDUsage,
actualDiskUsage: nextMd.MDDiskUsage(),
}
}
// TODO: Check that the successor (bare) TLF handle is the
// same or more resolved.
return nil
} | go | func (md *RootMetadataV3) CheckValidSuccessor(
currID ID, nextMd RootMetadata) error {
// (1) Verify current metadata is non-final.
if md.IsFinal() {
return MetadataIsFinalError{}
}
// (2) Check TLF ID.
if nextMd.TlfID() != md.TlfID() {
return MDTlfIDMismatch{
CurrID: md.TlfID(),
NextID: nextMd.TlfID(),
}
}
// (3) Check revision.
if nextMd.RevisionNumber() != md.RevisionNumber()+1 {
return MDRevisionMismatch{
Rev: nextMd.RevisionNumber(),
Curr: md.RevisionNumber(),
}
}
// (4) Check PrevRoot pointer.
expectedPrevRoot := currID
if nextMd.IsFinal() {
expectedPrevRoot = md.GetPrevRoot()
}
if nextMd.GetPrevRoot() != expectedPrevRoot {
return MDPrevRootMismatch{
prevRoot: nextMd.GetPrevRoot(),
expectedPrevRoot: expectedPrevRoot,
}
}
// (5) Check branch ID.
if md.MergedStatus() == nextMd.MergedStatus() && md.BID() != nextMd.BID() {
return errors.Errorf("Unexpected branch ID on successor: %s vs. %s",
md.BID(), nextMd.BID())
} else if md.MergedStatus() == Unmerged && nextMd.MergedStatus() == Merged {
return errors.New("merged MD can't follow unmerged MD")
}
// (6) Check disk usage.
expectedUsage := md.DiskUsage()
if !nextMd.IsWriterMetadataCopiedSet() {
expectedUsage += nextMd.RefBytes() - nextMd.UnrefBytes()
}
if nextMd.DiskUsage() != expectedUsage {
return MDDiskUsageMismatch{
expectedDiskUsage: expectedUsage,
actualDiskUsage: nextMd.DiskUsage(),
}
}
expectedMDUsage := md.MDDiskUsage()
if !nextMd.IsWriterMetadataCopiedSet() {
expectedMDUsage += nextMd.MDRefBytes()
}
// Add an exception for the case where MDRefBytes is equal, since
// it probably indicates an older client just copied the previous
// MDRefBytes value as an unknown field.
if nextMd.MDDiskUsage() != expectedMDUsage &&
md.MDRefBytes() != nextMd.MDRefBytes() {
return MDDiskUsageMismatch{
expectedDiskUsage: expectedMDUsage,
actualDiskUsage: nextMd.MDDiskUsage(),
}
}
// TODO: Check that the successor (bare) TLF handle is the
// same or more resolved.
return nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"CheckValidSuccessor",
"(",
"currID",
"ID",
",",
"nextMd",
"RootMetadata",
")",
"error",
"{",
"// (1) Verify current metadata is non-final.",
"if",
"md",
".",
"IsFinal",
"(",
")",
"{",
"return",
"MetadataIsFinalError",
"{",
"}",
"\n",
"}",
"\n\n",
"// (2) Check TLF ID.",
"if",
"nextMd",
".",
"TlfID",
"(",
")",
"!=",
"md",
".",
"TlfID",
"(",
")",
"{",
"return",
"MDTlfIDMismatch",
"{",
"CurrID",
":",
"md",
".",
"TlfID",
"(",
")",
",",
"NextID",
":",
"nextMd",
".",
"TlfID",
"(",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// (3) Check revision.",
"if",
"nextMd",
".",
"RevisionNumber",
"(",
")",
"!=",
"md",
".",
"RevisionNumber",
"(",
")",
"+",
"1",
"{",
"return",
"MDRevisionMismatch",
"{",
"Rev",
":",
"nextMd",
".",
"RevisionNumber",
"(",
")",
",",
"Curr",
":",
"md",
".",
"RevisionNumber",
"(",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// (4) Check PrevRoot pointer.",
"expectedPrevRoot",
":=",
"currID",
"\n",
"if",
"nextMd",
".",
"IsFinal",
"(",
")",
"{",
"expectedPrevRoot",
"=",
"md",
".",
"GetPrevRoot",
"(",
")",
"\n",
"}",
"\n",
"if",
"nextMd",
".",
"GetPrevRoot",
"(",
")",
"!=",
"expectedPrevRoot",
"{",
"return",
"MDPrevRootMismatch",
"{",
"prevRoot",
":",
"nextMd",
".",
"GetPrevRoot",
"(",
")",
",",
"expectedPrevRoot",
":",
"expectedPrevRoot",
",",
"}",
"\n",
"}",
"\n\n",
"// (5) Check branch ID.",
"if",
"md",
".",
"MergedStatus",
"(",
")",
"==",
"nextMd",
".",
"MergedStatus",
"(",
")",
"&&",
"md",
".",
"BID",
"(",
")",
"!=",
"nextMd",
".",
"BID",
"(",
")",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"md",
".",
"BID",
"(",
")",
",",
"nextMd",
".",
"BID",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"md",
".",
"MergedStatus",
"(",
")",
"==",
"Unmerged",
"&&",
"nextMd",
".",
"MergedStatus",
"(",
")",
"==",
"Merged",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// (6) Check disk usage.",
"expectedUsage",
":=",
"md",
".",
"DiskUsage",
"(",
")",
"\n",
"if",
"!",
"nextMd",
".",
"IsWriterMetadataCopiedSet",
"(",
")",
"{",
"expectedUsage",
"+=",
"nextMd",
".",
"RefBytes",
"(",
")",
"-",
"nextMd",
".",
"UnrefBytes",
"(",
")",
"\n",
"}",
"\n",
"if",
"nextMd",
".",
"DiskUsage",
"(",
")",
"!=",
"expectedUsage",
"{",
"return",
"MDDiskUsageMismatch",
"{",
"expectedDiskUsage",
":",
"expectedUsage",
",",
"actualDiskUsage",
":",
"nextMd",
".",
"DiskUsage",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"expectedMDUsage",
":=",
"md",
".",
"MDDiskUsage",
"(",
")",
"\n",
"if",
"!",
"nextMd",
".",
"IsWriterMetadataCopiedSet",
"(",
")",
"{",
"expectedMDUsage",
"+=",
"nextMd",
".",
"MDRefBytes",
"(",
")",
"\n",
"}",
"\n",
"// Add an exception for the case where MDRefBytes is equal, since",
"// it probably indicates an older client just copied the previous",
"// MDRefBytes value as an unknown field.",
"if",
"nextMd",
".",
"MDDiskUsage",
"(",
")",
"!=",
"expectedMDUsage",
"&&",
"md",
".",
"MDRefBytes",
"(",
")",
"!=",
"nextMd",
".",
"MDRefBytes",
"(",
")",
"{",
"return",
"MDDiskUsageMismatch",
"{",
"expectedDiskUsage",
":",
"expectedMDUsage",
",",
"actualDiskUsage",
":",
"nextMd",
".",
"MDDiskUsage",
"(",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// TODO: Check that the successor (bare) TLF handle is the",
"// same or more resolved.",
"return",
"nil",
"\n",
"}"
] | // CheckValidSuccessor implements the RootMetadata interface for RootMetadataV3. | [
"CheckValidSuccessor",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L554-L627 |
160,626 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | CheckValidSuccessorForServer | func (md *RootMetadataV3) CheckValidSuccessorForServer(
currID ID, nextMd RootMetadata) error {
err := md.CheckValidSuccessor(currID, nextMd)
switch err := err.(type) {
case nil:
break
case MDRevisionMismatch:
return ServerErrorConflictRevision{
Expected: err.Curr + 1,
Actual: err.Rev,
}
case MDPrevRootMismatch:
return ServerErrorConflictPrevRoot{
Expected: err.expectedPrevRoot,
Actual: err.prevRoot,
}
case MDDiskUsageMismatch:
return ServerErrorConflictDiskUsage{
Expected: err.expectedDiskUsage,
Actual: err.actualDiskUsage,
}
default:
return ServerError{Err: err}
}
return nil
} | go | func (md *RootMetadataV3) CheckValidSuccessorForServer(
currID ID, nextMd RootMetadata) error {
err := md.CheckValidSuccessor(currID, nextMd)
switch err := err.(type) {
case nil:
break
case MDRevisionMismatch:
return ServerErrorConflictRevision{
Expected: err.Curr + 1,
Actual: err.Rev,
}
case MDPrevRootMismatch:
return ServerErrorConflictPrevRoot{
Expected: err.expectedPrevRoot,
Actual: err.prevRoot,
}
case MDDiskUsageMismatch:
return ServerErrorConflictDiskUsage{
Expected: err.expectedDiskUsage,
Actual: err.actualDiskUsage,
}
default:
return ServerError{Err: err}
}
return nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"CheckValidSuccessorForServer",
"(",
"currID",
"ID",
",",
"nextMd",
"RootMetadata",
")",
"error",
"{",
"err",
":=",
"md",
".",
"CheckValidSuccessor",
"(",
"currID",
",",
"nextMd",
")",
"\n",
"switch",
"err",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"nil",
":",
"break",
"\n\n",
"case",
"MDRevisionMismatch",
":",
"return",
"ServerErrorConflictRevision",
"{",
"Expected",
":",
"err",
".",
"Curr",
"+",
"1",
",",
"Actual",
":",
"err",
".",
"Rev",
",",
"}",
"\n\n",
"case",
"MDPrevRootMismatch",
":",
"return",
"ServerErrorConflictPrevRoot",
"{",
"Expected",
":",
"err",
".",
"expectedPrevRoot",
",",
"Actual",
":",
"err",
".",
"prevRoot",
",",
"}",
"\n\n",
"case",
"MDDiskUsageMismatch",
":",
"return",
"ServerErrorConflictDiskUsage",
"{",
"Expected",
":",
"err",
".",
"expectedDiskUsage",
",",
"Actual",
":",
"err",
".",
"actualDiskUsage",
",",
"}",
"\n\n",
"default",
":",
"return",
"ServerError",
"{",
"Err",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CheckValidSuccessorForServer implements the RootMetadata interface for RootMetadataV3. | [
"CheckValidSuccessorForServer",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L630-L660 |
160,627 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | TypeForKeying | func (md *RootMetadataV3) TypeForKeying() tlf.KeyingType {
if md.isBackedByTeam() {
return tlf.TeamKeying
}
return md.TlfID().Type().ToKeyingType()
} | go | func (md *RootMetadataV3) TypeForKeying() tlf.KeyingType {
if md.isBackedByTeam() {
return tlf.TeamKeying
}
return md.TlfID().Type().ToKeyingType()
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"TypeForKeying",
"(",
")",
"tlf",
".",
"KeyingType",
"{",
"if",
"md",
".",
"isBackedByTeam",
"(",
")",
"{",
"return",
"tlf",
".",
"TeamKeying",
"\n",
"}",
"\n",
"return",
"md",
".",
"TlfID",
"(",
")",
".",
"Type",
"(",
")",
".",
"ToKeyingType",
"(",
")",
"\n",
"}"
] | // TypeForKeying implements the RootMetadata interface for RootMetadataV3. | [
"TypeForKeying",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L678-L683 |
160,628 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | MakeBareTlfHandle | func (md *RootMetadataV3) MakeBareTlfHandle(extra ExtraMetadata) (
tlf.Handle, error) {
var writers, readers []keybase1.UserOrTeamID
if md.TypeForKeying() == tlf.PrivateKeying {
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return tlf.Handle{}, err
}
writers = make([]keybase1.UserOrTeamID, 0, len(wkb.Keys))
readers = make([]keybase1.UserOrTeamID, 0, len(rkb.Keys))
for w := range wkb.Keys {
writers = append(writers, w.AsUserOrTeam())
}
for r := range rkb.Keys {
// TODO: Return an error instead if r is
// PublicUID. Maybe return an error if r is in
// WKeys also. Or do all this in
// MakeBareTlfHandle.
if _, ok := wkb.Keys[r]; !ok &&
r != keybase1.PublicUID {
readers = append(readers, r.AsUserOrTeam())
}
}
} else {
err := md.checkNonPrivateExtra(extra)
if err != nil {
return tlf.Handle{}, err
}
writers = md.WriterMetadata.Writers
if md.TypeForKeying() == tlf.PublicKeying {
readers = []keybase1.UserOrTeamID{keybase1.PublicUID.AsUserOrTeam()}
}
}
return tlf.MakeHandle(
writers, readers,
md.WriterMetadata.UnresolvedWriters, md.UnresolvedReaders,
md.TlfHandleExtensions())
} | go | func (md *RootMetadataV3) MakeBareTlfHandle(extra ExtraMetadata) (
tlf.Handle, error) {
var writers, readers []keybase1.UserOrTeamID
if md.TypeForKeying() == tlf.PrivateKeying {
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return tlf.Handle{}, err
}
writers = make([]keybase1.UserOrTeamID, 0, len(wkb.Keys))
readers = make([]keybase1.UserOrTeamID, 0, len(rkb.Keys))
for w := range wkb.Keys {
writers = append(writers, w.AsUserOrTeam())
}
for r := range rkb.Keys {
// TODO: Return an error instead if r is
// PublicUID. Maybe return an error if r is in
// WKeys also. Or do all this in
// MakeBareTlfHandle.
if _, ok := wkb.Keys[r]; !ok &&
r != keybase1.PublicUID {
readers = append(readers, r.AsUserOrTeam())
}
}
} else {
err := md.checkNonPrivateExtra(extra)
if err != nil {
return tlf.Handle{}, err
}
writers = md.WriterMetadata.Writers
if md.TypeForKeying() == tlf.PublicKeying {
readers = []keybase1.UserOrTeamID{keybase1.PublicUID.AsUserOrTeam()}
}
}
return tlf.MakeHandle(
writers, readers,
md.WriterMetadata.UnresolvedWriters, md.UnresolvedReaders,
md.TlfHandleExtensions())
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"MakeBareTlfHandle",
"(",
"extra",
"ExtraMetadata",
")",
"(",
"tlf",
".",
"Handle",
",",
"error",
")",
"{",
"var",
"writers",
",",
"readers",
"[",
"]",
"keybase1",
".",
"UserOrTeamID",
"\n",
"if",
"md",
".",
"TypeForKeying",
"(",
")",
"==",
"tlf",
".",
"PrivateKeying",
"{",
"wkb",
",",
"rkb",
",",
"err",
":=",
"md",
".",
"getTLFKeyBundles",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tlf",
".",
"Handle",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"writers",
"=",
"make",
"(",
"[",
"]",
"keybase1",
".",
"UserOrTeamID",
",",
"0",
",",
"len",
"(",
"wkb",
".",
"Keys",
")",
")",
"\n",
"readers",
"=",
"make",
"(",
"[",
"]",
"keybase1",
".",
"UserOrTeamID",
",",
"0",
",",
"len",
"(",
"rkb",
".",
"Keys",
")",
")",
"\n",
"for",
"w",
":=",
"range",
"wkb",
".",
"Keys",
"{",
"writers",
"=",
"append",
"(",
"writers",
",",
"w",
".",
"AsUserOrTeam",
"(",
")",
")",
"\n",
"}",
"\n",
"for",
"r",
":=",
"range",
"rkb",
".",
"Keys",
"{",
"// TODO: Return an error instead if r is",
"// PublicUID. Maybe return an error if r is in",
"// WKeys also. Or do all this in",
"// MakeBareTlfHandle.",
"if",
"_",
",",
"ok",
":=",
"wkb",
".",
"Keys",
"[",
"r",
"]",
";",
"!",
"ok",
"&&",
"r",
"!=",
"keybase1",
".",
"PublicUID",
"{",
"readers",
"=",
"append",
"(",
"readers",
",",
"r",
".",
"AsUserOrTeam",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err",
":=",
"md",
".",
"checkNonPrivateExtra",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tlf",
".",
"Handle",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"writers",
"=",
"md",
".",
"WriterMetadata",
".",
"Writers",
"\n",
"if",
"md",
".",
"TypeForKeying",
"(",
")",
"==",
"tlf",
".",
"PublicKeying",
"{",
"readers",
"=",
"[",
"]",
"keybase1",
".",
"UserOrTeamID",
"{",
"keybase1",
".",
"PublicUID",
".",
"AsUserOrTeam",
"(",
")",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"tlf",
".",
"MakeHandle",
"(",
"writers",
",",
"readers",
",",
"md",
".",
"WriterMetadata",
".",
"UnresolvedWriters",
",",
"md",
".",
"UnresolvedReaders",
",",
"md",
".",
"TlfHandleExtensions",
"(",
")",
")",
"\n",
"}"
] | // MakeBareTlfHandle implements the RootMetadata interface for RootMetadataV3. | [
"MakeBareTlfHandle",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L686-L725 |
160,629 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | PromoteReaders | func (md *RootMetadataV3) PromoteReaders(
readersToPromote map[keybase1.UID]bool, extra ExtraMetadata) error {
if md.TypeForKeying() != tlf.PrivateKeying {
return InvalidNonPrivateTLFOperation{md.TlfID(), "PromoteReaders", md.Version()}
}
if len(readersToPromote) == 0 {
return nil
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return err
}
for reader := range readersToPromote {
dkim, ok := rkb.Keys[reader]
if !ok {
return errors.Errorf("Could not find %s in rkb", reader)
}
// TODO: This is incorrect, since dkim contains offsets info
// rkb.TLFEphemeralPublicKeys, which don't directly translate
// to offsets into wkb.TLFEphemeralPublicKeys.
//
// Also, doing this may leave some entries in
// rkb.TLFEphemeralPublicKeys unreferenced, so they should be
// removed.
//
// See KBFS-1719.
wkb.Keys[reader] = dkim
delete(rkb.Keys, reader)
}
return nil
} | go | func (md *RootMetadataV3) PromoteReaders(
readersToPromote map[keybase1.UID]bool, extra ExtraMetadata) error {
if md.TypeForKeying() != tlf.PrivateKeying {
return InvalidNonPrivateTLFOperation{md.TlfID(), "PromoteReaders", md.Version()}
}
if len(readersToPromote) == 0 {
return nil
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return err
}
for reader := range readersToPromote {
dkim, ok := rkb.Keys[reader]
if !ok {
return errors.Errorf("Could not find %s in rkb", reader)
}
// TODO: This is incorrect, since dkim contains offsets info
// rkb.TLFEphemeralPublicKeys, which don't directly translate
// to offsets into wkb.TLFEphemeralPublicKeys.
//
// Also, doing this may leave some entries in
// rkb.TLFEphemeralPublicKeys unreferenced, so they should be
// removed.
//
// See KBFS-1719.
wkb.Keys[reader] = dkim
delete(rkb.Keys, reader)
}
return nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"PromoteReaders",
"(",
"readersToPromote",
"map",
"[",
"keybase1",
".",
"UID",
"]",
"bool",
",",
"extra",
"ExtraMetadata",
")",
"error",
"{",
"if",
"md",
".",
"TypeForKeying",
"(",
")",
"!=",
"tlf",
".",
"PrivateKeying",
"{",
"return",
"InvalidNonPrivateTLFOperation",
"{",
"md",
".",
"TlfID",
"(",
")",
",",
"\"",
"\"",
",",
"md",
".",
"Version",
"(",
")",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"readersToPromote",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"wkb",
",",
"rkb",
",",
"err",
":=",
"md",
".",
"getTLFKeyBundles",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"reader",
":=",
"range",
"readersToPromote",
"{",
"dkim",
",",
"ok",
":=",
"rkb",
".",
"Keys",
"[",
"reader",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"reader",
")",
"\n",
"}",
"\n",
"// TODO: This is incorrect, since dkim contains offsets info",
"// rkb.TLFEphemeralPublicKeys, which don't directly translate",
"// to offsets into wkb.TLFEphemeralPublicKeys.",
"//",
"// Also, doing this may leave some entries in",
"// rkb.TLFEphemeralPublicKeys unreferenced, so they should be",
"// removed.",
"//",
"// See KBFS-1719.",
"wkb",
".",
"Keys",
"[",
"reader",
"]",
"=",
"dkim",
"\n",
"delete",
"(",
"rkb",
".",
"Keys",
",",
"reader",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // PromoteReaders implements the RootMetadata interface for
// RootMetadataV3. | [
"PromoteReaders",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L741-L774 |
160,630 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | RevokeRemovedDevices | func (md *RootMetadataV3) RevokeRemovedDevices(
updatedWriterKeys, updatedReaderKeys UserDevicePublicKeys,
extra ExtraMetadata) (ServerHalfRemovalInfo, error) {
if md.TypeForKeying() != tlf.PrivateKeying {
return nil, InvalidNonPrivateTLFOperation{
md.TlfID(), "RevokeRemovedDevices", md.Version()}
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return nil, err
}
wRemovalInfo := wkb.Keys.RemoveDevicesNotIn(updatedWriterKeys)
rRemovalInfo := rkb.Keys.RemoveDevicesNotIn(updatedReaderKeys)
return wRemovalInfo.MergeUsers(rRemovalInfo)
} | go | func (md *RootMetadataV3) RevokeRemovedDevices(
updatedWriterKeys, updatedReaderKeys UserDevicePublicKeys,
extra ExtraMetadata) (ServerHalfRemovalInfo, error) {
if md.TypeForKeying() != tlf.PrivateKeying {
return nil, InvalidNonPrivateTLFOperation{
md.TlfID(), "RevokeRemovedDevices", md.Version()}
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return nil, err
}
wRemovalInfo := wkb.Keys.RemoveDevicesNotIn(updatedWriterKeys)
rRemovalInfo := rkb.Keys.RemoveDevicesNotIn(updatedReaderKeys)
return wRemovalInfo.MergeUsers(rRemovalInfo)
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"RevokeRemovedDevices",
"(",
"updatedWriterKeys",
",",
"updatedReaderKeys",
"UserDevicePublicKeys",
",",
"extra",
"ExtraMetadata",
")",
"(",
"ServerHalfRemovalInfo",
",",
"error",
")",
"{",
"if",
"md",
".",
"TypeForKeying",
"(",
")",
"!=",
"tlf",
".",
"PrivateKeying",
"{",
"return",
"nil",
",",
"InvalidNonPrivateTLFOperation",
"{",
"md",
".",
"TlfID",
"(",
")",
",",
"\"",
"\"",
",",
"md",
".",
"Version",
"(",
")",
"}",
"\n",
"}",
"\n\n",
"wkb",
",",
"rkb",
",",
"err",
":=",
"md",
".",
"getTLFKeyBundles",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"wRemovalInfo",
":=",
"wkb",
".",
"Keys",
".",
"RemoveDevicesNotIn",
"(",
"updatedWriterKeys",
")",
"\n",
"rRemovalInfo",
":=",
"rkb",
".",
"Keys",
".",
"RemoveDevicesNotIn",
"(",
"updatedReaderKeys",
")",
"\n",
"return",
"wRemovalInfo",
".",
"MergeUsers",
"(",
"rRemovalInfo",
")",
"\n",
"}"
] | // RevokeRemovedDevices implements the RootMetadata interface for
// RootMetadataV3. | [
"RevokeRemovedDevices",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L778-L794 |
160,631 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | GetUserDevicePublicKeys | func (md *RootMetadataV3) GetUserDevicePublicKeys(extra ExtraMetadata) (
writerDeviceKeys, readerDeviceKeys UserDevicePublicKeys, err error) {
if md.TypeForKeying() != tlf.PrivateKeying {
return nil, nil, InvalidNonPrivateTLFOperation{
md.TlfID(), "GetUserDevicePublicKeys", md.Version()}
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return nil, nil, err
}
return wkb.Keys.ToPublicKeys(), rkb.Keys.ToPublicKeys(), nil
} | go | func (md *RootMetadataV3) GetUserDevicePublicKeys(extra ExtraMetadata) (
writerDeviceKeys, readerDeviceKeys UserDevicePublicKeys, err error) {
if md.TypeForKeying() != tlf.PrivateKeying {
return nil, nil, InvalidNonPrivateTLFOperation{
md.TlfID(), "GetUserDevicePublicKeys", md.Version()}
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return nil, nil, err
}
return wkb.Keys.ToPublicKeys(), rkb.Keys.ToPublicKeys(), nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"GetUserDevicePublicKeys",
"(",
"extra",
"ExtraMetadata",
")",
"(",
"writerDeviceKeys",
",",
"readerDeviceKeys",
"UserDevicePublicKeys",
",",
"err",
"error",
")",
"{",
"if",
"md",
".",
"TypeForKeying",
"(",
")",
"!=",
"tlf",
".",
"PrivateKeying",
"{",
"return",
"nil",
",",
"nil",
",",
"InvalidNonPrivateTLFOperation",
"{",
"md",
".",
"TlfID",
"(",
")",
",",
"\"",
"\"",
",",
"md",
".",
"Version",
"(",
")",
"}",
"\n",
"}",
"\n\n",
"wkb",
",",
"rkb",
",",
"err",
":=",
"md",
".",
"getTLFKeyBundles",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"wkb",
".",
"Keys",
".",
"ToPublicKeys",
"(",
")",
",",
"rkb",
".",
"Keys",
".",
"ToPublicKeys",
"(",
")",
",",
"nil",
"\n",
"}"
] | // GetUserDevicePublicKeys implements the RootMetadata interface
// for RootMetadataV3. | [
"GetUserDevicePublicKeys",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L798-L811 |
160,632 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | GetTLFCryptKeyParams | func (md *RootMetadataV3) GetTLFCryptKeyParams(
keyGen KeyGen, user keybase1.UID,
key kbfscrypto.CryptPublicKey, extra ExtraMetadata) (
kbfscrypto.TLFEphemeralPublicKey,
kbfscrypto.EncryptedTLFCryptKeyClientHalf,
kbfscrypto.TLFCryptKeyServerHalfID, bool, error) {
if keyGen != md.LatestKeyGeneration() {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false,
TLFCryptKeyNotPerDeviceEncrypted{md.TlfID(), keyGen}
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false, err
}
isWriter := true
dkim := wkb.Keys[user]
if dkim == nil {
dkim = rkb.Keys[user]
if dkim == nil {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false, nil
}
isWriter = false
}
info, ok := dkim[key]
if !ok {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false, nil
}
var publicKeys kbfscrypto.TLFEphemeralPublicKeys
var keyType string
if isWriter {
publicKeys = wkb.TLFEphemeralPublicKeys
keyType = "writer"
} else {
publicKeys = rkb.TLFEphemeralPublicKeys
keyType = "reader"
}
keyCount := len(publicKeys)
index := info.EPubKeyIndex
if index >= keyCount {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false,
errors.Errorf("Invalid %s key index %d >= %d",
keyType, index, keyCount)
}
return publicKeys[index], info.ClientHalf, info.ServerHalfID, true, nil
} | go | func (md *RootMetadataV3) GetTLFCryptKeyParams(
keyGen KeyGen, user keybase1.UID,
key kbfscrypto.CryptPublicKey, extra ExtraMetadata) (
kbfscrypto.TLFEphemeralPublicKey,
kbfscrypto.EncryptedTLFCryptKeyClientHalf,
kbfscrypto.TLFCryptKeyServerHalfID, bool, error) {
if keyGen != md.LatestKeyGeneration() {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false,
TLFCryptKeyNotPerDeviceEncrypted{md.TlfID(), keyGen}
}
wkb, rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false, err
}
isWriter := true
dkim := wkb.Keys[user]
if dkim == nil {
dkim = rkb.Keys[user]
if dkim == nil {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false, nil
}
isWriter = false
}
info, ok := dkim[key]
if !ok {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false, nil
}
var publicKeys kbfscrypto.TLFEphemeralPublicKeys
var keyType string
if isWriter {
publicKeys = wkb.TLFEphemeralPublicKeys
keyType = "writer"
} else {
publicKeys = rkb.TLFEphemeralPublicKeys
keyType = "reader"
}
keyCount := len(publicKeys)
index := info.EPubKeyIndex
if index >= keyCount {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false,
errors.Errorf("Invalid %s key index %d >= %d",
keyType, index, keyCount)
}
return publicKeys[index], info.ClientHalf, info.ServerHalfID, true, nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"GetTLFCryptKeyParams",
"(",
"keyGen",
"KeyGen",
",",
"user",
"keybase1",
".",
"UID",
",",
"key",
"kbfscrypto",
".",
"CryptPublicKey",
",",
"extra",
"ExtraMetadata",
")",
"(",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
",",
"kbfscrypto",
".",
"EncryptedTLFCryptKeyClientHalf",
",",
"kbfscrypto",
".",
"TLFCryptKeyServerHalfID",
",",
"bool",
",",
"error",
")",
"{",
"if",
"keyGen",
"!=",
"md",
".",
"LatestKeyGeneration",
"(",
")",
"{",
"return",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
"{",
"}",
",",
"kbfscrypto",
".",
"EncryptedTLFCryptKeyClientHalf",
"{",
"}",
",",
"kbfscrypto",
".",
"TLFCryptKeyServerHalfID",
"{",
"}",
",",
"false",
",",
"TLFCryptKeyNotPerDeviceEncrypted",
"{",
"md",
".",
"TlfID",
"(",
")",
",",
"keyGen",
"}",
"\n",
"}",
"\n",
"wkb",
",",
"rkb",
",",
"err",
":=",
"md",
".",
"getTLFKeyBundles",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
"{",
"}",
",",
"kbfscrypto",
".",
"EncryptedTLFCryptKeyClientHalf",
"{",
"}",
",",
"kbfscrypto",
".",
"TLFCryptKeyServerHalfID",
"{",
"}",
",",
"false",
",",
"err",
"\n",
"}",
"\n",
"isWriter",
":=",
"true",
"\n",
"dkim",
":=",
"wkb",
".",
"Keys",
"[",
"user",
"]",
"\n",
"if",
"dkim",
"==",
"nil",
"{",
"dkim",
"=",
"rkb",
".",
"Keys",
"[",
"user",
"]",
"\n",
"if",
"dkim",
"==",
"nil",
"{",
"return",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
"{",
"}",
",",
"kbfscrypto",
".",
"EncryptedTLFCryptKeyClientHalf",
"{",
"}",
",",
"kbfscrypto",
".",
"TLFCryptKeyServerHalfID",
"{",
"}",
",",
"false",
",",
"nil",
"\n",
"}",
"\n",
"isWriter",
"=",
"false",
"\n",
"}",
"\n",
"info",
",",
"ok",
":=",
"dkim",
"[",
"key",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
"{",
"}",
",",
"kbfscrypto",
".",
"EncryptedTLFCryptKeyClientHalf",
"{",
"}",
",",
"kbfscrypto",
".",
"TLFCryptKeyServerHalfID",
"{",
"}",
",",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"publicKeys",
"kbfscrypto",
".",
"TLFEphemeralPublicKeys",
"\n",
"var",
"keyType",
"string",
"\n",
"if",
"isWriter",
"{",
"publicKeys",
"=",
"wkb",
".",
"TLFEphemeralPublicKeys",
"\n",
"keyType",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"publicKeys",
"=",
"rkb",
".",
"TLFEphemeralPublicKeys",
"\n",
"keyType",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"keyCount",
":=",
"len",
"(",
"publicKeys",
")",
"\n",
"index",
":=",
"info",
".",
"EPubKeyIndex",
"\n",
"if",
"index",
">=",
"keyCount",
"{",
"return",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
"{",
"}",
",",
"kbfscrypto",
".",
"EncryptedTLFCryptKeyClientHalf",
"{",
"}",
",",
"kbfscrypto",
".",
"TLFCryptKeyServerHalfID",
"{",
"}",
",",
"false",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyType",
",",
"index",
",",
"keyCount",
")",
"\n",
"}",
"\n",
"return",
"publicKeys",
"[",
"index",
"]",
",",
"info",
".",
"ClientHalf",
",",
"info",
".",
"ServerHalfID",
",",
"true",
",",
"nil",
"\n",
"}"
] | // GetTLFCryptKeyParams implements the RootMetadata interface for RootMetadataV3. | [
"GetTLFCryptKeyParams",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L814-L869 |
160,633 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | CheckWKBID | func CheckWKBID(codec kbfscodec.Codec,
wkbID TLFWriterKeyBundleID, wkb TLFWriterKeyBundleV3) error {
computedWKBID, err := MakeTLFWriterKeyBundleID(codec, wkb)
if err != nil {
return err
}
if wkbID != computedWKBID {
return errors.Errorf("Expected WKB ID %s, got %s",
wkbID, computedWKBID)
}
return nil
} | go | func CheckWKBID(codec kbfscodec.Codec,
wkbID TLFWriterKeyBundleID, wkb TLFWriterKeyBundleV3) error {
computedWKBID, err := MakeTLFWriterKeyBundleID(codec, wkb)
if err != nil {
return err
}
if wkbID != computedWKBID {
return errors.Errorf("Expected WKB ID %s, got %s",
wkbID, computedWKBID)
}
return nil
} | [
"func",
"CheckWKBID",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"wkbID",
"TLFWriterKeyBundleID",
",",
"wkb",
"TLFWriterKeyBundleV3",
")",
"error",
"{",
"computedWKBID",
",",
"err",
":=",
"MakeTLFWriterKeyBundleID",
"(",
"codec",
",",
"wkb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"wkbID",
"!=",
"computedWKBID",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"wkbID",
",",
"computedWKBID",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CheckWKBID returns an error if the ID of the given writer key
// bundle doesn't match the given one. | [
"CheckWKBID",
"returns",
"an",
"error",
"if",
"the",
"ID",
"of",
"the",
"given",
"writer",
"key",
"bundle",
"doesn",
"t",
"match",
"the",
"given",
"one",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L873-L886 |
160,634 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | CheckRKBID | func CheckRKBID(codec kbfscodec.Codec,
rkbID TLFReaderKeyBundleID, rkb TLFReaderKeyBundleV3) error {
computedRKBID, err := MakeTLFReaderKeyBundleID(codec, rkb)
if err != nil {
return err
}
if rkbID != computedRKBID {
return errors.Errorf("Expected RKB ID %s, got %s",
rkbID, computedRKBID)
}
return nil
} | go | func CheckRKBID(codec kbfscodec.Codec,
rkbID TLFReaderKeyBundleID, rkb TLFReaderKeyBundleV3) error {
computedRKBID, err := MakeTLFReaderKeyBundleID(codec, rkb)
if err != nil {
return err
}
if rkbID != computedRKBID {
return errors.Errorf("Expected RKB ID %s, got %s",
rkbID, computedRKBID)
}
return nil
} | [
"func",
"CheckRKBID",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"rkbID",
"TLFReaderKeyBundleID",
",",
"rkb",
"TLFReaderKeyBundleV3",
")",
"error",
"{",
"computedRKBID",
",",
"err",
":=",
"MakeTLFReaderKeyBundleID",
"(",
"codec",
",",
"rkb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"rkbID",
"!=",
"computedRKBID",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rkbID",
",",
"computedRKBID",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CheckRKBID returns an error if the ID of the given reader key
// bundle doesn't match the given one. | [
"CheckRKBID",
"returns",
"an",
"error",
"if",
"the",
"ID",
"of",
"the",
"given",
"reader",
"key",
"bundle",
"doesn",
"t",
"match",
"the",
"given",
"one",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L890-L903 |
160,635 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | IsLastModifiedBy | func (md *RootMetadataV3) IsLastModifiedBy(
uid keybase1.UID, key kbfscrypto.VerifyingKey) error {
// Verify the user and device are the writer.
writer := md.LastModifyingWriter()
if !md.IsWriterMetadataCopiedSet() {
if writer != uid {
return errors.Errorf("Last writer %s != %s", writer, uid)
}
}
// Verify the user and device are the last modifier.
user := md.GetLastModifyingUser()
if user != uid {
return errors.Errorf("Last modifier %s != %s", user, uid)
}
return nil
} | go | func (md *RootMetadataV3) IsLastModifiedBy(
uid keybase1.UID, key kbfscrypto.VerifyingKey) error {
// Verify the user and device are the writer.
writer := md.LastModifyingWriter()
if !md.IsWriterMetadataCopiedSet() {
if writer != uid {
return errors.Errorf("Last writer %s != %s", writer, uid)
}
}
// Verify the user and device are the last modifier.
user := md.GetLastModifyingUser()
if user != uid {
return errors.Errorf("Last modifier %s != %s", user, uid)
}
return nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"IsLastModifiedBy",
"(",
"uid",
"keybase1",
".",
"UID",
",",
"key",
"kbfscrypto",
".",
"VerifyingKey",
")",
"error",
"{",
"// Verify the user and device are the writer.",
"writer",
":=",
"md",
".",
"LastModifyingWriter",
"(",
")",
"\n",
"if",
"!",
"md",
".",
"IsWriterMetadataCopiedSet",
"(",
")",
"{",
"if",
"writer",
"!=",
"uid",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"writer",
",",
"uid",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Verify the user and device are the last modifier.",
"user",
":=",
"md",
".",
"GetLastModifyingUser",
"(",
")",
"\n",
"if",
"user",
"!=",
"uid",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"user",
",",
"uid",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // IsLastModifiedBy implements the RootMetadata interface for
// RootMetadataV3. | [
"IsLastModifiedBy",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1016-L1033 |
160,636 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | GetSerializedWriterMetadata | func (md *RootMetadataV3) GetSerializedWriterMetadata(
codec kbfscodec.Codec) ([]byte, error) {
return codec.Encode(md.WriterMetadata)
} | go | func (md *RootMetadataV3) GetSerializedWriterMetadata(
codec kbfscodec.Codec) ([]byte, error) {
return codec.Encode(md.WriterMetadata)
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"GetSerializedWriterMetadata",
"(",
"codec",
"kbfscodec",
".",
"Codec",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"codec",
".",
"Encode",
"(",
"md",
".",
"WriterMetadata",
")",
"\n",
"}"
] | // GetSerializedWriterMetadata implements the RootMetadata interface for RootMetadataV3. | [
"GetSerializedWriterMetadata",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1176-L1179 |
160,637 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | SetLastModifyingWriter | func (md *RootMetadataV3) SetLastModifyingWriter(user keybase1.UID) {
md.WriterMetadata.LastModifyingWriter = user
} | go | func (md *RootMetadataV3) SetLastModifyingWriter(user keybase1.UID) {
md.WriterMetadata.LastModifyingWriter = user
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"SetLastModifyingWriter",
"(",
"user",
"keybase1",
".",
"UID",
")",
"{",
"md",
".",
"WriterMetadata",
".",
"LastModifyingWriter",
"=",
"user",
"\n",
"}"
] | // SetLastModifyingWriter implements the MutableRootMetadata interface for RootMetadataV3. | [
"SetLastModifyingWriter",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1193-L1195 |
160,638 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | SetUnresolvedWriters | func (md *RootMetadataV3) SetUnresolvedWriters(writers []keybase1.SocialAssertion) {
md.WriterMetadata.UnresolvedWriters = writers
} | go | func (md *RootMetadataV3) SetUnresolvedWriters(writers []keybase1.SocialAssertion) {
md.WriterMetadata.UnresolvedWriters = writers
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"SetUnresolvedWriters",
"(",
"writers",
"[",
"]",
"keybase1",
".",
"SocialAssertion",
")",
"{",
"md",
".",
"WriterMetadata",
".",
"UnresolvedWriters",
"=",
"writers",
"\n",
"}"
] | // SetUnresolvedWriters implements the MutableRootMetadata interface for RootMetadataV3. | [
"SetUnresolvedWriters",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1401-L1403 |
160,639 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | SetWriters | func (md *RootMetadataV3) SetWriters(writers []keybase1.UserOrTeamID) {
md.WriterMetadata.Writers = writers
} | go | func (md *RootMetadataV3) SetWriters(writers []keybase1.UserOrTeamID) {
md.WriterMetadata.Writers = writers
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"SetWriters",
"(",
"writers",
"[",
"]",
"keybase1",
".",
"UserOrTeamID",
")",
"{",
"md",
".",
"WriterMetadata",
".",
"Writers",
"=",
"writers",
"\n",
"}"
] | // SetWriters implements the MutableRootMetadata interface for RootMetadataV3. | [
"SetWriters",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1416-L1418 |
160,640 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | ClearForV4Migration | func (md *RootMetadataV3) ClearForV4Migration() {
md.WriterMetadata.WKeyBundleID = TLFWriterKeyBundleID{}
md.RKeyBundleID = TLFReaderKeyBundleID{}
} | go | func (md *RootMetadataV3) ClearForV4Migration() {
md.WriterMetadata.WKeyBundleID = TLFWriterKeyBundleID{}
md.RKeyBundleID = TLFReaderKeyBundleID{}
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"ClearForV4Migration",
"(",
")",
"{",
"md",
".",
"WriterMetadata",
".",
"WKeyBundleID",
"=",
"TLFWriterKeyBundleID",
"{",
"}",
"\n",
"md",
".",
"RKeyBundleID",
"=",
"TLFReaderKeyBundleID",
"{",
"}",
"\n",
"}"
] | // ClearForV4Migration implements the MutableRootMetadata interface
// for RootMetadataV3. | [
"ClearForV4Migration",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1422-L1425 |
160,641 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | SetTlfID | func (md *RootMetadataV3) SetTlfID(tlf tlf.ID) {
md.WriterMetadata.ID = tlf
} | go | func (md *RootMetadataV3) SetTlfID(tlf tlf.ID) {
md.WriterMetadata.ID = tlf
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"SetTlfID",
"(",
"tlf",
"tlf",
".",
"ID",
")",
"{",
"md",
".",
"WriterMetadata",
".",
"ID",
"=",
"tlf",
"\n",
"}"
] | // SetTlfID implements the MutableRootMetadata interface for RootMetadataV3. | [
"SetTlfID",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1428-L1430 |
160,642 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | Version | func (md *RootMetadataV3) Version() MetadataVer {
if md.TlfID().Type() != tlf.SingleTeam &&
md.TypeForKeying() == tlf.TeamKeying {
return ImplicitTeamsVer
}
return SegregatedKeyBundlesVer
} | go | func (md *RootMetadataV3) Version() MetadataVer {
if md.TlfID().Type() != tlf.SingleTeam &&
md.TypeForKeying() == tlf.TeamKeying {
return ImplicitTeamsVer
}
return SegregatedKeyBundlesVer
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"Version",
"(",
")",
"MetadataVer",
"{",
"if",
"md",
".",
"TlfID",
"(",
")",
".",
"Type",
"(",
")",
"!=",
"tlf",
".",
"SingleTeam",
"&&",
"md",
".",
"TypeForKeying",
"(",
")",
"==",
"tlf",
".",
"TeamKeying",
"{",
"return",
"ImplicitTeamsVer",
"\n",
"}",
"\n",
"return",
"SegregatedKeyBundlesVer",
"\n",
"}"
] | // Version implements the MutableRootMetadata interface for RootMetadataV3. | [
"Version",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1438-L1444 |
160,643 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | GetCurrentTLFPublicKey | func (md *RootMetadataV3) GetCurrentTLFPublicKey(
extra ExtraMetadata) (kbfscrypto.TLFPublicKey, error) {
wkb, _, err := md.getTLFKeyBundles(extra)
if err != nil {
return kbfscrypto.TLFPublicKey{}, err
}
return wkb.TLFPublicKey, nil
} | go | func (md *RootMetadataV3) GetCurrentTLFPublicKey(
extra ExtraMetadata) (kbfscrypto.TLFPublicKey, error) {
wkb, _, err := md.getTLFKeyBundles(extra)
if err != nil {
return kbfscrypto.TLFPublicKey{}, err
}
return wkb.TLFPublicKey, nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"GetCurrentTLFPublicKey",
"(",
"extra",
"ExtraMetadata",
")",
"(",
"kbfscrypto",
".",
"TLFPublicKey",
",",
"error",
")",
"{",
"wkb",
",",
"_",
",",
"err",
":=",
"md",
".",
"getTLFKeyBundles",
"(",
"extra",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"kbfscrypto",
".",
"TLFPublicKey",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"wkb",
".",
"TLFPublicKey",
",",
"nil",
"\n",
"}"
] | // GetCurrentTLFPublicKey implements the RootMetadata interface
// for RootMetadataV3. | [
"GetCurrentTLFPublicKey",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1448-L1455 |
160,644 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | GetUnresolvedParticipants | func (md *RootMetadataV3) GetUnresolvedParticipants() []keybase1.SocialAssertion {
writers := md.WriterMetadata.UnresolvedWriters
readers := md.UnresolvedReaders
users := make([]keybase1.SocialAssertion, 0, len(writers)+len(readers))
users = append(users, writers...)
users = append(users, readers...)
return users
} | go | func (md *RootMetadataV3) GetUnresolvedParticipants() []keybase1.SocialAssertion {
writers := md.WriterMetadata.UnresolvedWriters
readers := md.UnresolvedReaders
users := make([]keybase1.SocialAssertion, 0, len(writers)+len(readers))
users = append(users, writers...)
users = append(users, readers...)
return users
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"GetUnresolvedParticipants",
"(",
")",
"[",
"]",
"keybase1",
".",
"SocialAssertion",
"{",
"writers",
":=",
"md",
".",
"WriterMetadata",
".",
"UnresolvedWriters",
"\n",
"readers",
":=",
"md",
".",
"UnresolvedReaders",
"\n",
"users",
":=",
"make",
"(",
"[",
"]",
"keybase1",
".",
"SocialAssertion",
",",
"0",
",",
"len",
"(",
"writers",
")",
"+",
"len",
"(",
"readers",
")",
")",
"\n",
"users",
"=",
"append",
"(",
"users",
",",
"writers",
"...",
")",
"\n",
"users",
"=",
"append",
"(",
"users",
",",
"readers",
"...",
")",
"\n",
"return",
"users",
"\n",
"}"
] | // GetUnresolvedParticipants implements the RootMetadata interface for RootMetadataV3. | [
"GetUnresolvedParticipants",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1458-L1465 |
160,645 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | UpdateKeyBundles | func (md *RootMetadataV3) UpdateKeyBundles(codec kbfscodec.Codec,
extra ExtraMetadata,
updatedWriterKeys, updatedReaderKeys UserDevicePublicKeys,
ePubKey kbfscrypto.TLFEphemeralPublicKey,
ePrivKey kbfscrypto.TLFEphemeralPrivateKey,
tlfCryptKeys []kbfscrypto.TLFCryptKey) (
[]UserDeviceKeyServerHalves, error) {
if len(tlfCryptKeys) != 1 {
return nil, fmt.Errorf(
"(MDv3) Expected 1 TLF crypt key, got %d",
len(tlfCryptKeys))
}
serverHalves, err := md.updateKeyBundles(codec, extra,
updatedWriterKeys, updatedReaderKeys,
ePubKey, ePrivKey, tlfCryptKeys[0])
if err != nil {
return nil, err
}
return []UserDeviceKeyServerHalves{serverHalves}, nil
} | go | func (md *RootMetadataV3) UpdateKeyBundles(codec kbfscodec.Codec,
extra ExtraMetadata,
updatedWriterKeys, updatedReaderKeys UserDevicePublicKeys,
ePubKey kbfscrypto.TLFEphemeralPublicKey,
ePrivKey kbfscrypto.TLFEphemeralPrivateKey,
tlfCryptKeys []kbfscrypto.TLFCryptKey) (
[]UserDeviceKeyServerHalves, error) {
if len(tlfCryptKeys) != 1 {
return nil, fmt.Errorf(
"(MDv3) Expected 1 TLF crypt key, got %d",
len(tlfCryptKeys))
}
serverHalves, err := md.updateKeyBundles(codec, extra,
updatedWriterKeys, updatedReaderKeys,
ePubKey, ePrivKey, tlfCryptKeys[0])
if err != nil {
return nil, err
}
return []UserDeviceKeyServerHalves{serverHalves}, nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"UpdateKeyBundles",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"extra",
"ExtraMetadata",
",",
"updatedWriterKeys",
",",
"updatedReaderKeys",
"UserDevicePublicKeys",
",",
"ePubKey",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
",",
"ePrivKey",
"kbfscrypto",
".",
"TLFEphemeralPrivateKey",
",",
"tlfCryptKeys",
"[",
"]",
"kbfscrypto",
".",
"TLFCryptKey",
")",
"(",
"[",
"]",
"UserDeviceKeyServerHalves",
",",
"error",
")",
"{",
"if",
"len",
"(",
"tlfCryptKeys",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"len",
"(",
"tlfCryptKeys",
")",
")",
"\n",
"}",
"\n\n",
"serverHalves",
",",
"err",
":=",
"md",
".",
"updateKeyBundles",
"(",
"codec",
",",
"extra",
",",
"updatedWriterKeys",
",",
"updatedReaderKeys",
",",
"ePubKey",
",",
"ePrivKey",
",",
"tlfCryptKeys",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"[",
"]",
"UserDeviceKeyServerHalves",
"{",
"serverHalves",
"}",
",",
"nil",
"\n",
"}"
] | // UpdateKeyBundles implements the MutableRootMetadata interface
// for RootMetadataV3. | [
"UpdateKeyBundles",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1469-L1490 |
160,646 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | FinalizeRekey | func (md *RootMetadataV3) FinalizeRekey(
codec kbfscodec.Codec, extra ExtraMetadata) error {
extraV3, ok := extra.(*ExtraMetadataV3)
if !ok {
return errors.New("Invalid extra metadata")
}
oldWKBID := md.WriterMetadata.WKeyBundleID
oldRKBID := md.RKeyBundleID
newWKBID, err := MakeTLFWriterKeyBundleID(codec, extraV3.wkb)
if err != nil {
return err
}
newRKBID, err := MakeTLFReaderKeyBundleID(codec, extraV3.rkb)
if err != nil {
return err
}
md.WriterMetadata.WKeyBundleID = newWKBID
md.RKeyBundleID = newRKBID
extraV3.updateNew(newWKBID != oldWKBID, newRKBID != oldRKBID)
return nil
} | go | func (md *RootMetadataV3) FinalizeRekey(
codec kbfscodec.Codec, extra ExtraMetadata) error {
extraV3, ok := extra.(*ExtraMetadataV3)
if !ok {
return errors.New("Invalid extra metadata")
}
oldWKBID := md.WriterMetadata.WKeyBundleID
oldRKBID := md.RKeyBundleID
newWKBID, err := MakeTLFWriterKeyBundleID(codec, extraV3.wkb)
if err != nil {
return err
}
newRKBID, err := MakeTLFReaderKeyBundleID(codec, extraV3.rkb)
if err != nil {
return err
}
md.WriterMetadata.WKeyBundleID = newWKBID
md.RKeyBundleID = newRKBID
extraV3.updateNew(newWKBID != oldWKBID, newRKBID != oldRKBID)
return nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"FinalizeRekey",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"extra",
"ExtraMetadata",
")",
"error",
"{",
"extraV3",
",",
"ok",
":=",
"extra",
".",
"(",
"*",
"ExtraMetadataV3",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"oldWKBID",
":=",
"md",
".",
"WriterMetadata",
".",
"WKeyBundleID",
"\n",
"oldRKBID",
":=",
"md",
".",
"RKeyBundleID",
"\n\n",
"newWKBID",
",",
"err",
":=",
"MakeTLFWriterKeyBundleID",
"(",
"codec",
",",
"extraV3",
".",
"wkb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"newRKBID",
",",
"err",
":=",
"MakeTLFReaderKeyBundleID",
"(",
"codec",
",",
"extraV3",
".",
"rkb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"md",
".",
"WriterMetadata",
".",
"WKeyBundleID",
"=",
"newWKBID",
"\n",
"md",
".",
"RKeyBundleID",
"=",
"newRKBID",
"\n\n",
"extraV3",
".",
"updateNew",
"(",
"newWKBID",
"!=",
"oldWKBID",
",",
"newRKBID",
"!=",
"oldRKBID",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // FinalizeRekey implements the MutableRootMetadata interface for RootMetadataV3. | [
"FinalizeRekey",
"implements",
"the",
"MutableRootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1503-L1527 |
160,647 | keybase/client | go/kbfs/kbfsmd/root_metadata_v3.go | GetHistoricTLFCryptKey | func (md *RootMetadataV3) GetHistoricTLFCryptKey(codec kbfscodec.Codec,
keyGen KeyGen, currentKey kbfscrypto.TLFCryptKey, extra ExtraMetadata) (
kbfscrypto.TLFCryptKey, error) {
extraV3, ok := extra.(*ExtraMetadataV3)
if !ok {
return kbfscrypto.TLFCryptKey{}, errors.New(
"Invalid extra metadata")
}
if keyGen < FirstValidKeyGen || keyGen >= md.LatestKeyGeneration() {
return kbfscrypto.TLFCryptKey{}, errors.Errorf(
"Invalid key generation %d", keyGen)
}
oldKeys, err := kbfscrypto.DecryptTLFCryptKeys(
codec, extraV3.wkb.EncryptedHistoricTLFCryptKeys, currentKey)
if err != nil {
return kbfscrypto.TLFCryptKey{}, err
}
index := int(keyGen - FirstValidKeyGen)
if index >= len(oldKeys) || index < 0 {
return kbfscrypto.TLFCryptKey{}, errors.Errorf(
"Index %d out of range (max: %d)", index, len(oldKeys))
}
return oldKeys[index], nil
} | go | func (md *RootMetadataV3) GetHistoricTLFCryptKey(codec kbfscodec.Codec,
keyGen KeyGen, currentKey kbfscrypto.TLFCryptKey, extra ExtraMetadata) (
kbfscrypto.TLFCryptKey, error) {
extraV3, ok := extra.(*ExtraMetadataV3)
if !ok {
return kbfscrypto.TLFCryptKey{}, errors.New(
"Invalid extra metadata")
}
if keyGen < FirstValidKeyGen || keyGen >= md.LatestKeyGeneration() {
return kbfscrypto.TLFCryptKey{}, errors.Errorf(
"Invalid key generation %d", keyGen)
}
oldKeys, err := kbfscrypto.DecryptTLFCryptKeys(
codec, extraV3.wkb.EncryptedHistoricTLFCryptKeys, currentKey)
if err != nil {
return kbfscrypto.TLFCryptKey{}, err
}
index := int(keyGen - FirstValidKeyGen)
if index >= len(oldKeys) || index < 0 {
return kbfscrypto.TLFCryptKey{}, errors.Errorf(
"Index %d out of range (max: %d)", index, len(oldKeys))
}
return oldKeys[index], nil
} | [
"func",
"(",
"md",
"*",
"RootMetadataV3",
")",
"GetHistoricTLFCryptKey",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"keyGen",
"KeyGen",
",",
"currentKey",
"kbfscrypto",
".",
"TLFCryptKey",
",",
"extra",
"ExtraMetadata",
")",
"(",
"kbfscrypto",
".",
"TLFCryptKey",
",",
"error",
")",
"{",
"extraV3",
",",
"ok",
":=",
"extra",
".",
"(",
"*",
"ExtraMetadataV3",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"kbfscrypto",
".",
"TLFCryptKey",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"keyGen",
"<",
"FirstValidKeyGen",
"||",
"keyGen",
">=",
"md",
".",
"LatestKeyGeneration",
"(",
")",
"{",
"return",
"kbfscrypto",
".",
"TLFCryptKey",
"{",
"}",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"keyGen",
")",
"\n",
"}",
"\n",
"oldKeys",
",",
"err",
":=",
"kbfscrypto",
".",
"DecryptTLFCryptKeys",
"(",
"codec",
",",
"extraV3",
".",
"wkb",
".",
"EncryptedHistoricTLFCryptKeys",
",",
"currentKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"kbfscrypto",
".",
"TLFCryptKey",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"index",
":=",
"int",
"(",
"keyGen",
"-",
"FirstValidKeyGen",
")",
"\n",
"if",
"index",
">=",
"len",
"(",
"oldKeys",
")",
"||",
"index",
"<",
"0",
"{",
"return",
"kbfscrypto",
".",
"TLFCryptKey",
"{",
"}",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"index",
",",
"len",
"(",
"oldKeys",
")",
")",
"\n",
"}",
"\n",
"return",
"oldKeys",
"[",
"index",
"]",
",",
"nil",
"\n",
"}"
] | // GetHistoricTLFCryptKey implements the RootMetadata interface for RootMetadataV3. | [
"GetHistoricTLFCryptKey",
"implements",
"the",
"RootMetadata",
"interface",
"for",
"RootMetadataV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/root_metadata_v3.go#L1535-L1558 |
160,648 | keybase/client | go/service/log.go | NewLogHandler | func NewLogHandler(xp rpc.Transporter, logReg *logRegister, g *libkb.GlobalContext) *LogHandler {
return &LogHandler{
BaseHandler: NewBaseHandler(g, xp),
logReg: logReg,
Contextified: libkb.NewContextified(g),
}
} | go | func NewLogHandler(xp rpc.Transporter, logReg *logRegister, g *libkb.GlobalContext) *LogHandler {
return &LogHandler{
BaseHandler: NewBaseHandler(g, xp),
logReg: logReg,
Contextified: libkb.NewContextified(g),
}
} | [
"func",
"NewLogHandler",
"(",
"xp",
"rpc",
".",
"Transporter",
",",
"logReg",
"*",
"logRegister",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"*",
"LogHandler",
"{",
"return",
"&",
"LogHandler",
"{",
"BaseHandler",
":",
"NewBaseHandler",
"(",
"g",
",",
"xp",
")",
",",
"logReg",
":",
"logReg",
",",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
",",
"}",
"\n",
"}"
] | // NewLogHandler creates a LogHandler for the xp transport. | [
"NewLogHandler",
"creates",
"a",
"LogHandler",
"for",
"the",
"xp",
"transport",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/service/log.go#L22-L28 |
160,649 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | NewKBFSOpsStandard | func NewKBFSOpsStandard(appStateUpdater env.AppStateUpdater, config Config) *KBFSOpsStandard {
log := config.MakeLogger("")
quLog := config.MakeLogger(QuotaUsageLogModule("KBFSOps"))
kops := &KBFSOpsStandard{
appStateUpdater: appStateUpdater,
config: config,
log: log,
deferLog: log.CloneWithAddedDepth(1),
ops: make(map[data.FolderBranch]*folderBranchOps),
opsByFav: make(map[favorites.Folder]*folderBranchOps),
reIdentifyControlChan: make(chan chan<- struct{}),
favs: NewFavorites(config),
quotaUsage: NewEventuallyConsistentQuotaUsage(
config, quLog, config.MakeVLogger(quLog)),
longOperationDebugDumper: NewImpatientDebugDumper(
config, longOperationDebugDumpDuration),
currentStatus: &kbfsCurrentStatus{},
}
kops.currentStatus.Init()
go kops.markForReIdentifyIfNeededLoop()
return kops
} | go | func NewKBFSOpsStandard(appStateUpdater env.AppStateUpdater, config Config) *KBFSOpsStandard {
log := config.MakeLogger("")
quLog := config.MakeLogger(QuotaUsageLogModule("KBFSOps"))
kops := &KBFSOpsStandard{
appStateUpdater: appStateUpdater,
config: config,
log: log,
deferLog: log.CloneWithAddedDepth(1),
ops: make(map[data.FolderBranch]*folderBranchOps),
opsByFav: make(map[favorites.Folder]*folderBranchOps),
reIdentifyControlChan: make(chan chan<- struct{}),
favs: NewFavorites(config),
quotaUsage: NewEventuallyConsistentQuotaUsage(
config, quLog, config.MakeVLogger(quLog)),
longOperationDebugDumper: NewImpatientDebugDumper(
config, longOperationDebugDumpDuration),
currentStatus: &kbfsCurrentStatus{},
}
kops.currentStatus.Init()
go kops.markForReIdentifyIfNeededLoop()
return kops
} | [
"func",
"NewKBFSOpsStandard",
"(",
"appStateUpdater",
"env",
".",
"AppStateUpdater",
",",
"config",
"Config",
")",
"*",
"KBFSOpsStandard",
"{",
"log",
":=",
"config",
".",
"MakeLogger",
"(",
"\"",
"\"",
")",
"\n",
"quLog",
":=",
"config",
".",
"MakeLogger",
"(",
"QuotaUsageLogModule",
"(",
"\"",
"\"",
")",
")",
"\n",
"kops",
":=",
"&",
"KBFSOpsStandard",
"{",
"appStateUpdater",
":",
"appStateUpdater",
",",
"config",
":",
"config",
",",
"log",
":",
"log",
",",
"deferLog",
":",
"log",
".",
"CloneWithAddedDepth",
"(",
"1",
")",
",",
"ops",
":",
"make",
"(",
"map",
"[",
"data",
".",
"FolderBranch",
"]",
"*",
"folderBranchOps",
")",
",",
"opsByFav",
":",
"make",
"(",
"map",
"[",
"favorites",
".",
"Folder",
"]",
"*",
"folderBranchOps",
")",
",",
"reIdentifyControlChan",
":",
"make",
"(",
"chan",
"chan",
"<-",
"struct",
"{",
"}",
")",
",",
"favs",
":",
"NewFavorites",
"(",
"config",
")",
",",
"quotaUsage",
":",
"NewEventuallyConsistentQuotaUsage",
"(",
"config",
",",
"quLog",
",",
"config",
".",
"MakeVLogger",
"(",
"quLog",
")",
")",
",",
"longOperationDebugDumper",
":",
"NewImpatientDebugDumper",
"(",
"config",
",",
"longOperationDebugDumpDuration",
")",
",",
"currentStatus",
":",
"&",
"kbfsCurrentStatus",
"{",
"}",
",",
"}",
"\n",
"kops",
".",
"currentStatus",
".",
"Init",
"(",
")",
"\n",
"go",
"kops",
".",
"markForReIdentifyIfNeededLoop",
"(",
")",
"\n",
"return",
"kops",
"\n",
"}"
] | // NewKBFSOpsStandard constructs a new KBFSOpsStandard object. | [
"NewKBFSOpsStandard",
"constructs",
"a",
"new",
"KBFSOpsStandard",
"object",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L66-L87 |
160,650 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Shutdown | func (fs *KBFSOpsStandard) Shutdown(ctx context.Context) error {
defer fs.longOperationDebugDumper.Shutdown() // shut it down last
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
err := fs.shutdownEdits(ctx)
if err != nil {
return err
}
close(fs.reIdentifyControlChan)
var errors []error
if err := fs.favs.Shutdown(); err != nil {
errors = append(errors, err)
}
for _, ops := range fs.ops {
if err := ops.Shutdown(ctx); err != nil {
errors = append(errors, err)
// Continue on and try to shut down the other FBOs.
}
}
if len(errors) == 1 {
return errors[0]
} else if len(errors) > 1 {
// Aggregate errors
return fmt.Errorf("Multiple errors on shutdown: %v", errors)
}
return nil
} | go | func (fs *KBFSOpsStandard) Shutdown(ctx context.Context) error {
defer fs.longOperationDebugDumper.Shutdown() // shut it down last
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
err := fs.shutdownEdits(ctx)
if err != nil {
return err
}
close(fs.reIdentifyControlChan)
var errors []error
if err := fs.favs.Shutdown(); err != nil {
errors = append(errors, err)
}
for _, ops := range fs.ops {
if err := ops.Shutdown(ctx); err != nil {
errors = append(errors, err)
// Continue on and try to shut down the other FBOs.
}
}
if len(errors) == 1 {
return errors[0]
} else if len(errors) > 1 {
// Aggregate errors
return fmt.Errorf("Multiple errors on shutdown: %v", errors)
}
return nil
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"defer",
"fs",
".",
"longOperationDebugDumper",
".",
"Shutdown",
"(",
")",
"// shut it down last",
"\n",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"err",
":=",
"fs",
".",
"shutdownEdits",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"close",
"(",
"fs",
".",
"reIdentifyControlChan",
")",
"\n",
"var",
"errors",
"[",
"]",
"error",
"\n",
"if",
"err",
":=",
"fs",
".",
"favs",
".",
"Shutdown",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"ops",
":=",
"range",
"fs",
".",
"ops",
"{",
"if",
"err",
":=",
"ops",
".",
"Shutdown",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"err",
")",
"\n",
"// Continue on and try to shut down the other FBOs.",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"errors",
")",
"==",
"1",
"{",
"return",
"errors",
"[",
"0",
"]",
"\n",
"}",
"else",
"if",
"len",
"(",
"errors",
")",
">",
"1",
"{",
"// Aggregate errors",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errors",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Shutdown safely shuts down any background goroutines that may have
// been launched by KBFSOpsStandard. | [
"Shutdown",
"safely",
"shuts",
"down",
"any",
"background",
"goroutines",
"that",
"may",
"have",
"been",
"launched",
"by",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L145-L173 |
160,651 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | ClearPrivateFolderMD | func (fs *KBFSOpsStandard) ClearPrivateFolderMD(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
// Block until all private folders have been reset. TODO:
// parallelize these, as they can block for a while waiting for
// the lock.
for _, fbo := range fs.ops {
// This call is a no-op for public folders.
fbo.ClearPrivateFolderMD(ctx)
}
} | go | func (fs *KBFSOpsStandard) ClearPrivateFolderMD(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
// Block until all private folders have been reset. TODO:
// parallelize these, as they can block for a while waiting for
// the lock.
for _, fbo := range fs.ops {
// This call is a no-op for public folders.
fbo.ClearPrivateFolderMD(ctx)
}
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"ClearPrivateFolderMD",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"fs",
".",
"opsLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"fs",
".",
"opsLock",
".",
"Unlock",
"(",
")",
"\n\n",
"// Block until all private folders have been reset. TODO:",
"// parallelize these, as they can block for a while waiting for",
"// the lock.",
"for",
"_",
",",
"fbo",
":=",
"range",
"fs",
".",
"ops",
"{",
"// This call is a no-op for public folders.",
"fbo",
".",
"ClearPrivateFolderMD",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"}"
] | // ClearPrivateFolderMD implements the KBFSOps interface for
// KBFSOpsStandard. | [
"ClearPrivateFolderMD",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L215-L229 |
160,652 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | ForceFastForward | func (fs *KBFSOpsStandard) ForceFastForward(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
fs.log.CDebugf(ctx, "Forcing fast-forwards for %d folders", len(fs.ops))
for _, fbo := range fs.ops {
fbo.ForceFastForward(ctx)
}
} | go | func (fs *KBFSOpsStandard) ForceFastForward(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
fs.log.CDebugf(ctx, "Forcing fast-forwards for %d folders", len(fs.ops))
for _, fbo := range fs.ops {
fbo.ForceFastForward(ctx)
}
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"ForceFastForward",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"fs",
".",
"opsLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"fs",
".",
"opsLock",
".",
"Unlock",
"(",
")",
"\n\n",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"len",
"(",
"fs",
".",
"ops",
")",
")",
"\n",
"for",
"_",
",",
"fbo",
":=",
"range",
"fs",
".",
"ops",
"{",
"fbo",
".",
"ForceFastForward",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"}"
] | // ForceFastForward implements the KBFSOps interface for
// KBFSOpsStandard. | [
"ForceFastForward",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L233-L244 |
160,653 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | InvalidateNodeAndChildren | func (fs *KBFSOpsStandard) InvalidateNodeAndChildren(
ctx context.Context, node Node) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.InvalidateNodeAndChildren(ctx, node)
} | go | func (fs *KBFSOpsStandard) InvalidateNodeAndChildren(
ctx context.Context, node Node) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.InvalidateNodeAndChildren(ctx, node)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"InvalidateNodeAndChildren",
"(",
"ctx",
"context",
".",
"Context",
",",
"node",
"Node",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"node",
")",
"\n",
"return",
"ops",
".",
"InvalidateNodeAndChildren",
"(",
"ctx",
",",
"node",
")",
"\n",
"}"
] | // InvalidateNodeAndChildren implements the KBFSOps interface for
// KBFSOpsStandard. | [
"InvalidateNodeAndChildren",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L248-L255 |
160,654 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetFavorites | func (fs *KBFSOpsStandard) GetFavorites(ctx context.Context) (
[]favorites.Folder, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.favs.Get(ctx)
} | go | func (fs *KBFSOpsStandard) GetFavorites(ctx context.Context) (
[]favorites.Folder, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.favs.Get(ctx)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetFavorites",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"favorites",
".",
"Folder",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"return",
"fs",
".",
"favs",
".",
"Get",
"(",
"ctx",
")",
"\n",
"}"
] | // GetFavorites implements the KBFSOps interface for
// KBFSOpsStandard. | [
"GetFavorites",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L259-L265 |
160,655 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetFavoritesAll | func (fs *KBFSOpsStandard) GetFavoritesAll(ctx context.Context) (keybase1.
FavoritesResult, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.favs.GetAll(ctx)
} | go | func (fs *KBFSOpsStandard) GetFavoritesAll(ctx context.Context) (keybase1.
FavoritesResult, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.favs.GetAll(ctx)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetFavoritesAll",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"keybase1",
".",
"FavoritesResult",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"return",
"fs",
".",
"favs",
".",
"GetAll",
"(",
"ctx",
")",
"\n",
"}"
] | // GetFavoritesAll implements the KBFSOps interface for
// KBFSOpsStandard. | [
"GetFavoritesAll",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L269-L275 |
160,656 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | RefreshCachedFavorites | func (fs *KBFSOpsStandard) RefreshCachedFavorites(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.favs.RefreshCache(ctx)
} | go | func (fs *KBFSOpsStandard) RefreshCachedFavorites(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.favs.RefreshCache(ctx)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"RefreshCachedFavorites",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"fs",
".",
"favs",
".",
"RefreshCache",
"(",
"ctx",
")",
"\n",
"}"
] | // RefreshCachedFavorites implements the KBFSOps interface for
// KBFSOpsStandard. | [
"RefreshCachedFavorites",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L279-L284 |
160,657 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | ClearCachedFavorites | func (fs *KBFSOpsStandard) ClearCachedFavorites(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.favs.ClearCache(ctx)
} | go | func (fs *KBFSOpsStandard) ClearCachedFavorites(ctx context.Context) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.favs.ClearCache(ctx)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"ClearCachedFavorites",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"fs",
".",
"favs",
".",
"ClearCache",
"(",
"ctx",
")",
"\n",
"}"
] | // ClearCachedFavorites implements the KBFSOps interface for
// KBFSOpsStandard. | [
"ClearCachedFavorites",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L288-L293 |
160,658 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | AddFavorite | func (fs *KBFSOpsStandard) AddFavorite(ctx context.Context,
fav favorites.Folder, data favorites.Data) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
kbpki := fs.config.KBPKI()
_, err := kbpki.GetCurrentSession(ctx)
isLoggedIn := err == nil
if isLoggedIn {
err := fs.favs.Add(ctx, favorites.ToAdd{
Folder: fav,
Data: data,
Created: false,
})
if err != nil {
return err
}
}
return nil
} | go | func (fs *KBFSOpsStandard) AddFavorite(ctx context.Context,
fav favorites.Folder, data favorites.Data) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
kbpki := fs.config.KBPKI()
_, err := kbpki.GetCurrentSession(ctx)
isLoggedIn := err == nil
if isLoggedIn {
err := fs.favs.Add(ctx, favorites.ToAdd{
Folder: fav,
Data: data,
Created: false,
})
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"AddFavorite",
"(",
"ctx",
"context",
".",
"Context",
",",
"fav",
"favorites",
".",
"Folder",
",",
"data",
"favorites",
".",
"Data",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"kbpki",
":=",
"fs",
".",
"config",
".",
"KBPKI",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"kbpki",
".",
"GetCurrentSession",
"(",
"ctx",
")",
"\n",
"isLoggedIn",
":=",
"err",
"==",
"nil",
"\n\n",
"if",
"isLoggedIn",
"{",
"err",
":=",
"fs",
".",
"favs",
".",
"Add",
"(",
"ctx",
",",
"favorites",
".",
"ToAdd",
"{",
"Folder",
":",
"fav",
",",
"Data",
":",
"data",
",",
"Created",
":",
"false",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // AddFavorite implements the KBFSOps interface for KBFSOpsStandard. | [
"AddFavorite",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L296-L317 |
160,659 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | SetFavoritesHomeTLFInfo | func (fs *KBFSOpsStandard) SetFavoritesHomeTLFInfo(ctx context.Context,
info homeTLFInfo) {
fs.favs.setHomeTLFInfo(ctx, info)
} | go | func (fs *KBFSOpsStandard) SetFavoritesHomeTLFInfo(ctx context.Context,
info homeTLFInfo) {
fs.favs.setHomeTLFInfo(ctx, info)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"SetFavoritesHomeTLFInfo",
"(",
"ctx",
"context",
".",
"Context",
",",
"info",
"homeTLFInfo",
")",
"{",
"fs",
".",
"favs",
".",
"setHomeTLFInfo",
"(",
"ctx",
",",
"info",
")",
"\n",
"}"
] | // SetFavoritesHomeTLFInfo implements the KBFSOps interface for KBFSOpsStandard. | [
"SetFavoritesHomeTLFInfo",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L320-L323 |
160,660 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | RefreshEditHistory | func (fs *KBFSOpsStandard) RefreshEditHistory(fav favorites.Folder) {
fbo := fs.getOpsByFav(fav)
if fbo != nil {
fbo.refreshEditHistory()
}
} | go | func (fs *KBFSOpsStandard) RefreshEditHistory(fav favorites.Folder) {
fbo := fs.getOpsByFav(fav)
if fbo != nil {
fbo.refreshEditHistory()
}
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"RefreshEditHistory",
"(",
"fav",
"favorites",
".",
"Folder",
")",
"{",
"fbo",
":=",
"fs",
".",
"getOpsByFav",
"(",
"fav",
")",
"\n",
"if",
"fbo",
"!=",
"nil",
"{",
"fbo",
".",
"refreshEditHistory",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // RefreshEditHistory implements the KBFSOps interface for KBFSOpsStandard | [
"RefreshEditHistory",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L332-L337 |
160,661 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | DeleteFavorite | func (fs *KBFSOpsStandard) DeleteFavorite(ctx context.Context,
fav favorites.Folder) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
kbpki := fs.config.KBPKI()
_, err := kbpki.GetCurrentSession(ctx)
isLoggedIn := err == nil
// Let this ops remove itself, if we have one available.
ops := fs.getOpsByFav(fav)
if ops != nil {
err := ops.doFavoritesOp(ctx, fs.favs, FavoritesOpRemove, nil)
if _, ok := err.(OpsCantHandleFavorite); !ok {
return err
}
// If the ops couldn't handle the delete, fall through to
// going directly via Favorites.
}
if isLoggedIn {
err := fs.favs.Delete(ctx, fav)
if err != nil {
return err
}
}
// TODO: Shut down the running folderBranchOps, if one exists?
// What about open file handles?
return nil
} | go | func (fs *KBFSOpsStandard) DeleteFavorite(ctx context.Context,
fav favorites.Folder) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
kbpki := fs.config.KBPKI()
_, err := kbpki.GetCurrentSession(ctx)
isLoggedIn := err == nil
// Let this ops remove itself, if we have one available.
ops := fs.getOpsByFav(fav)
if ops != nil {
err := ops.doFavoritesOp(ctx, fs.favs, FavoritesOpRemove, nil)
if _, ok := err.(OpsCantHandleFavorite); !ok {
return err
}
// If the ops couldn't handle the delete, fall through to
// going directly via Favorites.
}
if isLoggedIn {
err := fs.favs.Delete(ctx, fav)
if err != nil {
return err
}
}
// TODO: Shut down the running folderBranchOps, if one exists?
// What about open file handles?
return nil
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"DeleteFavorite",
"(",
"ctx",
"context",
".",
"Context",
",",
"fav",
"favorites",
".",
"Folder",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"kbpki",
":=",
"fs",
".",
"config",
".",
"KBPKI",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"kbpki",
".",
"GetCurrentSession",
"(",
"ctx",
")",
"\n",
"isLoggedIn",
":=",
"err",
"==",
"nil",
"\n\n",
"// Let this ops remove itself, if we have one available.",
"ops",
":=",
"fs",
".",
"getOpsByFav",
"(",
"fav",
")",
"\n",
"if",
"ops",
"!=",
"nil",
"{",
"err",
":=",
"ops",
".",
"doFavoritesOp",
"(",
"ctx",
",",
"fs",
".",
"favs",
",",
"FavoritesOpRemove",
",",
"nil",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"OpsCantHandleFavorite",
")",
";",
"!",
"ok",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// If the ops couldn't handle the delete, fall through to",
"// going directly via Favorites.",
"}",
"\n\n",
"if",
"isLoggedIn",
"{",
"err",
":=",
"fs",
".",
"favs",
".",
"Delete",
"(",
"ctx",
",",
"fav",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// TODO: Shut down the running folderBranchOps, if one exists?",
"// What about open file handles?",
"return",
"nil",
"\n",
"}"
] | // DeleteFavorite implements the KBFSOps interface for
// KBFSOpsStandard. | [
"DeleteFavorite",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L341-L372 |
160,662 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | createAndStoreTlfIDIfNeeded | func (fs *KBFSOpsStandard) createAndStoreTlfIDIfNeeded(
ctx context.Context, h *tlfhandle.Handle) error {
if h.TlfID() != tlf.NullID {
return nil
}
return fs.resetTlfID(ctx, h)
} | go | func (fs *KBFSOpsStandard) createAndStoreTlfIDIfNeeded(
ctx context.Context, h *tlfhandle.Handle) error {
if h.TlfID() != tlf.NullID {
return nil
}
return fs.resetTlfID(ctx, h)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"createAndStoreTlfIDIfNeeded",
"(",
"ctx",
"context",
".",
"Context",
",",
"h",
"*",
"tlfhandle",
".",
"Handle",
")",
"error",
"{",
"if",
"h",
".",
"TlfID",
"(",
")",
"!=",
"tlf",
".",
"NullID",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"fs",
".",
"resetTlfID",
"(",
"ctx",
",",
"h",
")",
"\n",
"}"
] | // createAndStoreTlfIDIfNeeded creates a TLF ID for a team-backed
// handle that doesn't have one yet, and associates it in the service
// with the team. If it returns a `nil` error, it may have modified
// `h` to include the new TLF ID. | [
"createAndStoreTlfIDIfNeeded",
"creates",
"a",
"TLF",
"ID",
"for",
"a",
"team",
"-",
"backed",
"handle",
"that",
"doesn",
"t",
"have",
"one",
"yet",
"and",
"associates",
"it",
"in",
"the",
"service",
"with",
"the",
"team",
".",
"If",
"it",
"returns",
"a",
"nil",
"error",
"it",
"may",
"have",
"modified",
"h",
"to",
"include",
"the",
"new",
"TLF",
"ID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L512-L519 |
160,663 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetTLFCryptKeys | func (fs *KBFSOpsStandard) GetTLFCryptKeys(
ctx context.Context, tlfHandle *tlfhandle.Handle) (
keys []kbfscrypto.TLFCryptKey, id tlf.ID, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.log.CDebugf(ctx, "GetTLFCryptKeys(%s)", tlfHandle.GetCanonicalPath())
defer func() { fs.deferLog.CDebugf(ctx, "Done: %+v", err) }()
rmd, err := fs.getMDByHandle(ctx, tlfHandle, FavoritesOpNoChange)
if err != nil {
return nil, tlf.ID{}, err
}
keys, err = fs.config.KeyManager().GetTLFCryptKeyOfAllGenerations(ctx, rmd)
return keys, rmd.TlfID(), err
} | go | func (fs *KBFSOpsStandard) GetTLFCryptKeys(
ctx context.Context, tlfHandle *tlfhandle.Handle) (
keys []kbfscrypto.TLFCryptKey, id tlf.ID, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.log.CDebugf(ctx, "GetTLFCryptKeys(%s)", tlfHandle.GetCanonicalPath())
defer func() { fs.deferLog.CDebugf(ctx, "Done: %+v", err) }()
rmd, err := fs.getMDByHandle(ctx, tlfHandle, FavoritesOpNoChange)
if err != nil {
return nil, tlf.ID{}, err
}
keys, err = fs.config.KeyManager().GetTLFCryptKeyOfAllGenerations(ctx, rmd)
return keys, rmd.TlfID(), err
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetTLFCryptKeys",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfHandle",
"*",
"tlfhandle",
".",
"Handle",
")",
"(",
"keys",
"[",
"]",
"kbfscrypto",
".",
"TLFCryptKey",
",",
"id",
"tlf",
".",
"ID",
",",
"err",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"tlfHandle",
".",
"GetCanonicalPath",
"(",
")",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"fs",
".",
"deferLog",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"}",
"(",
")",
"\n\n",
"rmd",
",",
"err",
":=",
"fs",
".",
"getMDByHandle",
"(",
"ctx",
",",
"tlfHandle",
",",
"FavoritesOpNoChange",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"tlf",
".",
"ID",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"keys",
",",
"err",
"=",
"fs",
".",
"config",
".",
"KeyManager",
"(",
")",
".",
"GetTLFCryptKeyOfAllGenerations",
"(",
"ctx",
",",
"rmd",
")",
"\n",
"return",
"keys",
",",
"rmd",
".",
"TlfID",
"(",
")",
",",
"err",
"\n",
"}"
] | // GetTLFCryptKeys implements the KBFSOps interface for
// KBFSOpsStandard | [
"GetTLFCryptKeys",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L680-L695 |
160,664 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetTLFID | func (fs *KBFSOpsStandard) GetTLFID(ctx context.Context,
tlfHandle *tlfhandle.Handle) (id tlf.ID, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.log.CDebugf(ctx, "GetTLFID(%s)", tlfHandle.GetCanonicalPath())
defer func() { fs.deferLog.CDebugf(ctx, "Done: %+v", err) }()
rmd, err := fs.getMDByHandle(ctx, tlfHandle, FavoritesOpNoChange)
if err != nil {
return tlf.ID{}, err
}
return rmd.TlfID(), err
} | go | func (fs *KBFSOpsStandard) GetTLFID(ctx context.Context,
tlfHandle *tlfhandle.Handle) (id tlf.ID, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.log.CDebugf(ctx, "GetTLFID(%s)", tlfHandle.GetCanonicalPath())
defer func() { fs.deferLog.CDebugf(ctx, "Done: %+v", err) }()
rmd, err := fs.getMDByHandle(ctx, tlfHandle, FavoritesOpNoChange)
if err != nil {
return tlf.ID{}, err
}
return rmd.TlfID(), err
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetTLFID",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfHandle",
"*",
"tlfhandle",
".",
"Handle",
")",
"(",
"id",
"tlf",
".",
"ID",
",",
"err",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"tlfHandle",
".",
"GetCanonicalPath",
"(",
")",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"fs",
".",
"deferLog",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"}",
"(",
")",
"\n\n",
"rmd",
",",
"err",
":=",
"fs",
".",
"getMDByHandle",
"(",
"ctx",
",",
"tlfHandle",
",",
"FavoritesOpNoChange",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tlf",
".",
"ID",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"rmd",
".",
"TlfID",
"(",
")",
",",
"err",
"\n",
"}"
] | // GetTLFID implements the KBFSOps interface for KBFSOpsStandard. | [
"GetTLFID",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L698-L711 |
160,665 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetTLFHandle | func (fs *KBFSOpsStandard) GetTLFHandle(ctx context.Context, node Node) (
*tlfhandle.Handle, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.GetTLFHandle(ctx, node)
} | go | func (fs *KBFSOpsStandard) GetTLFHandle(ctx context.Context, node Node) (
*tlfhandle.Handle, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.GetTLFHandle(ctx, node)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetTLFHandle",
"(",
"ctx",
"context",
".",
"Context",
",",
"node",
"Node",
")",
"(",
"*",
"tlfhandle",
".",
"Handle",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"node",
")",
"\n",
"return",
"ops",
".",
"GetTLFHandle",
"(",
"ctx",
",",
"node",
")",
"\n",
"}"
] | // GetTLFHandle implements the KBFSOps interface for KBFSOpsStandard. | [
"GetTLFHandle",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L714-L721 |
160,666 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetOrCreateRootNode | func (fs *KBFSOpsStandard) GetOrCreateRootNode(
ctx context.Context, h *tlfhandle.Handle, branch data.BranchName) (
node Node, ei data.EntryInfo, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.getMaybeCreateRootNode(ctx, h, branch, true)
} | go | func (fs *KBFSOpsStandard) GetOrCreateRootNode(
ctx context.Context, h *tlfhandle.Handle, branch data.BranchName) (
node Node, ei data.EntryInfo, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.getMaybeCreateRootNode(ctx, h, branch, true)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetOrCreateRootNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"h",
"*",
"tlfhandle",
".",
"Handle",
",",
"branch",
"data",
".",
"BranchName",
")",
"(",
"node",
"Node",
",",
"ei",
"data",
".",
"EntryInfo",
",",
"err",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"return",
"fs",
".",
"getMaybeCreateRootNode",
"(",
"ctx",
",",
"h",
",",
"branch",
",",
"true",
")",
"\n",
"}"
] | // GetOrCreateRootNode implements the KBFSOps interface for
// KBFSOpsStandard | [
"GetOrCreateRootNode",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L852-L859 |
160,667 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetDirChildren | func (fs *KBFSOpsStandard) GetDirChildren(ctx context.Context, dir Node) (
map[string]data.EntryInfo, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.GetDirChildren(ctx, dir)
} | go | func (fs *KBFSOpsStandard) GetDirChildren(ctx context.Context, dir Node) (
map[string]data.EntryInfo, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.GetDirChildren(ctx, dir)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetDirChildren",
"(",
"ctx",
"context",
".",
"Context",
",",
"dir",
"Node",
")",
"(",
"map",
"[",
"string",
"]",
"data",
".",
"EntryInfo",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"dir",
")",
"\n",
"return",
"ops",
".",
"GetDirChildren",
"(",
"ctx",
",",
"dir",
")",
"\n",
"}"
] | // GetDirChildren implements the KBFSOps interface for KBFSOpsStandard | [
"GetDirChildren",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L874-L881 |
160,668 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Stat | func (fs *KBFSOpsStandard) Stat(ctx context.Context, node Node) (
data.EntryInfo, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.Stat(ctx, node)
} | go | func (fs *KBFSOpsStandard) Stat(ctx context.Context, node Node) (
data.EntryInfo, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.Stat(ctx, node)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Stat",
"(",
"ctx",
"context",
".",
"Context",
",",
"node",
"Node",
")",
"(",
"data",
".",
"EntryInfo",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"node",
")",
"\n",
"return",
"ops",
".",
"Stat",
"(",
"ctx",
",",
"node",
")",
"\n",
"}"
] | // Stat implements the KBFSOps interface for KBFSOpsStandard | [
"Stat",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L894-L901 |
160,669 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | CreateFile | func (fs *KBFSOpsStandard) CreateFile(
ctx context.Context, dir Node, name string, isExec bool, excl Excl) (
Node, data.EntryInfo, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.CreateFile(ctx, dir, name, isExec, excl)
} | go | func (fs *KBFSOpsStandard) CreateFile(
ctx context.Context, dir Node, name string, isExec bool, excl Excl) (
Node, data.EntryInfo, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.CreateFile(ctx, dir, name, isExec, excl)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"CreateFile",
"(",
"ctx",
"context",
".",
"Context",
",",
"dir",
"Node",
",",
"name",
"string",
",",
"isExec",
"bool",
",",
"excl",
"Excl",
")",
"(",
"Node",
",",
"data",
".",
"EntryInfo",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"dir",
")",
"\n",
"return",
"ops",
".",
"CreateFile",
"(",
"ctx",
",",
"dir",
",",
"name",
",",
"isExec",
",",
"excl",
")",
"\n",
"}"
] | // CreateFile implements the KBFSOps interface for KBFSOpsStandard | [
"CreateFile",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L914-L922 |
160,670 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | RemoveDir | func (fs *KBFSOpsStandard) RemoveDir(
ctx context.Context, dir Node, name string) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.RemoveDir(ctx, dir, name)
} | go | func (fs *KBFSOpsStandard) RemoveDir(
ctx context.Context, dir Node, name string) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.RemoveDir(ctx, dir, name)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"RemoveDir",
"(",
"ctx",
"context",
".",
"Context",
",",
"dir",
"Node",
",",
"name",
"string",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"dir",
")",
"\n",
"return",
"ops",
".",
"RemoveDir",
"(",
"ctx",
",",
"dir",
",",
"name",
")",
"\n",
"}"
] | // RemoveDir implements the KBFSOps interface for KBFSOpsStandard | [
"RemoveDir",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L936-L943 |
160,671 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Rename | func (fs *KBFSOpsStandard) Rename(
ctx context.Context, oldParent Node, oldName string, newParent Node,
newName string) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
oldFB := oldParent.GetFolderBranch()
newFB := newParent.GetFolderBranch()
// only works for nodes within the same topdir
if oldFB != newFB {
return RenameAcrossDirsError{}
}
ops := fs.getOpsByNode(ctx, oldParent)
return ops.Rename(ctx, oldParent, oldName, newParent, newName)
} | go | func (fs *KBFSOpsStandard) Rename(
ctx context.Context, oldParent Node, oldName string, newParent Node,
newName string) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
oldFB := oldParent.GetFolderBranch()
newFB := newParent.GetFolderBranch()
// only works for nodes within the same topdir
if oldFB != newFB {
return RenameAcrossDirsError{}
}
ops := fs.getOpsByNode(ctx, oldParent)
return ops.Rename(ctx, oldParent, oldName, newParent, newName)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Rename",
"(",
"ctx",
"context",
".",
"Context",
",",
"oldParent",
"Node",
",",
"oldName",
"string",
",",
"newParent",
"Node",
",",
"newName",
"string",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"oldFB",
":=",
"oldParent",
".",
"GetFolderBranch",
"(",
")",
"\n",
"newFB",
":=",
"newParent",
".",
"GetFolderBranch",
"(",
")",
"\n\n",
"// only works for nodes within the same topdir",
"if",
"oldFB",
"!=",
"newFB",
"{",
"return",
"RenameAcrossDirsError",
"{",
"}",
"\n",
"}",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"oldParent",
")",
"\n",
"return",
"ops",
".",
"Rename",
"(",
"ctx",
",",
"oldParent",
",",
"oldName",
",",
"newParent",
",",
"newName",
")",
"\n",
"}"
] | // Rename implements the KBFSOps interface for KBFSOpsStandard | [
"Rename",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L956-L972 |
160,672 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Read | func (fs *KBFSOpsStandard) Read(
ctx context.Context, file Node, dest []byte, off int64) (
numRead int64, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Read(ctx, file, dest, off)
} | go | func (fs *KBFSOpsStandard) Read(
ctx context.Context, file Node, dest []byte, off int64) (
numRead int64, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Read(ctx, file, dest, off)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Read",
"(",
"ctx",
"context",
".",
"Context",
",",
"file",
"Node",
",",
"dest",
"[",
"]",
"byte",
",",
"off",
"int64",
")",
"(",
"numRead",
"int64",
",",
"err",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"file",
")",
"\n",
"return",
"ops",
".",
"Read",
"(",
"ctx",
",",
"file",
",",
"dest",
",",
"off",
")",
"\n",
"}"
] | // Read implements the KBFSOps interface for KBFSOpsStandard | [
"Read",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L975-L983 |
160,673 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Write | func (fs *KBFSOpsStandard) Write(
ctx context.Context, file Node, data []byte, off int64) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Write(ctx, file, data, off)
} | go | func (fs *KBFSOpsStandard) Write(
ctx context.Context, file Node, data []byte, off int64) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Write(ctx, file, data, off)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Write",
"(",
"ctx",
"context",
".",
"Context",
",",
"file",
"Node",
",",
"data",
"[",
"]",
"byte",
",",
"off",
"int64",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"file",
")",
"\n",
"return",
"ops",
".",
"Write",
"(",
"ctx",
",",
"file",
",",
"data",
",",
"off",
")",
"\n",
"}"
] | // Write implements the KBFSOps interface for KBFSOpsStandard | [
"Write",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L986-L993 |
160,674 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Truncate | func (fs *KBFSOpsStandard) Truncate(
ctx context.Context, file Node, size uint64) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Truncate(ctx, file, size)
} | go | func (fs *KBFSOpsStandard) Truncate(
ctx context.Context, file Node, size uint64) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Truncate(ctx, file, size)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Truncate",
"(",
"ctx",
"context",
".",
"Context",
",",
"file",
"Node",
",",
"size",
"uint64",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"file",
")",
"\n",
"return",
"ops",
".",
"Truncate",
"(",
"ctx",
",",
"file",
",",
"size",
")",
"\n",
"}"
] | // Truncate implements the KBFSOps interface for KBFSOpsStandard | [
"Truncate",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L996-L1003 |
160,675 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | SetEx | func (fs *KBFSOpsStandard) SetEx(
ctx context.Context, file Node, ex bool) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.SetEx(ctx, file, ex)
} | go | func (fs *KBFSOpsStandard) SetEx(
ctx context.Context, file Node, ex bool) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.SetEx(ctx, file, ex)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"SetEx",
"(",
"ctx",
"context",
".",
"Context",
",",
"file",
"Node",
",",
"ex",
"bool",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"file",
")",
"\n",
"return",
"ops",
".",
"SetEx",
"(",
"ctx",
",",
"file",
",",
"ex",
")",
"\n",
"}"
] | // SetEx implements the KBFSOps interface for KBFSOpsStandard | [
"SetEx",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1006-L1013 |
160,676 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | SetMtime | func (fs *KBFSOpsStandard) SetMtime(
ctx context.Context, file Node, mtime *time.Time) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.SetMtime(ctx, file, mtime)
} | go | func (fs *KBFSOpsStandard) SetMtime(
ctx context.Context, file Node, mtime *time.Time) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.SetMtime(ctx, file, mtime)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"SetMtime",
"(",
"ctx",
"context",
".",
"Context",
",",
"file",
"Node",
",",
"mtime",
"*",
"time",
".",
"Time",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOpsByNode",
"(",
"ctx",
",",
"file",
")",
"\n",
"return",
"ops",
".",
"SetMtime",
"(",
"ctx",
",",
"file",
",",
"mtime",
")",
"\n",
"}"
] | // SetMtime implements the KBFSOps interface for KBFSOpsStandard | [
"SetMtime",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1016-L1023 |
160,677 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | FolderStatus | func (fs *KBFSOpsStandard) FolderStatus(
ctx context.Context, folderBranch data.FolderBranch) (
FolderBranchStatus, <-chan StatusUpdate, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpNoChange)
return ops.FolderStatus(ctx, folderBranch)
} | go | func (fs *KBFSOpsStandard) FolderStatus(
ctx context.Context, folderBranch data.FolderBranch) (
FolderBranchStatus, <-chan StatusUpdate, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpNoChange)
return ops.FolderStatus(ctx, folderBranch)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"FolderStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"folderBranch",
"data",
".",
"FolderBranch",
")",
"(",
"FolderBranchStatus",
",",
"<-",
"chan",
"StatusUpdate",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"ctx",
",",
"folderBranch",
",",
"FavoritesOpNoChange",
")",
"\n",
"return",
"ops",
".",
"FolderStatus",
"(",
"ctx",
",",
"folderBranch",
")",
"\n",
"}"
] | // FolderStatus implements the KBFSOps interface for KBFSOpsStandard | [
"FolderStatus",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1036-L1044 |
160,678 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Status | func (fs *KBFSOpsStandard) Status(ctx context.Context) (
KBFSStatus, <-chan StatusUpdate, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
session, err := fs.config.KBPKI().GetCurrentSession(ctx)
var usageBytes, archiveBytes, limitBytes int64 = -1, -1, -1
var gitUsageBytes, gitArchiveBytes, gitLimitBytes int64 = -1, -1, -1
// Don't request the quota info until we're sure we've
// authenticated with our password. TODO: fix this in the
// service/GUI by handling multiple simultaneous passphrase
// requests at once.
if err == nil && fs.config.MDServer().IsConnected() {
var quErr error
_, usageBytes, archiveBytes, limitBytes,
gitUsageBytes, gitArchiveBytes, gitLimitBytes, quErr =
fs.quotaUsage.GetAllTypes(
ctx, quotaUsageStaleTolerance/2, quotaUsageStaleTolerance)
if quErr != nil {
// The error is ignored here so that other fields can still be populated
// even if this fails.
fs.log.CDebugf(ctx, "Getting quota usage error: %v", quErr)
}
}
failures, ch := fs.currentStatus.CurrentStatus()
var jManagerStatus *JournalManagerStatus
jManager, jErr := GetJournalManager(fs.config)
if jErr == nil {
status, tlfIDs := jManager.Status(ctx)
jManagerStatus = &status
err := FillInJournalStatusUnflushedPaths(
ctx, fs.config, jManagerStatus, tlfIDs)
if err != nil {
// The caller might depend on the channel (e.g., in
// libfs/remote_status.go), even in the case where err !=
// nil.
return KBFSStatus{}, ch, err
}
if usageBytes >= 0 {
usageBytes += status.UnflushedBytes
}
}
dbc := fs.config.DiskBlockCache()
var dbcStatus map[string]DiskBlockCacheStatus
if dbc != nil {
dbcStatus = dbc.Status(ctx)
}
dmc := fs.config.DiskMDCache()
var dmcStatus DiskMDCacheStatus
if dmc != nil {
dmcStatus = dmc.Status(ctx)
}
dqc := fs.config.DiskQuotaCache()
var dqcStatus DiskQuotaCacheStatus
if dqc != nil {
dqcStatus = dqc.Status(ctx)
}
return KBFSStatus{
CurrentUser: session.Name.String(),
IsConnected: fs.config.MDServer().IsConnected(),
UsageBytes: usageBytes,
ArchiveBytes: archiveBytes,
LimitBytes: limitBytes,
GitUsageBytes: gitUsageBytes,
GitArchiveBytes: gitArchiveBytes,
GitLimitBytes: gitLimitBytes,
FailingServices: failures,
JournalManager: jManagerStatus,
DiskBlockCacheStatus: dbcStatus,
DiskMDCacheStatus: dmcStatus,
DiskQuotaCacheStatus: dqcStatus,
}, ch, err
} | go | func (fs *KBFSOpsStandard) Status(ctx context.Context) (
KBFSStatus, <-chan StatusUpdate, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
session, err := fs.config.KBPKI().GetCurrentSession(ctx)
var usageBytes, archiveBytes, limitBytes int64 = -1, -1, -1
var gitUsageBytes, gitArchiveBytes, gitLimitBytes int64 = -1, -1, -1
// Don't request the quota info until we're sure we've
// authenticated with our password. TODO: fix this in the
// service/GUI by handling multiple simultaneous passphrase
// requests at once.
if err == nil && fs.config.MDServer().IsConnected() {
var quErr error
_, usageBytes, archiveBytes, limitBytes,
gitUsageBytes, gitArchiveBytes, gitLimitBytes, quErr =
fs.quotaUsage.GetAllTypes(
ctx, quotaUsageStaleTolerance/2, quotaUsageStaleTolerance)
if quErr != nil {
// The error is ignored here so that other fields can still be populated
// even if this fails.
fs.log.CDebugf(ctx, "Getting quota usage error: %v", quErr)
}
}
failures, ch := fs.currentStatus.CurrentStatus()
var jManagerStatus *JournalManagerStatus
jManager, jErr := GetJournalManager(fs.config)
if jErr == nil {
status, tlfIDs := jManager.Status(ctx)
jManagerStatus = &status
err := FillInJournalStatusUnflushedPaths(
ctx, fs.config, jManagerStatus, tlfIDs)
if err != nil {
// The caller might depend on the channel (e.g., in
// libfs/remote_status.go), even in the case where err !=
// nil.
return KBFSStatus{}, ch, err
}
if usageBytes >= 0 {
usageBytes += status.UnflushedBytes
}
}
dbc := fs.config.DiskBlockCache()
var dbcStatus map[string]DiskBlockCacheStatus
if dbc != nil {
dbcStatus = dbc.Status(ctx)
}
dmc := fs.config.DiskMDCache()
var dmcStatus DiskMDCacheStatus
if dmc != nil {
dmcStatus = dmc.Status(ctx)
}
dqc := fs.config.DiskQuotaCache()
var dqcStatus DiskQuotaCacheStatus
if dqc != nil {
dqcStatus = dqc.Status(ctx)
}
return KBFSStatus{
CurrentUser: session.Name.String(),
IsConnected: fs.config.MDServer().IsConnected(),
UsageBytes: usageBytes,
ArchiveBytes: archiveBytes,
LimitBytes: limitBytes,
GitUsageBytes: gitUsageBytes,
GitArchiveBytes: gitArchiveBytes,
GitLimitBytes: gitLimitBytes,
FailingServices: failures,
JournalManager: jManagerStatus,
DiskBlockCacheStatus: dbcStatus,
DiskMDCacheStatus: dmcStatus,
DiskQuotaCacheStatus: dqcStatus,
}, ch, err
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Status",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"KBFSStatus",
",",
"<-",
"chan",
"StatusUpdate",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"session",
",",
"err",
":=",
"fs",
".",
"config",
".",
"KBPKI",
"(",
")",
".",
"GetCurrentSession",
"(",
"ctx",
")",
"\n",
"var",
"usageBytes",
",",
"archiveBytes",
",",
"limitBytes",
"int64",
"=",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
"\n",
"var",
"gitUsageBytes",
",",
"gitArchiveBytes",
",",
"gitLimitBytes",
"int64",
"=",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
"\n",
"// Don't request the quota info until we're sure we've",
"// authenticated with our password. TODO: fix this in the",
"// service/GUI by handling multiple simultaneous passphrase",
"// requests at once.",
"if",
"err",
"==",
"nil",
"&&",
"fs",
".",
"config",
".",
"MDServer",
"(",
")",
".",
"IsConnected",
"(",
")",
"{",
"var",
"quErr",
"error",
"\n",
"_",
",",
"usageBytes",
",",
"archiveBytes",
",",
"limitBytes",
",",
"gitUsageBytes",
",",
"gitArchiveBytes",
",",
"gitLimitBytes",
",",
"quErr",
"=",
"fs",
".",
"quotaUsage",
".",
"GetAllTypes",
"(",
"ctx",
",",
"quotaUsageStaleTolerance",
"/",
"2",
",",
"quotaUsageStaleTolerance",
")",
"\n",
"if",
"quErr",
"!=",
"nil",
"{",
"// The error is ignored here so that other fields can still be populated",
"// even if this fails.",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"quErr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"failures",
",",
"ch",
":=",
"fs",
".",
"currentStatus",
".",
"CurrentStatus",
"(",
")",
"\n",
"var",
"jManagerStatus",
"*",
"JournalManagerStatus",
"\n",
"jManager",
",",
"jErr",
":=",
"GetJournalManager",
"(",
"fs",
".",
"config",
")",
"\n",
"if",
"jErr",
"==",
"nil",
"{",
"status",
",",
"tlfIDs",
":=",
"jManager",
".",
"Status",
"(",
"ctx",
")",
"\n",
"jManagerStatus",
"=",
"&",
"status",
"\n",
"err",
":=",
"FillInJournalStatusUnflushedPaths",
"(",
"ctx",
",",
"fs",
".",
"config",
",",
"jManagerStatus",
",",
"tlfIDs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// The caller might depend on the channel (e.g., in",
"// libfs/remote_status.go), even in the case where err !=",
"// nil.",
"return",
"KBFSStatus",
"{",
"}",
",",
"ch",
",",
"err",
"\n",
"}",
"\n",
"if",
"usageBytes",
">=",
"0",
"{",
"usageBytes",
"+=",
"status",
".",
"UnflushedBytes",
"\n",
"}",
"\n",
"}",
"\n\n",
"dbc",
":=",
"fs",
".",
"config",
".",
"DiskBlockCache",
"(",
")",
"\n",
"var",
"dbcStatus",
"map",
"[",
"string",
"]",
"DiskBlockCacheStatus",
"\n",
"if",
"dbc",
"!=",
"nil",
"{",
"dbcStatus",
"=",
"dbc",
".",
"Status",
"(",
"ctx",
")",
"\n",
"}",
"\n\n",
"dmc",
":=",
"fs",
".",
"config",
".",
"DiskMDCache",
"(",
")",
"\n",
"var",
"dmcStatus",
"DiskMDCacheStatus",
"\n",
"if",
"dmc",
"!=",
"nil",
"{",
"dmcStatus",
"=",
"dmc",
".",
"Status",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"dqc",
":=",
"fs",
".",
"config",
".",
"DiskQuotaCache",
"(",
")",
"\n",
"var",
"dqcStatus",
"DiskQuotaCacheStatus",
"\n",
"if",
"dqc",
"!=",
"nil",
"{",
"dqcStatus",
"=",
"dqc",
".",
"Status",
"(",
"ctx",
")",
"\n",
"}",
"\n\n",
"return",
"KBFSStatus",
"{",
"CurrentUser",
":",
"session",
".",
"Name",
".",
"String",
"(",
")",
",",
"IsConnected",
":",
"fs",
".",
"config",
".",
"MDServer",
"(",
")",
".",
"IsConnected",
"(",
")",
",",
"UsageBytes",
":",
"usageBytes",
",",
"ArchiveBytes",
":",
"archiveBytes",
",",
"LimitBytes",
":",
"limitBytes",
",",
"GitUsageBytes",
":",
"gitUsageBytes",
",",
"GitArchiveBytes",
":",
"gitArchiveBytes",
",",
"GitLimitBytes",
":",
"gitLimitBytes",
",",
"FailingServices",
":",
"failures",
",",
"JournalManager",
":",
"jManagerStatus",
",",
"DiskBlockCacheStatus",
":",
"dbcStatus",
",",
"DiskMDCacheStatus",
":",
"dmcStatus",
",",
"DiskQuotaCacheStatus",
":",
"dqcStatus",
",",
"}",
",",
"ch",
",",
"err",
"\n",
"}"
] | // Status implements the KBFSOps interface for KBFSOpsStandard | [
"Status",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1047-L1122 |
160,679 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | RequestRekey | func (fs *KBFSOpsStandard) RequestRekey(ctx context.Context, id tlf.ID) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
// We currently only support rekeys of master branches.
ops := fs.getOps(ctx,
data.FolderBranch{Tlf: id, Branch: data.MasterBranch}, FavoritesOpNoChange)
ops.RequestRekey(ctx, id)
} | go | func (fs *KBFSOpsStandard) RequestRekey(ctx context.Context, id tlf.ID) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
// We currently only support rekeys of master branches.
ops := fs.getOps(ctx,
data.FolderBranch{Tlf: id, Branch: data.MasterBranch}, FavoritesOpNoChange)
ops.RequestRekey(ctx, id)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"RequestRekey",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"tlf",
".",
"ID",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"// We currently only support rekeys of master branches.",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"ctx",
",",
"data",
".",
"FolderBranch",
"{",
"Tlf",
":",
"id",
",",
"Branch",
":",
"data",
".",
"MasterBranch",
"}",
",",
"FavoritesOpNoChange",
")",
"\n",
"ops",
".",
"RequestRekey",
"(",
"ctx",
",",
"id",
")",
"\n",
"}"
] | // RequestRekey implements the KBFSOps interface for KBFSOpsStandard | [
"RequestRekey",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1136-L1144 |
160,680 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | SyncFromServer | func (fs *KBFSOpsStandard) SyncFromServer(ctx context.Context,
folderBranch data.FolderBranch, lockBeforeGet *keybase1.LockID) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.SyncFromServer(ctx, folderBranch, lockBeforeGet)
} | go | func (fs *KBFSOpsStandard) SyncFromServer(ctx context.Context,
folderBranch data.FolderBranch, lockBeforeGet *keybase1.LockID) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.SyncFromServer(ctx, folderBranch, lockBeforeGet)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"SyncFromServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"folderBranch",
"data",
".",
"FolderBranch",
",",
"lockBeforeGet",
"*",
"keybase1",
".",
"LockID",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"ctx",
",",
"folderBranch",
",",
"FavoritesOpAdd",
")",
"\n",
"return",
"ops",
".",
"SyncFromServer",
"(",
"ctx",
",",
"folderBranch",
",",
"lockBeforeGet",
")",
"\n",
"}"
] | // SyncFromServer implements the KBFSOps interface for KBFSOpsStandard | [
"SyncFromServer",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1147-L1154 |
160,681 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetUpdateHistory | func (fs *KBFSOpsStandard) GetUpdateHistory(ctx context.Context,
folderBranch data.FolderBranch) (history TLFUpdateHistory, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.GetUpdateHistory(ctx, folderBranch)
} | go | func (fs *KBFSOpsStandard) GetUpdateHistory(ctx context.Context,
folderBranch data.FolderBranch) (history TLFUpdateHistory, err error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.GetUpdateHistory(ctx, folderBranch)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetUpdateHistory",
"(",
"ctx",
"context",
".",
"Context",
",",
"folderBranch",
"data",
".",
"FolderBranch",
")",
"(",
"history",
"TLFUpdateHistory",
",",
"err",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"ctx",
",",
"folderBranch",
",",
"FavoritesOpAdd",
")",
"\n",
"return",
"ops",
".",
"GetUpdateHistory",
"(",
"ctx",
",",
"folderBranch",
")",
"\n",
"}"
] | // GetUpdateHistory implements the KBFSOps interface for KBFSOpsStandard | [
"GetUpdateHistory",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1157-L1164 |
160,682 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetEditHistory | func (fs *KBFSOpsStandard) GetEditHistory(
ctx context.Context, folderBranch data.FolderBranch) (
tlfHistory keybase1.FSFolderEditHistory, err error) {
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.GetEditHistory(ctx, folderBranch)
} | go | func (fs *KBFSOpsStandard) GetEditHistory(
ctx context.Context, folderBranch data.FolderBranch) (
tlfHistory keybase1.FSFolderEditHistory, err error) {
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.GetEditHistory(ctx, folderBranch)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetEditHistory",
"(",
"ctx",
"context",
".",
"Context",
",",
"folderBranch",
"data",
".",
"FolderBranch",
")",
"(",
"tlfHistory",
"keybase1",
".",
"FSFolderEditHistory",
",",
"err",
"error",
")",
"{",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"ctx",
",",
"folderBranch",
",",
"FavoritesOpAdd",
")",
"\n",
"return",
"ops",
".",
"GetEditHistory",
"(",
"ctx",
",",
"folderBranch",
")",
"\n",
"}"
] | // GetEditHistory implements the KBFSOps interface for KBFSOpsStandard | [
"GetEditHistory",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1167-L1172 |
160,683 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetRootNodeMetadata | func (fs *KBFSOpsStandard) GetRootNodeMetadata(
ctx context.Context, folderBranch data.FolderBranch) (
NodeMetadata, *tlfhandle.Handle, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpNoChange)
rootNode, _, _, err := ops.getRootNode(ctx)
if err != nil {
return NodeMetadata{}, nil, err
}
md, err := ops.GetNodeMetadata(ctx, rootNode)
if err != nil {
return NodeMetadata{}, nil, err
}
h, err := ops.GetTLFHandle(ctx, rootNode)
if err != nil {
return NodeMetadata{}, nil, err
}
return md, h, nil
} | go | func (fs *KBFSOpsStandard) GetRootNodeMetadata(
ctx context.Context, folderBranch data.FolderBranch) (
NodeMetadata, *tlfhandle.Handle, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx, folderBranch, FavoritesOpNoChange)
rootNode, _, _, err := ops.getRootNode(ctx)
if err != nil {
return NodeMetadata{}, nil, err
}
md, err := ops.GetNodeMetadata(ctx, rootNode)
if err != nil {
return NodeMetadata{}, nil, err
}
h, err := ops.GetTLFHandle(ctx, rootNode)
if err != nil {
return NodeMetadata{}, nil, err
}
return md, h, nil
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetRootNodeMetadata",
"(",
"ctx",
"context",
".",
"Context",
",",
"folderBranch",
"data",
".",
"FolderBranch",
")",
"(",
"NodeMetadata",
",",
"*",
"tlfhandle",
".",
"Handle",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"ctx",
",",
"folderBranch",
",",
"FavoritesOpNoChange",
")",
"\n",
"rootNode",
",",
"_",
",",
"_",
",",
"err",
":=",
"ops",
".",
"getRootNode",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"NodeMetadata",
"{",
"}",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"md",
",",
"err",
":=",
"ops",
".",
"GetNodeMetadata",
"(",
"ctx",
",",
"rootNode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"NodeMetadata",
"{",
"}",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"h",
",",
"err",
":=",
"ops",
".",
"GetTLFHandle",
"(",
"ctx",
",",
"rootNode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"NodeMetadata",
"{",
"}",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"md",
",",
"h",
",",
"nil",
"\n",
"}"
] | // GetRootNodeMetadata implements the KBFSOps interface for KBFSOpsStandard | [
"GetRootNodeMetadata",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1185-L1206 |
160,684 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | TeamNameChanged | func (fs *KBFSOpsStandard) TeamNameChanged(
ctx context.Context, tid keybase1.TeamID) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.log.CDebugf(ctx, "Got TeamNameChanged for %s", tid)
fbo := fs.findTeamByID(ctx, tid)
if fbo != nil {
go fbo.TeamNameChanged(ctx, tid)
}
} | go | func (fs *KBFSOpsStandard) TeamNameChanged(
ctx context.Context, tid keybase1.TeamID) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.log.CDebugf(ctx, "Got TeamNameChanged for %s", tid)
fbo := fs.findTeamByID(ctx, tid)
if fbo != nil {
go fbo.TeamNameChanged(ctx, tid)
}
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"TeamNameChanged",
"(",
"ctx",
"context",
".",
"Context",
",",
"tid",
"keybase1",
".",
"TeamID",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"tid",
")",
"\n",
"fbo",
":=",
"fs",
".",
"findTeamByID",
"(",
"ctx",
",",
"tid",
")",
"\n",
"if",
"fbo",
"!=",
"nil",
"{",
"go",
"fbo",
".",
"TeamNameChanged",
"(",
"ctx",
",",
"tid",
")",
"\n",
"}",
"\n",
"}"
] | // TeamNameChanged implements the KBFSOps interface for KBFSOpsStandard | [
"TeamNameChanged",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1244-L1254 |
160,685 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | KickoffAllOutstandingRekeys | func (fs *KBFSOpsStandard) KickoffAllOutstandingRekeys() error {
for _, op := range fs.ops {
op.rekeyFSM.Event(newRekeyKickoffEvent())
}
return nil
} | go | func (fs *KBFSOpsStandard) KickoffAllOutstandingRekeys() error {
for _, op := range fs.ops {
op.rekeyFSM.Event(newRekeyKickoffEvent())
}
return nil
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"KickoffAllOutstandingRekeys",
"(",
")",
"error",
"{",
"for",
"_",
",",
"op",
":=",
"range",
"fs",
".",
"ops",
"{",
"op",
".",
"rekeyFSM",
".",
"Event",
"(",
"newRekeyKickoffEvent",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // KickoffAllOutstandingRekeys implements the KBFSOps interface for
// KBFSOpsStandard. | [
"KickoffAllOutstandingRekeys",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1283-L1288 |
160,686 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | NewNotificationChannel | func (fs *KBFSOpsStandard) NewNotificationChannel(
ctx context.Context, handle *tlfhandle.Handle, convID chat1.ConversationID,
channelName string) {
if !fs.config.Mode().TLFEditHistoryEnabled() {
return
}
fs.log.CDebugf(ctx, "New notification channel for %s",
handle.GetCanonicalPath())
// If the FBO already exists, notify it. If the FBO doesn't exist
// yet, we need to create it, so that it shows up in the edit
// history.
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
fav := handle.ToFavorite()
if ops, ok := fs.opsByFav[fav]; ok {
ops.NewNotificationChannel(ctx, handle, convID, channelName)
} else if handle.TlfID() != tlf.NullID {
fs.editActivity.Add(1)
go func() {
defer fs.editActivity.Done()
fs.log.CDebugf(ctx, "Initializing TLF %s for the edit history",
handle.GetCanonicalPath())
ctx := CtxWithRandomIDReplayable(
context.Background(), CtxFBOIDKey, CtxFBOOpID, fs.log)
// Fully initialize the TLF in order to kick off any
// necessary prefetches.
err := fs.initTLFWithoutIdentifyPopups(ctx, handle)
if err != nil {
fs.log.CDebugf(ctx, "Couldn't initialize TLF: %+v", err)
}
}()
} else {
fs.log.CWarningf(ctx,
"Handle %s for existing folder unexpectedly has no TLF ID",
handle.GetCanonicalName())
}
} | go | func (fs *KBFSOpsStandard) NewNotificationChannel(
ctx context.Context, handle *tlfhandle.Handle, convID chat1.ConversationID,
channelName string) {
if !fs.config.Mode().TLFEditHistoryEnabled() {
return
}
fs.log.CDebugf(ctx, "New notification channel for %s",
handle.GetCanonicalPath())
// If the FBO already exists, notify it. If the FBO doesn't exist
// yet, we need to create it, so that it shows up in the edit
// history.
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
fav := handle.ToFavorite()
if ops, ok := fs.opsByFav[fav]; ok {
ops.NewNotificationChannel(ctx, handle, convID, channelName)
} else if handle.TlfID() != tlf.NullID {
fs.editActivity.Add(1)
go func() {
defer fs.editActivity.Done()
fs.log.CDebugf(ctx, "Initializing TLF %s for the edit history",
handle.GetCanonicalPath())
ctx := CtxWithRandomIDReplayable(
context.Background(), CtxFBOIDKey, CtxFBOOpID, fs.log)
// Fully initialize the TLF in order to kick off any
// necessary prefetches.
err := fs.initTLFWithoutIdentifyPopups(ctx, handle)
if err != nil {
fs.log.CDebugf(ctx, "Couldn't initialize TLF: %+v", err)
}
}()
} else {
fs.log.CWarningf(ctx,
"Handle %s for existing folder unexpectedly has no TLF ID",
handle.GetCanonicalName())
}
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"NewNotificationChannel",
"(",
"ctx",
"context",
".",
"Context",
",",
"handle",
"*",
"tlfhandle",
".",
"Handle",
",",
"convID",
"chat1",
".",
"ConversationID",
",",
"channelName",
"string",
")",
"{",
"if",
"!",
"fs",
".",
"config",
".",
"Mode",
"(",
")",
".",
"TLFEditHistoryEnabled",
"(",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"handle",
".",
"GetCanonicalPath",
"(",
")",
")",
"\n\n",
"// If the FBO already exists, notify it. If the FBO doesn't exist",
"// yet, we need to create it, so that it shows up in the edit",
"// history.",
"fs",
".",
"opsLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"fs",
".",
"opsLock",
".",
"Unlock",
"(",
")",
"\n",
"fav",
":=",
"handle",
".",
"ToFavorite",
"(",
")",
"\n",
"if",
"ops",
",",
"ok",
":=",
"fs",
".",
"opsByFav",
"[",
"fav",
"]",
";",
"ok",
"{",
"ops",
".",
"NewNotificationChannel",
"(",
"ctx",
",",
"handle",
",",
"convID",
",",
"channelName",
")",
"\n",
"}",
"else",
"if",
"handle",
".",
"TlfID",
"(",
")",
"!=",
"tlf",
".",
"NullID",
"{",
"fs",
".",
"editActivity",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"fs",
".",
"editActivity",
".",
"Done",
"(",
")",
"\n",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"handle",
".",
"GetCanonicalPath",
"(",
")",
")",
"\n",
"ctx",
":=",
"CtxWithRandomIDReplayable",
"(",
"context",
".",
"Background",
"(",
")",
",",
"CtxFBOIDKey",
",",
"CtxFBOOpID",
",",
"fs",
".",
"log",
")",
"\n",
"// Fully initialize the TLF in order to kick off any",
"// necessary prefetches.",
"err",
":=",
"fs",
".",
"initTLFWithoutIdentifyPopups",
"(",
"ctx",
",",
"handle",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"else",
"{",
"fs",
".",
"log",
".",
"CWarningf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"handle",
".",
"GetCanonicalName",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // NewNotificationChannel implements the KBFSOps interface for
// KBFSOpsStandard. | [
"NewNotificationChannel",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1313-L1351 |
160,687 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | Reset | func (fs *KBFSOpsStandard) Reset(
ctx context.Context, handle *tlfhandle.Handle) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
// First, make sure the folder has been reset according to the
// mdserver.
bareHandle, err := handle.ToBareHandle()
if err != nil {
return err
}
id, _, err := fs.config.MDServer().GetForHandle(
ctx, bareHandle, kbfsmd.Merged, nil)
if err == nil {
fs.log.CDebugf(ctx, "Folder %s can't be reset; still has ID %s",
handle.GetCanonicalPath(), id)
return errors.WithStack(FolderNotResetOnServer{handle})
} else if _, ok := errors.Cause(err).(kbfsmd.ServerErrorClassicTLFDoesNotExist); !ok {
// Return errors if they don't indicate the folder is new.
return err
}
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
fs.log.CDebugf(ctx, "Reset %s", handle.GetCanonicalPath())
fb := data.FolderBranch{Tlf: handle.TlfID(), Branch: data.MasterBranch}
ops, ok := fs.ops[fb]
if ok {
err := ops.Reset(ctx, handle)
if err != nil {
return err
}
delete(fs.ops, fb)
fav := handle.ToFavorite()
delete(fs.opsByFav, fav)
err = ops.Shutdown(ctx)
if err != nil {
return err
}
}
// Reset the TLF by overwriting the TLF ID in the sigchain. This
// assumes that the server is in implicit team mode for new TLFs,
// which at this point it should always be.
return fs.resetTlfID(ctx, handle)
} | go | func (fs *KBFSOpsStandard) Reset(
ctx context.Context, handle *tlfhandle.Handle) error {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
// First, make sure the folder has been reset according to the
// mdserver.
bareHandle, err := handle.ToBareHandle()
if err != nil {
return err
}
id, _, err := fs.config.MDServer().GetForHandle(
ctx, bareHandle, kbfsmd.Merged, nil)
if err == nil {
fs.log.CDebugf(ctx, "Folder %s can't be reset; still has ID %s",
handle.GetCanonicalPath(), id)
return errors.WithStack(FolderNotResetOnServer{handle})
} else if _, ok := errors.Cause(err).(kbfsmd.ServerErrorClassicTLFDoesNotExist); !ok {
// Return errors if they don't indicate the folder is new.
return err
}
fs.opsLock.Lock()
defer fs.opsLock.Unlock()
fs.log.CDebugf(ctx, "Reset %s", handle.GetCanonicalPath())
fb := data.FolderBranch{Tlf: handle.TlfID(), Branch: data.MasterBranch}
ops, ok := fs.ops[fb]
if ok {
err := ops.Reset(ctx, handle)
if err != nil {
return err
}
delete(fs.ops, fb)
fav := handle.ToFavorite()
delete(fs.opsByFav, fav)
err = ops.Shutdown(ctx)
if err != nil {
return err
}
}
// Reset the TLF by overwriting the TLF ID in the sigchain. This
// assumes that the server is in implicit team mode for new TLFs,
// which at this point it should always be.
return fs.resetTlfID(ctx, handle)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"Reset",
"(",
"ctx",
"context",
".",
"Context",
",",
"handle",
"*",
"tlfhandle",
".",
"Handle",
")",
"error",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"// First, make sure the folder has been reset according to the",
"// mdserver.",
"bareHandle",
",",
"err",
":=",
"handle",
".",
"ToBareHandle",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"id",
",",
"_",
",",
"err",
":=",
"fs",
".",
"config",
".",
"MDServer",
"(",
")",
".",
"GetForHandle",
"(",
"ctx",
",",
"bareHandle",
",",
"kbfsmd",
".",
"Merged",
",",
"nil",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"handle",
".",
"GetCanonicalPath",
"(",
")",
",",
"id",
")",
"\n",
"return",
"errors",
".",
"WithStack",
"(",
"FolderNotResetOnServer",
"{",
"handle",
"}",
")",
"\n",
"}",
"else",
"if",
"_",
",",
"ok",
":=",
"errors",
".",
"Cause",
"(",
"err",
")",
".",
"(",
"kbfsmd",
".",
"ServerErrorClassicTLFDoesNotExist",
")",
";",
"!",
"ok",
"{",
"// Return errors if they don't indicate the folder is new.",
"return",
"err",
"\n",
"}",
"\n\n",
"fs",
".",
"opsLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"fs",
".",
"opsLock",
".",
"Unlock",
"(",
")",
"\n",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"handle",
".",
"GetCanonicalPath",
"(",
")",
")",
"\n",
"fb",
":=",
"data",
".",
"FolderBranch",
"{",
"Tlf",
":",
"handle",
".",
"TlfID",
"(",
")",
",",
"Branch",
":",
"data",
".",
"MasterBranch",
"}",
"\n",
"ops",
",",
"ok",
":=",
"fs",
".",
"ops",
"[",
"fb",
"]",
"\n",
"if",
"ok",
"{",
"err",
":=",
"ops",
".",
"Reset",
"(",
"ctx",
",",
"handle",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"delete",
"(",
"fs",
".",
"ops",
",",
"fb",
")",
"\n",
"fav",
":=",
"handle",
".",
"ToFavorite",
"(",
")",
"\n",
"delete",
"(",
"fs",
".",
"opsByFav",
",",
"fav",
")",
"\n",
"err",
"=",
"ops",
".",
"Shutdown",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Reset the TLF by overwriting the TLF ID in the sigchain. This",
"// assumes that the server is in implicit team mode for new TLFs,",
"// which at this point it should always be.",
"return",
"fs",
".",
"resetTlfID",
"(",
"ctx",
",",
"handle",
")",
"\n",
"}"
] | // Reset implements the KBFSOps interface for KBFSOpsStandard. | [
"Reset",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1354-L1399 |
160,688 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | ClearConflictView | func (fs *KBFSOpsStandard) ClearConflictView(ctx context.Context,
tlfID tlf.ID) error {
fbo := fs.getOpsNoAdd(ctx, data.FolderBranch{
Tlf: tlfID,
Branch: data.MasterBranch,
})
return fbo.clearConflictView(ctx)
} | go | func (fs *KBFSOpsStandard) ClearConflictView(ctx context.Context,
tlfID tlf.ID) error {
fbo := fs.getOpsNoAdd(ctx, data.FolderBranch{
Tlf: tlfID,
Branch: data.MasterBranch,
})
return fbo.clearConflictView(ctx)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"ClearConflictView",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
")",
"error",
"{",
"fbo",
":=",
"fs",
".",
"getOpsNoAdd",
"(",
"ctx",
",",
"data",
".",
"FolderBranch",
"{",
"Tlf",
":",
"tlfID",
",",
"Branch",
":",
"data",
".",
"MasterBranch",
",",
"}",
")",
"\n",
"return",
"fbo",
".",
"clearConflictView",
"(",
"ctx",
")",
"\n",
"}"
] | // ClearConflictView resets a TLF's jounral and conflict DB to a non
// -conflicting state. | [
"ClearConflictView",
"resets",
"a",
"TLF",
"s",
"jounral",
"and",
"conflict",
"DB",
"to",
"a",
"non",
"-",
"conflicting",
"state",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1403-L1410 |
160,689 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | GetSyncConfig | func (fs *KBFSOpsStandard) GetSyncConfig(
ctx context.Context, tlfID tlf.ID) (keybase1.FolderSyncConfig, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx,
data.FolderBranch{Tlf: tlfID, Branch: data.MasterBranch}, FavoritesOpNoChange)
return ops.GetSyncConfig(ctx, tlfID)
} | go | func (fs *KBFSOpsStandard) GetSyncConfig(
ctx context.Context, tlfID tlf.ID) (keybase1.FolderSyncConfig, error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOps(ctx,
data.FolderBranch{Tlf: tlfID, Branch: data.MasterBranch}, FavoritesOpNoChange)
return ops.GetSyncConfig(ctx, tlfID)
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"GetSyncConfig",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
")",
"(",
"keybase1",
".",
"FolderSyncConfig",
",",
"error",
")",
"{",
"timeTrackerDone",
":=",
"fs",
".",
"longOperationDebugDumper",
".",
"Begin",
"(",
"ctx",
")",
"\n",
"defer",
"timeTrackerDone",
"(",
")",
"\n\n",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"ctx",
",",
"data",
".",
"FolderBranch",
"{",
"Tlf",
":",
"tlfID",
",",
"Branch",
":",
"data",
".",
"MasterBranch",
"}",
",",
"FavoritesOpNoChange",
")",
"\n",
"return",
"ops",
".",
"GetSyncConfig",
"(",
"ctx",
",",
"tlfID",
")",
"\n",
"}"
] | // GetSyncConfig implements the KBFSOps interface for KBFSOpsStandard. | [
"GetSyncConfig",
"implements",
"the",
"KBFSOps",
"interface",
"for",
"KBFSOpsStandard",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1413-L1421 |
160,690 | keybase/client | go/kbfs/libkbfs/kbfs_ops.go | RegisterForChanges | func (fs *KBFSOpsStandard) RegisterForChanges(
folderBranches []data.FolderBranch, obs Observer) error {
for _, fb := range folderBranches {
// TODO: add branch parameter to notifier interface
ops := fs.getOps(context.Background(), fb, FavoritesOpNoChange)
return ops.RegisterForChanges(obs)
}
return nil
} | go | func (fs *KBFSOpsStandard) RegisterForChanges(
folderBranches []data.FolderBranch, obs Observer) error {
for _, fb := range folderBranches {
// TODO: add branch parameter to notifier interface
ops := fs.getOps(context.Background(), fb, FavoritesOpNoChange)
return ops.RegisterForChanges(obs)
}
return nil
} | [
"func",
"(",
"fs",
"*",
"KBFSOpsStandard",
")",
"RegisterForChanges",
"(",
"folderBranches",
"[",
"]",
"data",
".",
"FolderBranch",
",",
"obs",
"Observer",
")",
"error",
"{",
"for",
"_",
",",
"fb",
":=",
"range",
"folderBranches",
"{",
"// TODO: add branch parameter to notifier interface",
"ops",
":=",
"fs",
".",
"getOps",
"(",
"context",
".",
"Background",
"(",
")",
",",
"fb",
",",
"FavoritesOpNoChange",
")",
"\n",
"return",
"ops",
".",
"RegisterForChanges",
"(",
"obs",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // RegisterForChanges implements the Notifer interface for KBFSOpsStandard | [
"RegisterForChanges",
"implements",
"the",
"Notifer",
"interface",
"for",
"KBFSOpsStandard"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbfs_ops.go#L1453-L1461 |
160,691 | keybase/client | go/chat/attachments/utils.go | NewFileReadCloseResetter | func NewFileReadCloseResetter(name string) (ReadCloseResetter, error) {
f := &FileReadCloseResetter{filename: name}
if err := f.open(); err != nil {
return nil, err
}
return f, nil
} | go | func NewFileReadCloseResetter(name string) (ReadCloseResetter, error) {
f := &FileReadCloseResetter{filename: name}
if err := f.open(); err != nil {
return nil, err
}
return f, nil
} | [
"func",
"NewFileReadCloseResetter",
"(",
"name",
"string",
")",
"(",
"ReadCloseResetter",
",",
"error",
")",
"{",
"f",
":=",
"&",
"FileReadCloseResetter",
"{",
"filename",
":",
"name",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"open",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] | // NewFileReadCloseResetter creates a ReadCloseResetter that uses an on-disk file as
// source of data. | [
"NewFileReadCloseResetter",
"creates",
"a",
"ReadCloseResetter",
"that",
"uses",
"an",
"on",
"-",
"disk",
"file",
"as",
"source",
"of",
"data",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/attachments/utils.go#L98-L104 |
160,692 | keybase/client | go/chat/attachments/utils.go | Read | func (f *KbfsReadCloseResetter) Read(p []byte) (int, error) {
content, err := f.client.SimpleFSRead(f.ctx, keybase1.SimpleFSReadArg{
OpID: f.opid,
Offset: atomic.LoadInt64(&f.offset),
Size: len(p),
})
if err != nil {
return 0, err
}
if len(content.Data) == 0 {
// Unfortunately SimpleFSRead doesn't return EOF error.
return 0, io.EOF
}
atomic.AddInt64(&f.offset, int64(len(content.Data)))
copy(p, content.Data)
return len(content.Data), nil
} | go | func (f *KbfsReadCloseResetter) Read(p []byte) (int, error) {
content, err := f.client.SimpleFSRead(f.ctx, keybase1.SimpleFSReadArg{
OpID: f.opid,
Offset: atomic.LoadInt64(&f.offset),
Size: len(p),
})
if err != nil {
return 0, err
}
if len(content.Data) == 0 {
// Unfortunately SimpleFSRead doesn't return EOF error.
return 0, io.EOF
}
atomic.AddInt64(&f.offset, int64(len(content.Data)))
copy(p, content.Data)
return len(content.Data), nil
} | [
"func",
"(",
"f",
"*",
"KbfsReadCloseResetter",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"content",
",",
"err",
":=",
"f",
".",
"client",
".",
"SimpleFSRead",
"(",
"f",
".",
"ctx",
",",
"keybase1",
".",
"SimpleFSReadArg",
"{",
"OpID",
":",
"f",
".",
"opid",
",",
"Offset",
":",
"atomic",
".",
"LoadInt64",
"(",
"&",
"f",
".",
"offset",
")",
",",
"Size",
":",
"len",
"(",
"p",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"content",
".",
"Data",
")",
"==",
"0",
"{",
"// Unfortunately SimpleFSRead doesn't return EOF error.",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"atomic",
".",
"AddInt64",
"(",
"&",
"f",
".",
"offset",
",",
"int64",
"(",
"len",
"(",
"content",
".",
"Data",
")",
")",
")",
"\n",
"copy",
"(",
"p",
",",
"content",
".",
"Data",
")",
"\n",
"return",
"len",
"(",
"content",
".",
"Data",
")",
",",
"nil",
"\n",
"}"
] | // Read implements the ReadCloseResetter interface. | [
"Read",
"implements",
"the",
"ReadCloseResetter",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/attachments/utils.go#L204-L220 |
160,693 | keybase/client | go/chat/attachments/utils.go | Close | func (f *KbfsReadCloseResetter) Close() error {
return f.client.SimpleFSClose(f.ctx, f.opid)
} | go | func (f *KbfsReadCloseResetter) Close() error {
return f.client.SimpleFSClose(f.ctx, f.opid)
} | [
"func",
"(",
"f",
"*",
"KbfsReadCloseResetter",
")",
"Close",
"(",
")",
"error",
"{",
"return",
"f",
".",
"client",
".",
"SimpleFSClose",
"(",
"f",
".",
"ctx",
",",
"f",
".",
"opid",
")",
"\n",
"}"
] | // Close implements the ReadCloseResetter interface. | [
"Close",
"implements",
"the",
"ReadCloseResetter",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/attachments/utils.go#L229-L231 |
160,694 | keybase/client | go/chat/attachments/utils.go | NewReadCloseResetter | func NewReadCloseResetter(ctx context.Context, g *libkb.GlobalContext,
p string) (ReadCloseResetter, error) {
if isKbfsPath(p) {
return NewKbfsReadCloseResetter(ctx, g, p)
}
return NewFileReadCloseResetter(p)
} | go | func NewReadCloseResetter(ctx context.Context, g *libkb.GlobalContext,
p string) (ReadCloseResetter, error) {
if isKbfsPath(p) {
return NewKbfsReadCloseResetter(ctx, g, p)
}
return NewFileReadCloseResetter(p)
} | [
"func",
"NewReadCloseResetter",
"(",
"ctx",
"context",
".",
"Context",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"p",
"string",
")",
"(",
"ReadCloseResetter",
",",
"error",
")",
"{",
"if",
"isKbfsPath",
"(",
"p",
")",
"{",
"return",
"NewKbfsReadCloseResetter",
"(",
"ctx",
",",
"g",
",",
"p",
")",
"\n",
"}",
"\n",
"return",
"NewFileReadCloseResetter",
"(",
"p",
")",
"\n",
"}"
] | // NewReadCloseResetter creates a ReadCloseResetter using either on-disk file
// or SimpleFS depending on if p is a KBFS path. | [
"NewReadCloseResetter",
"creates",
"a",
"ReadCloseResetter",
"using",
"either",
"on",
"-",
"disk",
"file",
"or",
"SimpleFS",
"depending",
"on",
"if",
"p",
"is",
"a",
"KBFS",
"path",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/attachments/utils.go#L235-L241 |
160,695 | keybase/client | go/chat/attachments/utils.go | StatOSOrKbfsFile | func StatOSOrKbfsFile(ctx context.Context, g *libkb.GlobalContext, p string) (
fi os.FileInfo, err error) {
if !isKbfsPath(p) {
return os.Stat(p)
}
client, err := makeSimpleFSClientFromGlobalContext(g)
if err != nil {
return nil, err
}
dirent, err := client.SimpleFSStat(ctx, keybase1.SimpleFSStatArg{
Path: keybase1.NewPathWithKbfs(p[len(kbfsPrefix):]),
})
if err != nil {
return nil, err
}
return kbfsFileInfo{dirent: &dirent}, nil
} | go | func StatOSOrKbfsFile(ctx context.Context, g *libkb.GlobalContext, p string) (
fi os.FileInfo, err error) {
if !isKbfsPath(p) {
return os.Stat(p)
}
client, err := makeSimpleFSClientFromGlobalContext(g)
if err != nil {
return nil, err
}
dirent, err := client.SimpleFSStat(ctx, keybase1.SimpleFSStatArg{
Path: keybase1.NewPathWithKbfs(p[len(kbfsPrefix):]),
})
if err != nil {
return nil, err
}
return kbfsFileInfo{dirent: &dirent}, nil
} | [
"func",
"StatOSOrKbfsFile",
"(",
"ctx",
"context",
".",
"Context",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"p",
"string",
")",
"(",
"fi",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"{",
"if",
"!",
"isKbfsPath",
"(",
"p",
")",
"{",
"return",
"os",
".",
"Stat",
"(",
"p",
")",
"\n",
"}",
"\n\n",
"client",
",",
"err",
":=",
"makeSimpleFSClientFromGlobalContext",
"(",
"g",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"dirent",
",",
"err",
":=",
"client",
".",
"SimpleFSStat",
"(",
"ctx",
",",
"keybase1",
".",
"SimpleFSStatArg",
"{",
"Path",
":",
"keybase1",
".",
"NewPathWithKbfs",
"(",
"p",
"[",
"len",
"(",
"kbfsPrefix",
")",
":",
"]",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"kbfsFileInfo",
"{",
"dirent",
":",
"&",
"dirent",
"}",
",",
"nil",
"\n",
"}"
] | // StatOSOrKbfsFile stats the file located at p, using SimpleFSStat if it's a
// KBFS path, or os.Stat if not. | [
"StatOSOrKbfsFile",
"stats",
"the",
"file",
"located",
"at",
"p",
"using",
"SimpleFSStat",
"if",
"it",
"s",
"a",
"KBFS",
"path",
"or",
"os",
".",
"Stat",
"if",
"not",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/attachments/utils.go#L274-L293 |
160,696 | keybase/client | go/engine/puk_upkeep_background.go | NewPerUserKeyUpkeepBackground | func NewPerUserKeyUpkeepBackground(g *libkb.GlobalContext, args *PerUserKeyUpkeepBackgroundArgs) *PerUserKeyUpkeepBackground {
task := NewBackgroundTask(g, &BackgroundTaskArgs{
Name: "PerUserKeyUpkeepBackground",
F: PerUserKeyUpkeepBackgroundRound,
Settings: PerUserKeyUpkeepBackgroundSettings,
testingMetaCh: args.testingMetaCh,
testingRoundResCh: args.testingRoundResCh,
})
return &PerUserKeyUpkeepBackground{
Contextified: libkb.NewContextified(g),
args: args,
// Install the task early so that Shutdown can be called before RunEngine.
task: task,
}
} | go | func NewPerUserKeyUpkeepBackground(g *libkb.GlobalContext, args *PerUserKeyUpkeepBackgroundArgs) *PerUserKeyUpkeepBackground {
task := NewBackgroundTask(g, &BackgroundTaskArgs{
Name: "PerUserKeyUpkeepBackground",
F: PerUserKeyUpkeepBackgroundRound,
Settings: PerUserKeyUpkeepBackgroundSettings,
testingMetaCh: args.testingMetaCh,
testingRoundResCh: args.testingRoundResCh,
})
return &PerUserKeyUpkeepBackground{
Contextified: libkb.NewContextified(g),
args: args,
// Install the task early so that Shutdown can be called before RunEngine.
task: task,
}
} | [
"func",
"NewPerUserKeyUpkeepBackground",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"args",
"*",
"PerUserKeyUpkeepBackgroundArgs",
")",
"*",
"PerUserKeyUpkeepBackground",
"{",
"task",
":=",
"NewBackgroundTask",
"(",
"g",
",",
"&",
"BackgroundTaskArgs",
"{",
"Name",
":",
"\"",
"\"",
",",
"F",
":",
"PerUserKeyUpkeepBackgroundRound",
",",
"Settings",
":",
"PerUserKeyUpkeepBackgroundSettings",
",",
"testingMetaCh",
":",
"args",
".",
"testingMetaCh",
",",
"testingRoundResCh",
":",
"args",
".",
"testingRoundResCh",
",",
"}",
")",
"\n",
"return",
"&",
"PerUserKeyUpkeepBackground",
"{",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
",",
"args",
":",
"args",
",",
"// Install the task early so that Shutdown can be called before RunEngine.",
"task",
":",
"task",
",",
"}",
"\n",
"}"
] | // NewPerUserKeyUpkeepBackground creates a PerUserKeyUpkeepBackground engine. | [
"NewPerUserKeyUpkeepBackground",
"creates",
"a",
"PerUserKeyUpkeepBackground",
"engine",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/engine/puk_upkeep_background.go#L41-L56 |
160,697 | keybase/client | go/kbfs/libfuse/debug_server_file.go | Write | func (f *DebugServerFile) Write(ctx context.Context, req *fuse.WriteRequest,
resp *fuse.WriteResponse) (err error) {
f.fs.log.CDebugf(ctx, "DebugServerFile (enable: %t) Write", f.enable)
defer func() { err = f.fs.processError(ctx, libkbfs.WriteMode, err) }()
if len(req.Data) == 0 {
return nil
}
if f.enable {
portStr := strings.TrimSpace(string(req.Data))
port, err := strconv.ParseUint(portStr, 10, 16)
if err != nil {
return err
}
err = f.fs.enableDebugServer(ctx, uint16(port))
if err != nil {
return err
}
} else {
err := f.fs.disableDebugServer(ctx)
if err != nil {
return err
}
}
resp.Size = len(req.Data)
return nil
} | go | func (f *DebugServerFile) Write(ctx context.Context, req *fuse.WriteRequest,
resp *fuse.WriteResponse) (err error) {
f.fs.log.CDebugf(ctx, "DebugServerFile (enable: %t) Write", f.enable)
defer func() { err = f.fs.processError(ctx, libkbfs.WriteMode, err) }()
if len(req.Data) == 0 {
return nil
}
if f.enable {
portStr := strings.TrimSpace(string(req.Data))
port, err := strconv.ParseUint(portStr, 10, 16)
if err != nil {
return err
}
err = f.fs.enableDebugServer(ctx, uint16(port))
if err != nil {
return err
}
} else {
err := f.fs.disableDebugServer(ctx)
if err != nil {
return err
}
}
resp.Size = len(req.Data)
return nil
} | [
"func",
"(",
"f",
"*",
"DebugServerFile",
")",
"Write",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"*",
"fuse",
".",
"WriteRequest",
",",
"resp",
"*",
"fuse",
".",
"WriteResponse",
")",
"(",
"err",
"error",
")",
"{",
"f",
".",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"f",
".",
"enable",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"err",
"=",
"f",
".",
"fs",
".",
"processError",
"(",
"ctx",
",",
"libkbfs",
".",
"WriteMode",
",",
"err",
")",
"}",
"(",
")",
"\n",
"if",
"len",
"(",
"req",
".",
"Data",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"enable",
"{",
"portStr",
":=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"req",
".",
"Data",
")",
")",
"\n",
"port",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"portStr",
",",
"10",
",",
"16",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"f",
".",
"fs",
".",
"enableDebugServer",
"(",
"ctx",
",",
"uint16",
"(",
"port",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err",
":=",
"f",
".",
"fs",
".",
"disableDebugServer",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"resp",
".",
"Size",
"=",
"len",
"(",
"req",
".",
"Data",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Write implements the fs.HandleWriter interface for DebugServerFile. | [
"Write",
"implements",
"the",
"fs",
".",
"HandleWriter",
"interface",
"for",
"DebugServerFile",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfuse/debug_server_file.go#L46-L74 |
160,698 | keybase/client | go/chat/ephemeral_purger.go | Push | func (pq *priorityQueue) Push(x interface{}) {
pq.Lock()
defer pq.Unlock()
item := x.(*queueItem)
item.index = len(pq.queue)
pq.queue = append(pq.queue, item)
pq.itemMap[item.purgeInfo.ConvID.String()] = item
} | go | func (pq *priorityQueue) Push(x interface{}) {
pq.Lock()
defer pq.Unlock()
item := x.(*queueItem)
item.index = len(pq.queue)
pq.queue = append(pq.queue, item)
pq.itemMap[item.purgeInfo.ConvID.String()] = item
} | [
"func",
"(",
"pq",
"*",
"priorityQueue",
")",
"Push",
"(",
"x",
"interface",
"{",
"}",
")",
"{",
"pq",
".",
"Lock",
"(",
")",
"\n",
"defer",
"pq",
".",
"Unlock",
"(",
")",
"\n\n",
"item",
":=",
"x",
".",
"(",
"*",
"queueItem",
")",
"\n",
"item",
".",
"index",
"=",
"len",
"(",
"pq",
".",
"queue",
")",
"\n",
"pq",
".",
"queue",
"=",
"append",
"(",
"pq",
".",
"queue",
",",
"item",
")",
"\n",
"pq",
".",
"itemMap",
"[",
"item",
".",
"purgeInfo",
".",
"ConvID",
".",
"String",
"(",
")",
"]",
"=",
"item",
"\n",
"}"
] | // Note this method should not be used directly since we only want each
// conversation to appear once in the heap. Use
// `BackgroundEphemeralPurger.update` instead since it handles this as
// intended. | [
"Note",
"this",
"method",
"should",
"not",
"be",
"used",
"directly",
"since",
"we",
"only",
"want",
"each",
"conversation",
"to",
"appear",
"once",
"in",
"the",
"heap",
".",
"Use",
"BackgroundEphemeralPurger",
".",
"update",
"instead",
"since",
"it",
"handles",
"this",
"as",
"intended",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/ephemeral_purger.go#L78-L86 |
160,699 | keybase/client | go/chat/ephemeral_purger.go | initQueue | func (b *BackgroundEphemeralPurger) initQueue(ctx context.Context) {
b.queueLock.Lock()
defer b.queueLock.Unlock()
// Create a new queue
b.pq = newPriorityQueue()
heap.Init(b.pq)
allPurgeInfo, err := b.storage.GetAllPurgeInfo(ctx, b.uid)
if err != nil {
b.Debug(ctx, "unable to get purgeInfo: %v", allPurgeInfo)
}
for _, purgeInfo := range allPurgeInfo {
if purgeInfo.IsActive {
b.updateQueue(purgeInfo)
}
}
} | go | func (b *BackgroundEphemeralPurger) initQueue(ctx context.Context) {
b.queueLock.Lock()
defer b.queueLock.Unlock()
// Create a new queue
b.pq = newPriorityQueue()
heap.Init(b.pq)
allPurgeInfo, err := b.storage.GetAllPurgeInfo(ctx, b.uid)
if err != nil {
b.Debug(ctx, "unable to get purgeInfo: %v", allPurgeInfo)
}
for _, purgeInfo := range allPurgeInfo {
if purgeInfo.IsActive {
b.updateQueue(purgeInfo)
}
}
} | [
"func",
"(",
"b",
"*",
"BackgroundEphemeralPurger",
")",
"initQueue",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"b",
".",
"queueLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"queueLock",
".",
"Unlock",
"(",
")",
"\n\n",
"// Create a new queue",
"b",
".",
"pq",
"=",
"newPriorityQueue",
"(",
")",
"\n",
"heap",
".",
"Init",
"(",
"b",
".",
"pq",
")",
"\n\n",
"allPurgeInfo",
",",
"err",
":=",
"b",
".",
"storage",
".",
"GetAllPurgeInfo",
"(",
"ctx",
",",
"b",
".",
"uid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"b",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"allPurgeInfo",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"purgeInfo",
":=",
"range",
"allPurgeInfo",
"{",
"if",
"purgeInfo",
".",
"IsActive",
"{",
"b",
".",
"updateQueue",
"(",
"purgeInfo",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Read all purgeInfo from disk and startup our queue. | [
"Read",
"all",
"purgeInfo",
"from",
"disk",
"and",
"startup",
"our",
"queue",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/ephemeral_purger.go#L226-L243 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.