id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c160400 | if err != nil {
return arg2, err
}
arg2 = keybase1.Hello2Arg{
Uid: arg1.Uid,
Token: arg1.Token,
Csrf: arg1.Csrf,
SigBody: arg1.SigBody,
}
return arg2, nil
} | |
c160401 | some device information for ProvisionUI.ProvisionerSuccess()
if err = e.rememberDeviceInfo(e.proof); err != nil {
return nil, err
}
// sign the whole thing with provisioner's signing key
s, _, _, err := libkb.SignJSON(e.proof, e.signingKey)
if err != nil {
return nil, err
}
return []byte(s), nil
} | |
c160402 | return output, err
}
userEKBoxStorage := m.G().GetUserEKBoxStorage()
if input.DeviceEkKID.Exists() && userEKBoxStorage != nil {
// If we error out here the provisionee will create it's own keys later
// but we shouldn't fail kex.
userEKBox, ekErr := makeUserEKBoxForProvisionee(m, input.DeviceEkKID)
if ekEr... | |
c160403 | e.signingKey,
Me: e.me,
DelegationType: libkb.DelegationTypeSibkey,
Expire: libkb.NaclEdDSAExpireIn,
Contextified: libkb.NewContextified(e.G()),
}
e.proof, err = libkb.KeyProof(m, delg)
if err != nil {
return "", err
}
body, err := e.proof.Marshal()
if err != nil {
return "", ... | |
c160404 | jw.AtPath("body.device.type").GetString()
if err != nil {
return err
}
e.provisioneeDeviceType = dtype
return nil
} | |
c160405 | err != nil {
return nil, err
}
if !pukring.HasAnyKeys() {
return nil, nil
}
return pukring, nil
} | |
c160406 |
readyBlockData.ServerHalf)
if err != nil {
return err
}
if _, isDir := block.(*data.DirBlock); isDir {
bps.isDir[blockPtr] = true
}
return bps.blockPutStateMemory.AddNewBlock(
ctx, blockPtr, nil, data.ReadyBlockData{}, syncedCb)
} | |
c160407 | ad := NewProvisionalActiveDevice(m, uv, d, sigKey, encKey, deviceName)
return m.switchUserNewConfig(uv.Uid, n, salt, d, ad)
} | |
c160408 | nil {
return NoConfigWriterError{}
}
g.ActiveDevice.Clear()
err = cw.SetUserConfig(nil, false)
if err != nil {
return err
}
return nil
} | |
c160409 | switched out from underneath provisioning process")
}
return g.ActiveDevice.Set(m, uv, deviceID, sigKey, encKey, deviceName, 0)
} | |
c160410 | doLogout = true
case KeyRevokedError:
m.Debug("LogoutAndDeprovisionIfRevoked: key revoked error error; device was revoked; calling logout (%s)", err)
doLogout = true
default:
m.Debug("LogoutAndDeprovisionIfRevoked: non-actionable error: %s", err)
}
if doLogout {
username := m.G().Env.GetUsername()
if e... | |
c160411 | devnull.Fd()
files = append(files, nullfd, nullfd, nullfd)
attr := syscall.ProcAttr{
Env: os.Environ(),
Sys: &syscall.SysProcAttr{Setsid: true},
Files: files,
}
pid, err = syscall.ForkExec(cmd, args, &attr)
return pid, err
} | |
c160412 | keeping the size up to date.
a.Valid = 1 * time.Second
// Some apps (e.g., Chrome) get confused if we use a 0 size
// here, as is usual for pseudofiles. So return the actual
// size, even though it may be racy.
a.Size = uint64(len(data))
a.Mtime = t
a.Ctime = t
a.Mode = 0444
return nil
} | |
c160413 | {
data, _, err := f.read(ctx)
if err != nil {
return nil, err
}
resp.Flags |= fuse.OpenDirectIO
return fs.DataHandle(data), nil
} | |
c160414 | "a relative time for the KBFS folder (eg \"5m\")",
},
cli.BoolFlag{
Name: "show-archived",
Usage: "shows stats for several previous revisions",
},
cli.BoolFlag{
Name: "show-last-archived",
Usage: "shows stats for sequential previous revisions",
},
},
}
} | |
c160415 | not verify metadata (revision=%d) for directory %s (id=%s): %s",
e.Revision, e.Dir, e.TlfID, e.Err)
} | |
c160416 | e.User, BuildCanonicalPathForTlfName(e.Type, e.Tlf))
} | |
c160417 | username,
Filename: filename,
Tlf: tlfname,
Type: h.Type(),
}
} | |
c160418 |
}
return fmt.Sprintf("%s does not have write access to %s", e.User, e.Filename)
} | |
c160419 | = h.Type()
}
return WriteAccessError{
User: username,
Filename: filename,
Tlf: tlfName,
Type: t,
}
} | |
c160420 |
(bc.sizeEstimate != 0 && other.sizeEstimate != 0 &&
bc.sizeEstimate != other.sizeEstimate) {
return false
}
// TODO: check for op equality?
return true
} | |
c160421 | after the size is estimated")
}
bc.Ops[len(bc.Ops)-1].AddRefBlock(ptr)
} | |
c160422 | after the size is estimated")
}
bc.Ops[len(bc.Ops)-1].AddUpdate(oldPtr, newPtr)
} | |
c160423 | + len(op.Unrefs()) +
2*len(op.allUpdates())
bc.sizeEstimate +=
uint64(numPtrs)*data.BPSize + op.SizeExceptUpdates()
}
}
return bc.sizeEstimate
} | |
c160424 | FinishedPrefetch:
return keybase1.PrefetchStatus_COMPLETE
default:
panic(fmt.Sprintf("Unknown prefetch status: %s", s))
}
} | |
c160425 | "TriggeredPrefetch":
*s = TriggeredPrefetch
case "FinishedPrefetch":
*s = FinishedPrefetch
}
return nil
} | |
c160426 |
panic("Invalid prefetch status for protocol")
}
return protocolPrefetchStatus
} | |
c160427 | TriggeredPrefetch:
case FinishedPrefetch:
default:
panic("Invalid prefetch status from protocol")
}
return s
} | |
c160428 | agree on stop-if-full, we should remove it
// from the combined result.
if bra.StopIfFull() != other.StopIfFull() {
combined = combined &^ blockRequestStopIfFull
}
return combined
} | |
c160429 | object.
if block.IsIndirect() && bra.Sync() {
return true
}
return bra.prefetch()
} | |
c160430 | bra.DeepPrefetch() || (block.IsIndirect() && bra.Sync()) {
return bra
}
return bra &^ (blockRequestPrefetch | blockRequestSync)
} | |
c160431 | clock.Now().Sub(p.Start)
fracDone := float64(out.BytesFetched) / float64(out.BytesTotal)
totalTimeEstimate := time.Duration(float64(timeRunning) / fracDone)
endEstimate := p.Start.Add(totalTimeEstimate)
out.EndEstimate = keybase1.ToTime(endEstimate)
return out
} | |
c160432 | return keybase1.PrefetchStatus_COMPLETE
}
return keybase1.PrefetchStatus_IN_PROGRESS
} | |
c160433 | 128-bit number.
buf := make([]byte, 128/8)
err := kbfscrypto.RandRead(buf)
if err != nil {
return "", err
}
return base64.RawURLEncoding.EncodeToString(buf), nil
} | |
c160434 | PrereleaseBuild)
}
return libkb.Version
} | |
c160435 | logTags := make(logger.CtxLogTags)
logTags[tagKey] = tagName
newCtx := logger.NewContextWithLogTags(ctx, logTags)
if err == nil {
newCtx = context.WithValue(newCtx, tagKey, id)
}
return newCtx
})
} | |
c160436 | ptr.DataVer > versioner.DataVersion() {
return errors.WithStack(NewDataVersionError{p, ptr.DataVer})
}
return nil
} | |
c160437 | := h.FirstResolvedWriter().AsTeam()
if err != nil {
return false, err
}
offline := keybase1.OfflineAvailability_NONE
if osg != nil {
offline = osg.OfflineAvailabilityForID(h.TlfID())
}
return checker.IsTeamWriter(ctx, tid, uid, verifyingKey, offline)
} | |
c160438 | }
if h.TypeForKeying() == tlf.TeamKeying {
return false
}
return tlf.UserIsOnlyWriter(session.Name, h.GetCanonicalName())
} | |
c160439 | cancel()
cli, err := s.client()
if err != nil {
return err
}
return cli.SimpleFSListRecursiveToDepth(ctx, arg)
} | |
c160440 | err := s.client()
if err != nil {
return err
}
return cli.SimpleFSSymlink(ctx, arg)
} | |
c160441 |
cli, err := s.client()
if err != nil {
return err
}
return cli.SimpleFSGetRevisions(ctx, arg)
} | |
c160442 | ctx, cancel := s.wrapContextWithTimeout(ctx)
defer cancel()
cli, err := s.client()
if err != nil {
return keybase1.GetRevisionsResult{}, err
}
return cli.SimpleFSReadRevisions(ctx, opID)
} | |
c160443 | return keybase1.SimpleFSGetHTTPAddressAndTokenResponse{}, err
}
return cli.SimpleFSGetHTTPAddressAndToken(ctx)
} | |
c160444 |
cli, err := s.client()
if err != nil {
return nil, err
}
return cli.SimpleFSUserEditHistory(ctx)
} | |
c160445 | nil {
return keybase1.FSFolderEditHistory{}, err
}
return cli.SimpleFSFolderEditHistory(ctx, path)
} | |
c160446 | := s.client()
if err != nil {
return err
}
return cli.SimpleFSReset(ctx, path)
} | |
c160447 | s.wrapContextWithTimeout(ctx)
defer cancel()
cli, err := s.client()
if err != nil {
return keybase1.SimpleFSQuotaUsage{}, err
}
return cli.SimpleFSGetUserQuotaUsage(ctx)
} | |
c160448 | nil {
return keybase1.SimpleFSQuotaUsage{}, err
}
return cli.SimpleFSGetTeamQuotaUsage(ctx, teamName)
} | |
c160449 | }
needUpdate, err := strconv.ParseBool(strings.TrimSpace(string(out)))
if err != nil {
return false, err
}
return needUpdate, nil
} | |
c160450 | return nil, err
}
res := computeSecret(players)
return NewPRNG(res), nil
} | |
c160451 | if err != nil {
return nil, err
}
return prng.Big(modulus), nil
} | |
c160452 | if err != nil {
return 0, err
}
return prng.Int(modulus), nil
} | |
c160453 | err != nil {
return false, err
}
return prng.Bool(), nil
} | |
c160454 | &SaltpackDecrypt{
arg: arg,
pnymResolver: pnymResolver,
}
} | |
c160455 | := []string{}
for _, p := range pairs {
reacjis = append(reacjis, p.name)
}
if len(reacjis) < len(DefaultTopReacjis) {
reacjis = append(reacjis, DefaultTopReacjis[:len(DefaultTopReacjis)-len(reacjis)]...)
}
return keybase1.UserReacjis{
TopReacjis: reacjis,
SkinTone: cache.SkinTone,
}
} | |
c160456 | err.(idutil.NoSuchNameError); ok {
return fuse.ESTALE
}
return err
}
s.parent.folder.fillAttrWithUIDAndWritePerm(ctx, s.parent.node, &de, a)
a.Mode = os.ModeSymlink | a.Mode | 0500
a.Inode = s.inode
return nil
} | |
c160457 | err := s.parent.folder.fs.config.KBFSOps().Lookup(ctx, s.parent.node, s.name)
if err != nil {
return "", err
}
if de.Type != data.Sym {
return "", fuse.Errno(syscall.EINVAL)
}
return de.SymPath, nil
} | |
c160458 | == 0 {
return TLFWriterKeyBundleV3{}, errors.New(
"Writer key bundle with no keys (DeserializeTLFWriterKeyBundleV3)")
}
return wkb, nil
} | |
c160459 | _, ok := wkb.Keys[user][deviceKey]
return ok
} | |
c160460 | return TLFWriterKeyBundleID{}, err
}
return TLFWriterKeyBundleID{h}, nil
} | |
c160461 | if err != nil {
return TLFWriterKeyBundleID{}, err
}
return TLFWriterKeyBundleID{h}, nil
} | |
c160462 | {
return h.h.MarshalBinary()
} | |
c160463 | return h.h.UnmarshalBinary(data)
} | |
c160464 | {
return TLFWriterKeyBundleID{}, err
}
h, err := kbfshash.DefaultHash(buf)
if err != nil {
return TLFWriterKeyBundleID{}, err
}
return TLFWriterKeyBundleID{h}, nil
} | |
c160465 | err := kbfscodec.DeserializeFromFile(codec, path, &rkb)
if err != nil {
return TLFReaderKeyBundleV3{}, err
}
if len(rkb.Keys) == 0 {
rkb.Keys = make(UserDeviceKeyInfoMapV3)
}
return rkb, nil
} | |
c160466 | return TLFReaderKeyBundleID{}, err
}
return TLFReaderKeyBundleID{h}, nil
} | |
c160467 | if err != nil {
return TLFReaderKeyBundleID{}, err
}
return TLFReaderKeyBundleID{h}, nil
} | |
c160468 | {
return h.h.MarshalBinary()
} | |
c160469 | return h.h.UnmarshalBinary(data)
} | |
c160470 | if err != nil {
return TLFReaderKeyBundleID{}, err
}
h, err := kbfshash.DefaultHash(buf)
if err != nil {
return TLFReaderKeyBundleID{}, err
}
return TLFReaderKeyBundleID{h}, nil
} | |
c160471 | readerKeyBundleDb: readerKeyBundleDb,
truncateLockManager: &truncateLockManager,
lockIDs: make(map[mdLockMemKey]mdLockMemVal),
iTeamMigrationLocks: make(map[tlf.ID]bool),
updateManager: newMDServerLocalUpdateManager(),
merkleRoots: make(map[keybase1.MerkleTreeID]*kbfsmd.MerkleRoo... | |
c160472 | id, nil, nil
}
rmds, err := md.GetForTLF(ctx, id, kbfsmd.NullBranchID, mStatus, nil)
if err != nil {
return tlf.NullID, nil, err
}
return id, rmds, nil
} | |
c160473 | md.lock.RUnlock()
bid, err := md.checkGetParamsRLocked(ctx, id, bid, mStatus)
if err != nil {
return nil, err
}
if mStatus == kbfsmd.Unmerged && bid == kbfsmd.NullBranchID {
return nil, nil
}
rmds, err := md.getHeadForTLFRLocked(ctx, id, bid, mStatus)
if err != nil {
return nil, kbfsmd.ServerError{Err: ... | |
c160474 | blockList, ok := md.mdDb[key]
if !ok {
return nil, nil
}
blocks := blockList.blocks
// Iterate backward until we find a timestamp less than `serverTime`.
for i := len(blocks) - 1; i >= 0; i-- {
t := blocks[i].timestamp
if t.After(serverTime) {
continue
}
max := md.config.MetadataVersion()
ver := ... | |
c160475 | // TODO: wait for the clock to pass the expired time. We'd
// need a new method in the `Clock` interface to support this.
case <-ch:
continue
case <-ctx.Done():
return ctx.Err()
}
}
} | |
c160476 | keybase1.LockID) error {
md.lock.Lock()
defer md.lock.Unlock()
md.releaseLockLocked(ctx, tlfID, lockID)
return nil
} | |
c160477 | is intentional to be consistent
// with the mdserver behavior-- it garbage collects discarded branches in the
// background.
branchKey, err := md.getBranchKey(ctx, id)
if err != nil {
return kbfsmd.ServerError{Err: err}
}
err = md.checkShutdownRLocked()
if err != nil {
return err
}
delete(md.branchDb, br... | |
c160478 |
currMergedHeadRev, err := md.getCurrentMergedHeadRevision(ctx, id)
if err != nil {
return nil, err
}
c := md.updateManager.registerForUpdate(id, currHead, currMergedHeadRev, md)
return c, nil
} | |
c160479 |
md.updateManager.cancel(id, md)
} | |
c160480 |
}
myKey, err := md.getCurrentDeviceKey(ctx)
if err != nil {
return false, err
}
return md.truncateLockManager.truncateLock(myKey, id)
} | |
c160481 |
md.handleDb = nil
md.latestHandleDb = nil
md.branchDb = nil
md.truncateLockManager = nil
} | |
c160482 | }
md.lock.RLock()
defer md.lock.RUnlock()
wkb, rkb, err := md.getKeyBundlesRLocked(tlfID, wkbID, rkbID)
if err != nil {
return nil, nil, kbfsmd.ServerError{Err: err}
}
return wkb, rkb, nil
} | |
c160483 |
Bytes: make(map[UsageType]int64),
Blocks: make(map[UsageType]int64),
}
} | |
c160484 | != 0 {
return true
}
}
return false
} | |
c160485 |
}
u.Bytes[usage] += int64(change)
if change > 0 {
u.Blocks[usage]++
} else {
u.Blocks[usage]--
}
} | |
c160486 |
u.Folders[folder].AccumOne(change, usage)
u.Total.AccumOne(change, usage)
} | |
c160487 | ([]byte, error) {
return codec.Encode(u)
} | |
c160488 | &info)
if err != nil {
return nil, err
}
return &info, nil
} | |
c160489 | vlog,
requestsChan: make(chan dirtyReq, 1000),
bytesDecreasedChan: make(chan struct{}, 1),
shutdownChan: make(chan struct{}),
cache: make(map[dirtyBlockID]Block),
minSyncBufCap: minSyncBufCap,
maxSyncBufCap: maxSyncBufCap,
syncBufferCap: startSyncBufCap,
... | |
c160490 | id: ptr.ID,
refNonce: ptr.RefNonce,
branch: branch,
}
d.lock.RLock()
defer d.lock.RUnlock()
return d.cache[dirtyID]
}()
if block != nil {
return block, nil
}
return nil, NoSuchBlockError{ptr.ID}
} | |
c160491 | ptr.RefNonce,
branch: branch,
}
d.lock.Lock()
defer d.lock.Unlock()
d.cache[dirtyID] = block
return nil
} | |
c160492 | branch,
}
d.lock.Lock()
defer d.lock.Unlock()
delete(d.cache, dirtyID)
return nil
} | |
c160493 | branch: branch,
}
d.lock.RLock()
defer d.lock.RUnlock()
_, isDirty = d.cache[dirtyID]
return
} | |
c160494 | return len(d.cache) > 0 || d.syncBufBytes > 0 || d.waitBufBytes > 0
} | |
c160495 | float64(d.waitBufBytes-d.syncBufferCap) /
float64(d.syncBufferCap)
if backpressureFrac > 1.0 {
backpressureFrac = 1.0
}
totalBackpressure := time.Duration(
float64(totalReqTime) * backpressureFrac)
timeSpentSoFar := d.clock.Now().Sub(start)
if totalBackpressure <= timeSpentSoFar {
return 0
}
// How muc... | |
c160496 | := ctx.Deadline()
defaultDeadline := now.Add(BackgroundTaskTimeout / 2)
if !ok || deadline.After(defaultDeadline) {
// Use half of the background task timeout, to make sure we
// never get close to a timeout in a background task.
deadline = defaultDeadline
}
req := dirtyReq{c, estimatedDirtyBytes, now, deadl... | |
c160497 |
if wasSyncing {
d.syncBufBytes += newUnsyncedBytes
} else {
d.updateWaitBufLocked(newUnsyncedBytes)
}
if newUnsyncedBytes < 0 {
d.signalDecreasedBytes()
}
} | |
c160498 | d.syncBufBytes += size
d.updateWaitBufLocked(-size)
d.signalDecreasedBytes()
} | |
c160499 | throughput of the connection.
if bufferIncrease >= d.syncBufferCap {
d.syncBufferCap += bufferIncrease
if d.syncBufferCap > d.maxSyncBufCap {
d.syncBufferCap = d.maxSyncBufCap
}
}
d.signalDecreasedBytes()
d.vlog.CLogf(
context.TODO(), libkb.VLog1,
"Finished syncing %d bytes, syncBufferCap=%d, waitBuf=... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.