id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c161400 |
a.signingKey = sigKey
if len(deviceName) > 0 {
a.deviceName = deviceName
}
a.nistFactory = NewNISTFactory(g, uv.Uid, deviceID, sigKey)
return nil
} | |
c161401 | err := a.internalUpdateUserVersionDeviceID(uv, deviceID); err != nil {
return err
}
a.encryptionKey = encKey
return nil
} | |
c161402 | a.internalUpdateUserVersionDeviceID(uv, deviceID); err != nil {
return err
}
a.deviceName = deviceName
return nil
} | |
c161403 | nil deviceID")
}
if a.uv.IsNil() && a.deviceID.IsNil() {
a.uv = uv
a.deviceID = deviceID
} else if !a.uv.Eq(uv) {
return errors.New("ActiveDevice.set uid mismatch")
} else if !a.deviceID.Eq(deviceID) {
return errors.New("ActiveDevice.set deviceID mismatch")
}
return nil
} | |
c161404 | ""
a.signingKey = nil
a.encryptionKey = nil
a.nistFactory = nil
a.passphrase = nil
a.provisioningKey = nil
a.secretPromptCancelTimer.Reset()
return nil
} | |
c161405 | defer a.RUnlock()
return a.uv.Uid
} | |
c161406 | m.G().Env.GetUsernameForUID(a.UID())
} | |
c161407 | defer a.RUnlock()
return a.deviceID
} | |
c161408 | if a.signingKey == nil {
return nil, NotFoundError{
Msg: "Not found: device signing key",
}
}
return a.signingKey, nil
} | |
c161409 |
Msg: "Not found: device encryption key",
}
}
return a.encryptionKey, nil
} | |
c161410 | return a.EncryptionKey()
default:
return nil, fmt.Errorf("Invalid type %v", t)
}
} | |
c161411 | a.RUnlock()
return a.uv, a.deviceID, a.deviceName, a.signingKey, a.encryptionKey
} | |
c161412 | func(*kbfssync.LockState)) {
if !bl.locked {
bl.RUnlock(lState)
defer bl.RLock(lState)
}
f(lState)
} | |
c161413 | (now.Before(fbo.identifyTime) || fbo.identifyTime.Add(maxValid).Before(now)) {
fbo.log.CDebugf(nil, "Expiring identify from %v", fbo.identifyTime)
fbo.identifyDone = false
}
} | |
c161414 |
}
if err := fbo.fbm.waitForArchives(ctx); err != nil {
return err
}
close(fbo.shutdownChan)
fbo.cr.Shutdown()
fbo.fbm.shutdown()
fbo.rekeyFSM.Shutdown()
// Wait for all the goroutines to finish, so that we don't have any races
// with logging during test reporting.
fbo.doneWg.Wait()
return nil
} | |
c161415 | fbo.mdWriterLock.Unlock(lState)
return fbo.unmergedBID != kbfsmd.NullBranchID
} | |
c161416 | fbo.mdWriterLock.Lock(lState)
defer fbo.mdWriterLock.Unlock(lState)
journalEnabled := TLFJournalEnabled(fbo.config, fbo.id())
if journalEnabled {
err = fbo.unstageLocked(ctx, lState, moveJournalsAway)
} else {
err = fbo.unstageLocked(ctx, lState, doPruneBranches)
}
if err != nil {
return err
}
return fb... | |
c161417 | != kbfsmd.NullBranchID.String() {
return kbfsmd.RevisionUninitialized, errNoMergedRevWhileStaged
}
if jStatus.RevisionStart == kbfsmd.RevisionUninitialized {
// The journal is empty, so the local head must be the most recent.
return kbfsmd.RevisionUninitialized, nil
} else if jStatus.RevisionStart == kbfsmd.... | |
c161418 | %v %v %v", fbo.head.TlfID(), md.TlfID(), fbo.head.mdID, md.mdID)
return kbfsmd.MDTlfIDMismatch{CurrID: fbo.head.TlfID(), NextID: md.TlfID()}
}
fbo.headStatus = headTrusted
return nil
} | |
c161419 | case nil:
default:
return err
}
err = fbo.blocks.MarkNode(
ctx, lState, currNode, latestMerged, tag, cacheType)
if err != nil {
return err
}
}
// Now mark everything rooted at this path.
currNode, _, err = fbo.Lookup(ctx, currNode, syncedElem)
switch errors.Cause(err).(type) {
ca... | |
c161420 |
return errors.Errorf("setNewInitialHeadLocked unexpectedly called with revision %d", md.Revision())
}
return fbo.setHeadLocked(ctx, lState, md, headTrusted, mdToCommitType(md))
} | |
c161421 | return errors.New("Unexpected non-nil head in setInitialHeadTrustedLocked")
}
return fbo.setHeadLocked(ctx, lState, md, headTrusted, ct)
} | |
c161422 | IncompatibleHandleError{
oldName,
partialResolvedOldHandle.GetCanonicalName(),
newName,
}
}
err = fbo.setHeadLocked(ctx, lState, md, headTrusted, mdToCommitType(md))
if err != nil {
return err
}
if oldName != newName {
fbo.log.CDebugf(ctx, "Handle changed (%s -> %s)",
oldName, newName)
fbo.... | |
c161423 |
}
oldHandle := fbo.head.GetTlfHandle()
newHandle := md.GetTlfHandle()
// The two handles must be the same, since no rekeying is done
// while unmerged.
eq, err := oldHandle.Equals(fbo.config.Codec(), *newHandle)
if err != nil {
return err
}
if !eq {
return errors.Errorf(
"head handle %v unexpectedly... | |
c161424 | {
return errors.New("Unexpected unmerged update in setHeadConflictResolvedLocked")
}
return fbo.setHeadLocked(ctx, lState, md, headTrusted, mdToCommitType(md))
} | |
c161425 | md != (ImmutableRootMetadata{}) {
if rtype != mdReadNoIdentify {
err = fbo.identifyOnce(ctx, md.ReadOnly())
}
return md, err
}
return ImmutableRootMetadata{}, MDWriteNeededInRequest{}
} | |
c161426 | := fbo.getHead(ctx, lState, mdNoCommit)
return md.GetTlfHandle(), nil
} | |
c161427 | nil {
return ImmutableRootMetadata{}, err
}
if mergedMD == (ImmutableRootMetadata{}) {
return ImmutableRootMetadata{},
errors.WithStack(NoMergedMDError{fbo.id()})
}
if md == (ImmutableRootMetadata{}) {
// There are no unmerged MDs for this device, so just use the current head.
md = mergedMD
} else {
... | |
c161428 | use the local head.
lState := makeFBOLockState()
return fbo.getMDForReadHelper(ctx, lState, mdReadNoIdentify)
}
// Otherwise, use the specified revision.
rmd, err := getSingleMD(ctx, fbo.config, fbo.id(), kbfsmd.NullBranchID,
mergedRev, kbfsmd.Merged, nil)
if err != nil {
return ImmutableRootMetadata{}, e... | |
c161429 | NewRekeyPermissionError(md.GetTlfHandle(), session.Name)
}
newMd, err := md.MakeSuccessor(ctx, fbo.config.MetadataVersion(),
fbo.config.Codec(),
fbo.config.KeyManager(), fbo.config.KBPKI(), fbo.config.KBPKI(),
fbo.config, md.mdID, handle.IsWriter(session.UID))
if err != nil {
return nil, kbfscrypto.Verifyi... | |
c161430 | nil {
return nil, data.BlockInfo{}, data.ReadyBlockData{}, err
}
now := config.Clock().Now().UnixNano()
rmd.data.Dir = data.DirEntry{
BlockInfo: info,
EntryInfo: data.EntryInfo{
Type: data.Dir,
Size: uint64(plainSize),
Mtime: now,
Ctime: now,
},
}
prevDiskUsage := rmd.DiskUsage()
rmd.SetDi... | |
c161431 | if fb != fbo.folderBranch {
return WrongOpsError{fbo.folderBranch, fb}
}
// Always identify first when trying to initialize the folder,
// even if we turn out not to be a writer. (We can't rely on
// the identifyOnce call in getMDLocked, because that isn't
// called from the initialization code path wh... | |
c161432 | err is local to this block
// shadowing the err in the surrounding block.
if err != nil {
return data.DirEntry{}, err
}
} else {
// If nodePath has no valid parent, it's just the TLF root, so
// we don't need an identify in this case. Note: we don't
// support FS-based stats for the root directory.
... | |
c161433 | err.(kbfsmd.ServerErrorConflictFolderMapping)
_, isJournal := err.(MDJournalConflictError)
return isConflictRevision || isConflictPrevRoot ||
isConflictDiskUsage || isConditionFailed ||
isConflictFolderMapping || isJournal
} | |
c161434 | tlf.SingleTeam:
return tlfhandle.SingleTeamPathType
default:
panic(fmt.Sprintf("Unknown TLF type: %s", fbo.folderBranch.Tlf.Type()))
}
} | |
c161435 | := fbo.pathFromNodeForRead(dir)
if err != nil {
return "", err
}
return tlfhandle.BuildCanonicalPath(
fbo.PathType(), dirPath.String(), name), nil
} | |
c161436 | notify before we've synced, since it is only
// sending invalidation notifications. At worst the upper layer
// will just have to refresh its cache needlessly.
err = fbo.notifyOneOp(ctx, lState, op, md, false)
if err != nil {
return err
}
return fbo.syncDirUpdateOrSignal(ctx, lState)
} | |
c161437 |
fbo.prepper.cacheBlockInfos(blockInfos)
for _, blockInfo := range blockInfos {
unrefsToAdd[blockInfo.BlockPointer] = true
}
}
// Any referenced blocks that were unreferenced since the last
// sync can just be forgotten about. Note that any updated
// pointers that are unreferenced will be fixed up durin... | |
c161438 | folderBranch}
}
return fbo.doMDWriteWithRetryUnlessCanceled(ctx,
func(lState *kbfssync.LockState) error {
return fbo.syncAllLocked(ctx, lState, NoExcl)
})
} | |
c161439 | {
err := fbo.notifyOneOpLocked(ctx, lState, op, md.ReadOnly(), false)
if err != nil {
return err
}
}
return nil
} | |
c161440 | }
}
nodeMap, _, err := fbo.blocks.SearchForNodes(ctx, fbo.nodeCache,
[]data.BlockPointer{ptr}, newPtrs, md, md.data.Dir.BlockPointer)
if err != nil {
return nil, err
}
n, ok := nodeMap[ptr]
if !ok {
return nil, NodeNotFoundError{ptr}
}
return n, nil
} | |
c161441 | fbo.config, fbo.id(), start, lockBeforeGet)
if err != nil {
return err
}
err = applyFunc(ctx, lState, rmds)
if err != nil {
return err
}
return nil
} | |
c161442 | current branch ID.
unmergedBID := func() kbfsmd.BranchID {
fbo.mdWriterLock.Lock(lState)
defer fbo.mdWriterLock.Unlock(lState)
return fbo.unmergedBID
}()
return getUnmergedMDUpdates(ctx, fbo.config, fbo.id(),
unmergedBID, fbo.getCurrMDRevision(lState))
} | |
c161443 | != nil {
return nil, err
}
err = func() error {
fbo.headLock.Lock(lState)
defer fbo.headLock.Unlock(lState)
err = fbo.setHeadPredecessorLocked(ctx, lState, rmd)
if err != nil {
return err
}
fbo.setLatestMergedRevisionLocked(ctx, lState, rmd.Revision(), true)
return nil
}()
if err != nil {
retu... | |
c161444 |
fbo.mdWriterLock.Lock(lState)
defer fbo.mdWriterLock.Unlock(lState)
return fbo.finalizeResolutionLocked(
ctx, lState, md, bps, newOps, blocksToDelete)
} | |
c161445 | cancelFunc := fbo.newCtxWithFBOID()
defer cancelFunc()
fbo.log.CDebugf(ctx, "Abandoning team %s", tid)
fbo.locallyFinalizeTLF(ctx)
} | |
c161446 | err != nil {
return err
}
// Make sure the new handle contains just a team.
if newHandle.TypeForKeying() != tlf.TeamKeying {
return errors.New("No corresponding implicit team yet")
}
session, err := fbo.config.KBPKI().GetCurrentSession(ctx)
if err != nil {
return err
}
isWriter := true // getMDForMigr... | |
c161447 |
md, _ := fbo.getHead(ctx, lState, mdNoCommit)
name := md.GetTlfHandle().GetCanonicalName()
return fbo.config.UserHistory().GetTlfHistory(name, fbo.id().Type()), nil
} | |
c161448 | // we'll launch another one.
fbo.cancelUpdatesLock.Lock()
defer fbo.cancelUpdatesLock.Unlock()
if fbo.cancelUpdates != nil {
fbo.cancelUpdates()
select {
case <-fbo.updateDoneChan:
case <-ctx.Done():
fbo.log.CDebugf(
ctx, "Context canceled before updater was canceled")
return
}
fbo.config.MDSe... | |
c161449 |
if currHead == (ImmutableRootMetadata{}) {
fbo.log.CDebugf(ctx, "No MD yet")
return
}
fbo.log.CDebugf(ctx, "Current head is revision %d", currHead.Revision())
lState := makeFBOLockState()
// Kick off partial prefetching once the latest merged
// revision is set.
defer func() {
if err == nil {
... | |
c161450 | way of the
// next iteration of the folder.
now := fbo.config.Clock().Now()
finalizedInfo, err := tlf.NewHandleExtension(
tlf.HandleExtensionFinalized, 1, kbname.NormalizedUsername("<unknown>"),
now)
if err != nil {
return err
}
oldHandle.SetFinalizedInfo(finalizedInfo)
// FIXME: This can't be subject to ... | |
c161451 |
config, tlfPath, err = fbo.getProtocolSyncConfigUnlocked(
ctx, lState, md)
}
if err != nil {
return keybase1.FolderSyncConfig{}, err
}
if config.Mode == keybase1.FolderSyncMode_DISABLED ||
md == (ImmutableRootMetadata{}) ||
md.GetTlfHandle().GetCanonicalPath() == tlfPath {
return config, nil
}
// ... | |
c161452 | changes, affectedNodeIDs, err := fbo.blocks.GetInvalidationChangesForNode(
ctx, lState, node)
if err != nil {
return err
}
if len(changes) > 0 {
fbo.observers.batchChanges(ctx, changes, affectedNodeIDs)
}
return nil
} | |
c161453 | while edits are unmonitored")
return
}
fbo.vlog.CLogf(
ctx, libkb.VLog1, "New notification channel: %s %s",
convID, channelName)
fbo.editActivity.Add(1)
select {
case fbo.editChannels <- editChannelActivity{convID, channelName, ""}:
case <-monitoringCh:
fbo.editActivity.Done()
fbo.log.CDebugf(ctx, "Ed... | |
c161454 | call.ID
enc := json.NewEncoder(wr)
if indent {
enc.SetIndent("", " ")
}
return enc.Encode(reply)
} | |
c161455 | case any fields are required.
return opts.Check()
}
if err := json.Unmarshal(c.Params.Options, opts); err != nil {
return err
}
return opts.Check()
} | |
c161456 | GetBlockRes, err error) {
err = c.Cli.Call(ctx, "kbgitkbfs.1.DiskBlockCache.GetBlock", []interface{}{__arg}, &res)
return
} | |
c161457 | "kbgitkbfs.1.DiskBlockCache.GetPrefetchStatus", []interface{}{__arg}, &res)
return
} | |
c161458 | (err error) {
err = c.Cli.Call(ctx, "kbgitkbfs.1.DiskBlockCache.PutBlock", []interface{}{__arg}, nil)
return
} | |
c161459 | = c.Cli.Call(ctx, "kbgitkbfs.1.DiskBlockCache.DeleteBlocks", []interface{}{__arg}, &res)
return
} | |
c161460 | (err error) {
err = c.Cli.Call(ctx, "kbgitkbfs.1.DiskBlockCache.UpdateBlockMetadata", []interface{}{__arg}, nil)
return
} | |
c161461 | < 1 {
return ""
}
return strings.TrimSpace(lines[0])
} | |
c161462 | nil {
return "", fmt.Errorf("Nil result")
}
return strings.TrimSpace(string(result)), nil
} | |
c161463 | == nil || !m.options.ForceMount {
return err
}
// Mount failed, let's try to unmount and then try mounting again, even
// if unmounting errors here.
m.Unmount()
// In case we are on darwin, ask the installer to reinstall the mount dir
// and try again as the last resort. This specifically fixes a situation
... | |
c161464 | panic(fmt.Sprintf("Bad BServer request detected: err=%s, blockPtr=%s",
err, blockPtr))
}
return err
}
return assembleBlock(
ctx, bg.config.keyGetter(), bg.config.Codec(), bg.config.cryptoPure(),
kmd, blockPtr, block, buf, blockServerHalf)
} | |
c161465 | return
}
entry.refCount--
if entry.refCount <= 0 {
delete(ncs.nodes, ref)
}
} | |
c161466 | return nil, ParentNodeNotFoundError{ref}
}
if nodeStandard.core != entry.core {
return nil, ParentNodeNotFoundError{ref}
}
return nodeStandard, nil
} | |
c161467 | to make room for the new node.
if parent != nil && entry.core.parent == nil {
delete(ncs.nodes, ptr.Ref())
} else {
return ncs.makeNodeStandardForEntryLocked(entry), nil
}
}
if parent != nil {
// Make sure a child can be made for this parent.
_, err := ncs.newChildForParentLocked(parent)
if err !=... | |
c161468 |
ncs.lock.Lock()
defer ncs.lock.Unlock()
rootWrappers = ncs.rootWrappers
entry, ok := ncs.nodes[ref]
if !ok {
return nil
}
ns := ncs.makeNodeStandardForEntryLocked(entry)
parent = ns.core.parent // get while under lock
return ns
} | |
c161469 | return nil
}
// Cannot update the pointer for an unlinked node.
if entry.core.cachedPath.IsValid() {
return nil
}
entry.core.pathNode.BlockPointer = newPtr
delete(ncs.nodes, oldRef)
ncs.nodes[newPtr.Ref()] = entry
return entry.core
} | |
c161470 |
}
newParentNS, err := ncs.newChildForParentLocked(newParent)
if err != nil {
return nil, err
}
oldParent := entry.core.parent
oldName := entry.core.pathNode.Name
entry.core.parent = newParentNS
entry.core.pathNode.Name = newName
return func() {
entry.core.parent = oldParent
entry.core.pathNode.Name ... | |
c161471 | oldParent := entry.core.parent
oldName := entry.core.pathNode.Name
entry.core.cachedPath = oldPath
entry.core.cachedDe = oldDe
entry.core.parent = nil
entry.core.pathNode.Name = ""
return func() {
entry.core.cachedPath = data.Path{}
entry.core.cachedDe = data.DirEntry{}
entry.core.parent = oldParent
en... | |
c161472 |
ns, ok := node.Unwrap().(*nodeStandard)
if !ok {
return false
}
return ns.core.cachedPath.IsValid()
} | |
c161473 |
defer ncs.lock.RUnlock()
ns, ok := node.Unwrap().(*nodeStandard)
if !ok {
return data.DirEntry{}
}
return ns.core.cachedDe
} | |
c161474 | node.Unwrap().(*nodeStandard)
if !ok {
return
}
ns.core.cachedDe = newDe
} | |
c161475 | }
p.Path = append(p.Path, *core.pathNode)
if core.parent != nil {
ns = core.parent.Unwrap().(*nodeStandard)
} else {
break
}
}
// need to reverse the path nodes
for i := len(p.Path)/2 - 1; i >= 0; i-- {
opp := len(p.Path) - 1 - i
p.Path[i], p.Path[opp] = p.Path[opp], p.Path[i]
}
// TODO: woul... | |
c161476 | range ncs.nodes {
nodes = append(nodes, ncs.makeNodeStandardForEntryLocked(entry))
}
return nodes
} | |
c161477 | for), include it in the
// list.
parentID := parent.GetID()
if parentID == n.GetID() || entryIDs[parentID] {
nodes = append(nodes, ncs.makeNodeStandardForEntryLocked(entry))
for _, id := range pathIDs {
entryIDs[id] = true
}
entryIDs[entry.core] = true
break
}
// Otherwise, rem... | |
c161478 | if err != nil {
return false, err
}
offline := keybase1.OfflineAvailability_NONE
if osg != nil {
offline = osg.OfflineAvailabilityForID(h.TlfID())
}
isWriter, err := kbpki.IsTeamWriter(
ctx, tid, session.UID, session.VerifyingKey, offline)
if err != nil {
return false, err
}
return isWrite... | |
c161479 |
return original, nil
}
isWriter, err := IsWriter(ctx, kbpki, osg, h)
if err != nil {
return 0, err
}
if isWriter {
original |= 0200
}
return original, nil
} | |
c161480 | := decryptMDPrivateData(ctx, config.Codec(), config.Crypto(),
config.BlockCache(), config.BlockOps(), config.KeyManager(),
config.KBPKI(), config, config.Mode(), uid,
rmd.GetSerializedPrivateMetadata(), rmd, rmd, j.jManager.log)
if err != nil {
return ImmutableRootMetadata{}, err
}
rmd.data = pmd
irmd := ... | |
c161481 | {
return id, nil
}
// Create the journal if needed, while we have access to `handle`.
_, _ = j.jManager.getTLFJournal(id, handle)
return id, nil
} | |
c161482 |
if ckf := u.GetComputedKeyFamily(); ckf != nil {
ret = ckf.GetActivePGPKeys(sibkey)
}
return
} | |
c161483 | var res []*PGPKeyBundle
for _, k := range keys {
if KeyMatchesQuery(k, query, false) {
res = append(res, k)
}
}
return res
} | |
c161484 | := u.GetComputedKeyFamily()
if ckf == nil {
m.Debug("| short-circuit; no Computed key family")
return nil, nil
}
keys = ss.AllActiveKeys(ckf)
return keys, nil
} | |
c161485 | if err != nil {
return nil, fmt.Errorf("error determining link %v", c.GetSeqno())
}
if high {
res = append(res, c.GetSeqno())
}
}
return res, nil
} | |
c161486 | err = NoSigChainError{}
return
}
err = u.sigChain().LocalDelegate(u.keyFamily, key, sigID, kid, isSibkey, merkleHashMeta, firstAppearedUnverified)
if isEldest {
eldestKID := key.GetKID()
u.leaf.eldest = eldestKID
}
return
} | |
c161487 | bool) {
u.SigChainBumpMT(MerkleTriple{LinkID: linkID, SigID: sigID}, isHighDelegator)
} | |
c161488 | if ckf == nil {
return false
}
_, err := ckf.GetSibkeyForDevice(did)
if err != nil {
return false
}
return true
} | |
c161489 | ckf != nil {
ret.ckfShallowCopy = ckf.ShallowCopy()
ret.keyFamily = ckf.kf
} else if u.keyFamily != nil {
ret.keyFamily = u.keyFamily.ShallowCopy()
}
return ret
} | |
c161490 | "keybase.1.identify.resolveImplicitTeam", []interface{}{__arg}, &res)
return
} | |
c161491 | cl.ChooseCommand(&CmdLogProfile{Contextified: libkb.NewContextified(g)}, "profile", c)
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "p, path",
Usage: "Path of logfile to process.",
},
},
}
} | |
c161492 | := metrics.GetOrRegisterTimer("KeybaseService.FavoriteList", r)
encryptFavoritesTimer := metrics.GetOrRegisterTimer("KeybaseService."+
"EncryptFavorites", r)
decryptFavoritesTimer := metrics.GetOrRegisterTimer("KeybaseService."+
"DecryptFavorites", r)
notifyTimer := metrics.GetOrRegisterTimer("KeybaseService.No... | |
c161493 | kbname.NormalizedUsername, uid keybase1.UserOrTeamID, err error) {
k.resolveTimer.Time(func() {
name, uid, err = k.delegate.Resolve(ctx, assertion, offline)
})
return name, uid, err
} | |
c161494 | kbname.NormalizedUsername, id keybase1.UserOrTeamID, err error) {
k.identifyTimer.Time(func() {
name, id, err = k.delegate.Identify(ctx, assertion, reason, offline)
})
return name, id, err
} | |
c161495 | err = k.delegate.NormalizeSocialAssertion(
ctx, assertion)
})
return res, err
} | |
c161496 | {
info, err = k.delegate.ResolveIdentifyImplicitTeam(
ctx, assertions, suffix, tlfType, doIdentifies, reason, offline)
})
return info, err
} | |
c161497 | name, err = k.delegate.ResolveImplicitTeamByID(ctx, teamID)
})
return name, err
} | |
c161498 | userInfo, err = k.delegate.LoadUserPlusKeys(
ctx, uid, pollForKID, offline)
})
return userInfo, err
} | |
c161499 | desiredRole keybase1.TeamRole, offline keybase1.OfflineAvailability) (
teamInfo idutil.TeamInfo, err error) {
k.loadTeamPlusKeysTimer.Time(func() {
teamInfo, err = k.delegate.LoadTeamPlusKeys(
ctx, tid, tlfType, desiredKeyGen, desiredUser, desiredKey,
desiredRole, offline)
})
return teamInfo, err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.