id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c160600 | string, err error) {
err = c.Cli.Call(ctx, "keybase.1.crypto.signToString", []interface{}{__arg}, &res)
return
} | |
c160601 | g.Log.Notice("DUMPKEY %s -> %s", name, tmp.Name())
buf := bytes.NewBuffer(b)
io.Copy(tmp, buf)
tmp.Close()
} | |
c160602 | trigger)
s.autoClaimRunnerLock.Lock()
defer s.autoClaimRunnerLock.Unlock()
if s.autoClaimRunner == nil {
s.autoClaimRunner = NewAutoClaimRunner(s.walletState)
}
s.autoClaimRunner.Kick(mctx, trigger)
} | |
c160603 | no badger")
return nil
}
s.badger.SetWalletAccountUnreadCount(ctx, accountID, unread)
return nil
} | |
c160604 | return SpecMiniChatPayments(mctx, s.walletState, payments)
} | |
c160605 | 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
}
retur... | |
c160606 | == 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)
i... | |
c160607 | 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")
} | |
c160608 |
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()
})
re... | |
c160609 | {
// 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"... | |
c160610 | s.walletState.BaseFee(mctx)
} | |
c160611 | return federation.DefaultTestNetClient
}
return federation.DefaultPublicNetClient
} | |
c160612 | []cli.Flag{
cli.BoolFlag{
Name: "a, append",
Usage: "add to existing file",
},
cli.IntFlag{
Name: "b, buffersize",
Value: writeBufSizeDefault,
Usage: "write buffer size",
},
},
}
} | |
c160613 | 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
} | |
c160614 | if el.Status == TrackStatusTracking {
ret.Trackers = append(ret.Trackers, el)
}
}
}
return ret
} | |
c160615 |
wkbNew, rkbNew bool) *ExtraMetadataV3 {
return &ExtraMetadataV3{wkb, rkb, wkbNew, rkbNew}
} | |
c160616 |
if err != nil {
return nil, err
}
return NewExtraMetadataV3(wkb, rkb, extra.wkbNew, extra.rkbNew), nil
} | |
c160617 |
if err != nil {
return nil, err
}
return NewExtraMetadataV3(wkb, rkb, false, false), nil
} | |
c160618 | track of the latest key generation in extra.
return latest, latest + 1
} | |
c160619 | 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 reade... | |
c160620 | != 0 {
return Unmerged
}
return Merged
} | |
c160621 |
}
// 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, cryptKe... | |
c160622 | 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, u... | |
c160623 | kbfscodec.Update(codec, &newMd, md); err != nil {
return nil, err
}
return &newMd, nil
} | |
c160624 | }
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
} | |
c160625 | 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 MD... | |
c160626 |
}
case MDDiskUsageMismatch:
return ServerErrorConflictDiskUsage{
Expected: err.expectedDiskUsage,
Actual: err.actualDiskUsage,
}
default:
return ServerError{Err: err}
}
return nil
} | |
c160627 | return tlf.TeamKeying
}
return md.TlfID().Type().ToKeyingType()
} | |
c160628 | 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()}
}
}
... | |
c160629 | // 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... | |
c160630 | != nil {
return nil, err
}
wRemovalInfo := wkb.Keys.RemoveDevicesNotIn(updatedWriterKeys)
rRemovalInfo := rkb.Keys.RemoveDevicesNotIn(updatedReaderKeys)
return wRemovalInfo.MergeUsers(rRemovalInfo)
} | |
c160631 | rkb, err := md.getTLFKeyBundles(extra)
if err != nil {
return nil, nil, err
}
return wkb.Keys.ToPublicKeys(), rkb.Keys.ToPublicKeys(), nil
} | |
c160632 |
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 := ... | |
c160633 | computedWKBID {
return errors.Errorf("Expected WKB ID %s, got %s",
wkbID, computedWKBID)
}
return nil
} | |
c160634 | computedRKBID {
return errors.Errorf("Expected RKB ID %s, got %s",
rkbID, computedRKBID)
}
return nil
} | |
c160635 | 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
} | |
c160636 | {
return codec.Encode(md.WriterMetadata)
} | |
c160637 | keybase1.UID) {
md.WriterMetadata.LastModifyingWriter = user
} | |
c160638 | []keybase1.SocialAssertion) {
md.WriterMetadata.UnresolvedWriters = writers
} | |
c160639 | []keybase1.UserOrTeamID) {
md.WriterMetadata.Writers = writers
} | |
c160640 | = TLFWriterKeyBundleID{}
md.RKeyBundleID = TLFReaderKeyBundleID{}
} | |
c160641 | tlf.ID) {
md.WriterMetadata.ID = tlf
} | |
c160642 | return ImplicitTeamsVer
}
return SegregatedKeyBundlesVer
} | |
c160643 | {
wkb, _, err := md.getTLFKeyBundles(extra)
if err != nil {
return kbfscrypto.TLFPublicKey{}, err
}
return wkb.TLFPublicKey, nil
} | |
c160644 | len(writers)+len(readers))
users = append(users, writers...)
users = append(users, readers...)
return users
} | |
c160645 | err := md.updateKeyBundles(codec, extra,
updatedWriterKeys, updatedReaderKeys,
ePubKey, ePrivKey, tlfCryptKeys[0])
if err != nil {
return nil, err
}
return []UserDeviceKeyServerHalves{serverHalves}, nil
} | |
c160646 | 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
} | |
c160647 | 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
} | |
c160648 | xp),
logReg: logReg,
Contextified: libkb.NewContextified(g),
}
} | |
c160649 | 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(q... | |
c160650 | != 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
} | |
c160651 | 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)
}
} | |
c160652 | "Forcing fast-forwards for %d folders", len(fs.ops))
for _, fbo := range fs.ops {
fbo.ForceFastForward(ctx)
}
} | |
c160653 | := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.InvalidateNodeAndChildren(ctx, node)
} | |
c160654 | := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.favs.Get(ctx)
} | |
c160655 | := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.favs.GetAll(ctx)
} | |
c160656 | := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.favs.RefreshCache(ctx)
} | |
c160657 | := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
fs.favs.ClearCache(ctx)
} | |
c160658 | if isLoggedIn {
err := fs.favs.Add(ctx, favorites.ToAdd{
Folder: fav,
Data: data,
Created: false,
})
if err != nil {
return err
}
}
return nil
} | |
c160659 | {
fs.favs.setHomeTLFInfo(ctx, info)
} | |
c160660 | {
fbo := fs.getOpsByFav(fav)
if fbo != nil {
fbo.refreshEditHistory()
}
} | |
c160661 | // 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
} | |
c160662 | h *tlfhandle.Handle) error {
if h.TlfID() != tlf.NullID {
return nil
}
return fs.resetTlfID(ctx, h)
} | |
c160663 | 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
} | |
c160664 | 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
} | |
c160665 | timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.GetTLFHandle(ctx, node)
} | |
c160666 | fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
return fs.getMaybeCreateRootNode(ctx, h, branch, true)
} | |
c160667 | {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.GetDirChildren(ctx, dir)
} | |
c160668 | timeTrackerDone()
ops := fs.getOpsByNode(ctx, node)
return ops.Stat(ctx, node)
} | |
c160669 | error) {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.CreateFile(ctx, dir, name, isExec, excl)
} | |
c160670 | timeTrackerDone()
ops := fs.getOpsByNode(ctx, dir)
return ops.RemoveDir(ctx, dir, name)
} | |
c160671 | same topdir
if oldFB != newFB {
return RenameAcrossDirsError{}
}
ops := fs.getOpsByNode(ctx, oldParent)
return ops.Rename(ctx, oldParent, oldName, newParent, newName)
} | |
c160672 | {
timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
defer timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Read(ctx, file, dest, off)
} | |
c160673 | timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Write(ctx, file, data, off)
} | |
c160674 | timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.Truncate(ctx, file, size)
} | |
c160675 | timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.SetEx(ctx, file, ex)
} | |
c160676 | timeTrackerDone()
ops := fs.getOpsByNode(ctx, file)
return ops.SetMtime(ctx, file, mtime)
} | |
c160677 |
ops := fs.getOps(ctx, folderBranch, FavoritesOpNoChange)
return ops.FolderStatus(ctx, folderBranch)
} | |
c160678 |
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 e... | |
c160679 | data.FolderBranch{Tlf: id, Branch: data.MasterBranch}, FavoritesOpNoChange)
ops.RequestRekey(ctx, id)
} | |
c160680 | ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.SyncFromServer(ctx, folderBranch, lockBeforeGet)
} | |
c160681 |
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.GetUpdateHistory(ctx, folderBranch)
} | |
c160682 | keybase1.FSFolderEditHistory, err error) {
ops := fs.getOps(ctx, folderBranch, FavoritesOpAdd)
return ops.GetEditHistory(ctx, folderBranch)
} | |
c160683 | 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
} | |
c160684 | %s", tid)
fbo := fs.findTeamByID(ctx, tid)
if fbo != nil {
go fbo.TeamNameChanged(ctx, tid)
}
} | |
c160685 |
op.rekeyFSM.Event(newRekeyKickoffEvent())
}
return nil
} | |
c160686 | 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(... | |
c160687 | 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 = op... | |
c160688 | tlfID,
Branch: data.MasterBranch,
})
return fbo.clearConflictView(ctx)
} | |
c160689 | data.FolderBranch{Tlf: tlfID, Branch: data.MasterBranch}, FavoritesOpNoChange)
return ops.GetSyncConfig(ctx, tlfID)
} | |
c160690 |
// TODO: add branch parameter to notifier interface
ops := fs.getOps(context.Background(), fb, FavoritesOpNoChange)
return ops.RegisterForChanges(obs)
}
return nil
} | |
c160691 | err := f.open(); err != nil {
return nil, err
}
return f, nil
} | |
c160692 | 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
} | |
c160693 | f.client.SimpleFSClose(f.ctx, f.opid)
} | |
c160694 | NewKbfsReadCloseResetter(ctx, g, p)
}
return NewFileReadCloseResetter(p)
} | |
c160695 | client.SimpleFSStat(ctx, keybase1.SimpleFSStatArg{
Path: keybase1.NewPathWithKbfs(p[len(kbfsPrefix):]),
})
if err != nil {
return nil, err
}
return kbfsFileInfo{dirent: &dirent}, nil
} | |
c160696 | })
return &PerUserKeyUpkeepBackground{
Contextified: libkb.NewContextified(g),
args: args,
// Install the task early so that Shutdown can be called before RunEngine.
task: task,
}
} | |
c160697 | 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
} | |
c160698 | x.(*queueItem)
item.index = len(pq.queue)
pq.queue = append(pq.queue, item)
pq.itemMap[item.purgeInfo.ConvID.String()] = item
} | |
c160699 | get purgeInfo: %v", allPurgeInfo)
}
for _, purgeInfo := range allPurgeInfo {
if purgeInfo.IsActive {
b.updateQueue(purgeInfo)
}
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.