id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c160700 | for %s", b.uid)
b.queuePurges(bgctx)
case <-shutdownCh:
b.Debug(bgctx, "loop: shutting down for %s", b.uid)
return
}
}
} | |
c160701 |
if stateCount == 0 {
return nil
}
return &state.exclusionStates[stateCount-1]
} | |
c160702 | state.exclusionStates {
if state.level > level {
break
}
if state.level == level {
return state.exclusionType
}
}
return nonExclusion
} | |
c160703 | LeveledMutex{
level: level,
locker: locker,
}
} | |
c160704 | m.locker)
if err != nil {
panic(err)
}
} | |
c160705 | LeveledRWMutex{
level: level,
rwLocker: rwLocker,
}
} | |
c160706 | rw.rwLocker)
if err != nil {
panic(err)
}
} | |
c160707 | readExclusion, rw.rwLocker.RLocker())
if err != nil {
panic(err)
}
} | |
c160708 | readExclusion, rw.rwLocker.RLocker())
if err != nil {
panic(err)
}
} | |
c160709 | rw.level,
expectedExclusionType: readExclusion,
exclusionType: et,
})
}
} | |
c160710 |
levelToString: lockState.levelToString,
level: rw.level,
})
}
} | |
c160711 | {
fd := &FileData{
getter: getter,
}
fd.tree = &blockTree{
file: file,
chargedTo: chargedTo,
kmd: kmd,
bsplit: bsplit,
getter: fd.blockGetter,
cacher: cacher,
log: log,
vlog: vlog,
}
return fd
} | |
c160712 | rem)
defer cancel()
}
}
bytes, err := fd.getByteSlicesInOffsetRange(ctx, startOff,
startOff+Int64Offset(len(dest)), true)
if err != nil {
return 0, err
}
currLen := int64(0)
for _, b := range bytes {
bLen := int64(len(b))
copy(dest[currLen:currLen+bLen], b)
currLen += bLen
}
return currLen, ni... | |
c160713 | make([]byte, bufSize)
currLen := 0
for _, b := range bytes {
copy(data[currLen:currLen+len(b)], b)
currLen += len(b)
}
return data, nil
} | |
c160714 | {
block = b.(*FileBlock)
}
if nbso != nil {
nextBlockStartOff = nbso.(Int64Offset)
} else {
nextBlockStartOff = -1
}
if so != nil {
startOff = so.(Int64Offset)
}
return ptr, parentBlocks, block, nextBlockStartOff, startOff, wasDirty, nil
} | |
c160715 | func(ptr BlockPointer) func() error {
if df != nil {
return func() error { return df.setBlockSynced(ptr) }
}
return nil
})
} | |
c160716 | topBlock *FileBlock) ([]BlockInfo, error) {
return fd.tree.getIndirectBlockInfosWithTopBlock(ctx, topBlock)
} | |
c160717 | {
return fd.tree.getIndirectBlockInfos(ctx)
} | |
c160718 | // Because we only check each parent once, the
// `path` we're using here will be the one with a
// childIndex of 0. But, that's not necessarily
// the one that matches the pointer that needs to
// be dirty. So make a new path and set the
// childIndex to the correct pointer instead.
ne... | |
c160719 | make(chan struct{})
}
if rwg.num+delta < 0 {
panic("RepeatedWaitGroup count would be negative")
}
rwg.num += delta
if rwg.num == 0 {
close(rwg.isIdleCh)
rwg.isIdleCh = nil
}
} | |
c160720 | return nil
}
select {
case <-isIdleCh:
return nil
case <-ctx.Done():
return ctx.Err()
}
} | |
c160721 | }
if paused {
return true, nil
}
select {
case <-isIdleCh:
return false, nil
case <-pauseCh:
return true, nil
case <-ctx.Done():
return false, ctx.Err()
}
} | |
c160722 |
rwg.paused = true
if rwg.pauseCh != nil {
close(rwg.pauseCh)
rwg.pauseCh = nil
}
} | |
c160723 |
if rwg.pauseCh != nil {
panic("Non-nil pauseCh on resume!")
}
rwg.paused = false
} | |
c160724 |
Contextified: libkb.NewContextified(g),
}
} | |
c160725 | binary.LittleEndian.PutUint32(buf, uint32(len(block)))
copy(buf[padPrefixSize:], block)
return buf, nil
} | |
c160726 |
PaddedBlockReadError{
ActualLen: totalLen,
ExpectedLen: blockEndPos,
})
}
return paddedBlock[padPrefixSize:blockEndPos], nil
} | |
c160727 | 1 or 2 args: <service> [<username>]")
}
p.arg.Service = ctx.Args()[0]
if nargs == 2 {
p.arg.Username = ctx.Args()[1]
}
if libkb.RemoteServiceTypes[p.arg.Service] == keybase1.ProofType_ROOTER {
p.arg.Auto = ctx.Bool("auto")
if p.arg.Auto && len(p.arg.Username) == 0 {
return fmt.Errorf("must specify the u... | |
c160728 | Name: "output, o",
Usage: "Output proof text to a file (rather than standard out).",
},
cli.BoolFlag{
Name: "force, f",
Usage: "Don't prompt.",
},
cli.BoolFlag{
Name: "list-services, l",
Usage: "List all available services",
},
},
Action: func(c *cli.Context) {
cl.ChooseCom... | |
c160729 |
Contextified: libkb.NewContextified(g),
arg: keybase1.StartProofArg{
Service: "rooter",
Username: username,
Auto: true,
},
}
} | |
c160730 | API: true,
KbKeyring: true,
}
} | |
c160731 | }
return fmt.Sprintf(handleExtensionFinalizedString, username)
}
return "<unknown extension type>"
} | |
c160732 |
}
m := handleExtensionFinalizedRegex.FindStringSubmatch(s)
if len(m) < 2 {
return HandleExtensionUnknown, ""
}
return HandleExtensionFinalized, kbname.NewNormalizedUsername(m[1])
} | |
c160733 | *HandleExtension, error) {
return newHandleExtension(extType, num, un, now)
} | |
c160734 |
if err != nil {
return nil, err
}
return &HandleExtension{
Date: now.UTC().Unix(),
Number: num,
Type: extType,
Username: un,
}, nil
} | |
c160735 | 16)
if err != nil {
return nil, err
}
if num < 1 {
return nil, errHandleExtensionInvalidNumber
}
}
return &HandleExtension{
Date: date.UTC().Unix(),
Number: uint16(num),
Type: extType,
Username: un,
}, nil
} | |
c160736 | if extMap[ext.Type] {
// No duplicate extension types in the same suffix.
return nil, errHandleExtensionInvalidString
}
extMap[ext.Type] = true
extensions = append(extensions, *ext)
}
return extensions, nil
} | |
c160737 |
suffix += HandleExtensionSep
suffix += extension.string(isBackedByTeam)
}
return suffix
} | |
c160738 | return err
}
entry.MaxDeleteHistoryUpto = msgid
entry.MinDeletableMessage = msgid
return t.setEntry(ctx, convID, uid, entry)
} | |
c160739 | struct{}{}
close(f.folder.updateChan)
f.folder.updateChan = nil
} else {
if f.folder.updateChan != nil {
return errors.New("Updates are already disabled")
}
f.folder.updateChan, err =
libkbfs.DisableUpdatesForTesting(f.folder.fs.config,
f.folder.getFolderBranch())
if err != nil {
return err
... | |
c160740 | fmt.Printf("Nuking in memory chat db\n")
kbCtx.LocalChatDb.Nuke()
}
if _, ok := kbCtx.LocalDb.GetEngine().(*libkb.MemDb); ok {
fmt.Printf("Nuking in memory local db\n")
kbCtx.LocalDb.Nuke()
}
debug.FreeOSMemory()
fmt.Printf("Done flushing global caches\n")
runtime.ReadMemStats(&m)
fmt.Printf("mem stats (... | |
c160741 |
cache: ramcache.New(),
}
res.cache.MaxAge = maxAge
res.cache.TTL = maxAge
return res
} | |
c160742 | return nil, IdentifyTimeoutError{}
}
if up.TrackBreaks != nil && !breaksOK {
return nil, TrackBrokenError{}
}
thenTime := keybase1.FromTime(then)
timeout := gcdf(*up)
if time.Since(thenTime) > timeout {
return nil, IdentifyTimeoutError{}
}
}
return up, nil
} | |
c160743 |
copy := &tmp
copy.Upk.Uvv.CachedAt = keybase1.ToTime(time.Now())
return c.cache.Set(string(up.Upk.GetUID()), copy)
} | |
c160744 | "desired size of %d", desiredBlockSize)
}
// Trial and error shows that this magic 75% constant maximizes
// the number of realistic indirect pointers you can fit into the
// default block size. TODO: calculate this number more exactly
// during initialization for a given `maxSize`.
maxPtrs := int(.75 * floa... | |
c160745 |
maxPtrsPerBlock: maxPtrsPerBlock,
blockChangeEmbedMaxSize: blockChangeEmbedMaxSize,
maxDirEntriesPerBlock: maxDirEntriesPerBlock,
}, nil
} | |
c160746 |
{Revision: 4, Count: 4},
},
},
}
block.Children[bigName] = de
encodedBlock, err := codec.Encode(block)
if err != nil {
return err
}
oneEntrySize := int64(len(encodedBlock))
b.maxDirEntriesPerBlock = int(b.maxSize / oneEntrySize)
if b.maxDirEntriesPerBlock == 0 {
b.maxDirEntriesPerBlock = 1
}
ret... | |
c160747 | = b.maxSize - off
}
if moreNeeded > 0 {
block.Contents = append(block.Contents, make([]byte, moreNeeded)...)
}
}
// we may have filled out the block above, but we still can't copy anything
if off > int64(len(block.Contents)) {
return 0
}
copy(block.Contents[off:off+toCopy], data[:toCopy])
return to... | |
c160748 | block,
// and add to the new block.
newBlock := NewDirBlock().(*DirBlock)
startOff := int(len(names) / 2)
for _, name := range names[int(len(names)/2):] {
newBlock.Children[name] = block.Children[name]
delete(block.Children, name)
}
newOffset := StringOffset(names[startOff])
return []*DirBlock{block, newBlo... | |
c160749 | ...interface{}) {
l.log.Debug(s, args...)
} | |
c160750 | ...interface{}) {
l.log.Info(s, args...)
} | |
c160751 | ...interface{}) {
l.log.Warning(s, args...)
} | |
c160752 | ...interface{}) {
l.log.Errorf(s, args...)
} | |
c160753 | pukBoxes
section["generation"] = generation
if pukPrev != nil {
section["prev"] = *pukPrev
}
serverArg["per_user_key"] = section
} | |
c160754 | = map[string]string{string(arg.DeviceID): arg.DeviceEkStatementSig}
serverArg["user_ek_rebox"] = arg.UserEkBoxMetadata
} | |
c160755 | arg.Ratelimit, arg.Cachefile, arg.Ignorefile, h.G())
m := libkb.NewMetaContext(ctx, h.G()).WithUIs(uis)
return engine.RunEngine2(m, eng)
} | |
c160756 | httpclient = client[0]
}
return &S3{
Signer: signer,
Region: region,
AttemptStrategy: DefaultAttemptStrategy,
client: httpclient,
}
} | |
c160757 |
if resp != nil {
return resp.Body, err
}
return nil, err
} | |
c160758 | b.GetResponseWithHeaders(ctx, path, header)
if resp != nil {
return resp.Body, err
}
return nil, err
} | |
c160759 |
return b.GetResponseWithHeaders(ctx, path, make(http.Header))
} | |
c160760 |
err = b.S3.prepare(req)
if err != nil {
return nil, err
}
for attempt := b.S3.AttemptStrategy.Start(); attempt.Next(); {
resp, err := b.S3.run(ctx, req, nil)
if shouldRetry(err) && attempt.HasNext() {
continue
}
if err != nil {
return nil, err
}
return resp, nil
}
panic("unreachable")
} | |
c160761 | as non existence
if e, ok := err.(*Error); ok && (e.StatusCode == 403 || e.StatusCode == 404) {
return false, nil
}
return false, err
}
if resp.StatusCode/100 == 2 {
exists = true
}
return exists, err
}
return false, fmt.Errorf("S3 Currently Unreachable")
} | |
c160762 | := &request{
method: "PUT",
bucket: b.Name,
path: path,
headers: headers,
}
result = &CopyObjectResult{}
for attempt := b.S3.AttemptStrategy.Start(); attempt.Next(); {
err = b.S3.query(context.Background(), req, result)
if !shouldRetry(err) {
break
}
}
if err != nil {
return nil, err
}
r... | |
c160763 | }
options.addHeaders(headers)
req := &request{
method: "PUT",
bucket: b.Name,
path: path,
headers: headers,
payload: r,
}
return b.S3.query(ctx, req, nil)
} | |
c160764 | 1000)
if err != nil {
return &bucketContents, err
}
for _, key := range contents.Contents {
bucketContents[key.Key] = key
}
if contents.IsTruncated {
marker = contents.NextMarker
} else {
break
}
}
return &bucketContents, nil
} | |
c160765 | }
req.baseurl = strings.Replace(req.baseurl, "${bucket}", req.bucket, -1)
}
signpath = "/" + req.bucket + signpath
}
}
// Always sign again as it's not clear how far the
// server has handled a previous attempt.
u, err := url.Parse(req.baseurl)
if err != nil {
return fmt.Errorf("bad S3 endpoint U... | |
c160766 | InvalidHandle is the best way.
err = errors.New("Invalid handle from DokanOpenRequestorHandle")
}
return syscall.Token(hdl), err
} | |
c160767 | return false
}
res, _, _ := syscall.Syscall(procEqualSid.Addr(), 2,
uintptr(unsafe.Pointer(sid)),
uintptr(unsafe.Pointer(tokUser.User.Sid)),
0)
if isDebug {
u1, _ := (*syscall.SID)(sid).String()
u2, _ := tokUser.User.Sid.String()
debugf("IsRequestorUserSidEqualTo: EqualSID(%q,%q) => %v (expecting non-z... | |
c160768 | Failed!")
return errors.New("kbfsLibdokan_RemoveMountPoint failed")
}
debug("Unmount: Success!")
return nil
} | |
c160769 | return stringToUtf16BufferPtr(s, unsafe.Pointer(ptr), blenUcs2)
} | |
c160770 | "\000"))
return unsafe.Pointer(&tmp[0])
} | |
c160771 | return StagingRunMode, nil
case "":
return NoRunMode, nil
default:
return NoRunMode, fmt.Errorf("unknown run mode: '%s'", s)
}
} | |
c160772 | == 1 {
c.assertion = ctx.Args()[0]
}
c.verbose = ctx.Bool("verbose")
return nil
} | |
c160773 |
Config: true,
API: true,
}
} | |
c160774 |
kid := key.GetKID()
m.Debug("| Found KID for current device: %s", kid)
ret = keyring.LookupByKid(kid)
if ret != nil {
m.Debug("| Using device key: %s", kid)
}
} else {
m.Debug("| Looking up secret key in local keychain")
blocks := keyring.SearchWithComputedKeyFamily(ckf, ska)
if len(blocks) > 0 {
... | |
c160775 | return ret, nil
}
var pub GenericKey
if ska.KeyType != PGPKeyType {
m.Debug("| Skipped Synced PGP key (via options)")
err = NoSecretKeyError{}
return nil, err
}
if ret, err = ska.Me.SyncedSecretKey(m); err != nil {
m.Warning("Error fetching synced PGP secret key: %s", err)
return nil, err
}
if ret ... | |
c160776 | libkb.LogTagsFromContext,
ReconnectBackoff: func() backoff.BackOff { return constBackoff },
}
return rpc.NewConnectionWithTransport(
handler, transport, libkb.ErrorUnwrapper{},
logger.LogOutputWithDepthAdder{Logger: config.MakeLogger("")}, opts)
} | |
c160777 | kt.kbCtx.GetSocket(true)
if err != nil {
return nil, err
}
kt.mutex.Lock()
defer kt.mutex.Unlock()
kt.stagedTransport = transport
return transport, nil
} | |
c160778 | return kt.transport != nil && kt.transport.IsConnected()
} | |
c160779 | kt.transport = kt.stagedTransport
kt.stagedTransport = nil
} | |
c160780 | leafChainsValidated: make(
map[tlf.ID]map[kbfsmd.Revision]kbfsmd.Revision),
}
} | |
c160781 | = kbname.NormalizedUsername("uid: " +
rmds.MD.LastModifyingWriter().String())
}
md.log.CDebugf(ctx, "Unverifiable update for TLF %s: %+v",
rmds.MD.TlfID(), err)
return UnverifiableTlfUpdateError{tlf, writer, err}
} | |
c160782 | if !ok {
return leafRev
}
min, ok := revs[leafRev]
if !ok {
return leafRev
}
return min
} | |
c160783 | nil
default:
return tlf.NullID, err
}
id, _, err = md.getForHandle(ctx, handle, kbfsmd.Merged, nil)
switch errors.Cause(err).(type) {
case kbfsmd.ServerErrorClassicTLFDoesNotExist:
// The server thinks we should create an implicit team for this TLF.
return tlf.NullID, nil
case nil:
default:
return tlf.N... | |
c160784 | (
ImmutableRootMetadata, error) {
return md.getForTLF(ctx, id, kbfsmd.NullBranchID, kbfsmd.Merged, lockBeforeGet)
} | |
c160785 | mdserv, err := md.mdserver(ctx)
if err != nil {
return ImmutableRootMetadata{}, err
}
rmds, err := mdserv.GetForTLFByTime(ctx, id, serverTime)
if err != nil {
return ImmutableRootMetadata{}, err
}
return md.processSignedMD(ctx, id, kbfsmd.NullBranchID, rmds)
} | |
c160786 | bid kbfsmd.BranchID) (
ImmutableRootMetadata, error) {
return md.getForTLF(ctx, id, bid, kbfsmd.Unmerged, nil)
} | |
c160787 | *keybase1.LockID) (
[]ImmutableRootMetadata, error) {
return md.getRange(
ctx, id, kbfsmd.NullBranchID, kbfsmd.Merged, start, stop, lockBeforeGet)
} | |
c160788 | return md.getRange(ctx, id, bid, kbfsmd.Unmerged, start, stop, nil)
} | |
c160789 | {
return ImmutableRootMetadata{}, UnexpectedUnmergedPutError{}
}
return md.put(ctx, rmd, verifyingKey, lockContext, priority)
} | |
c160790 | err != nil {
return ImmutableRootMetadata{}, err
}
rmd.SetBranchID(bid)
}
return md.put(ctx, rmd, verifyingKey, nil, keybase1.MDPriorityNormal)
} | |
c160791 | err != nil {
return err
}
return mdserv.PruneBranch(ctx, id, bid)
} | |
c160792 | this is completed, we'll need to check for
// resolutions on the next restart (see KBFS-798).
err = md.PruneBranch(ctx, id, bid)
if err != nil {
return ImmutableRootMetadata{}, err
}
return irmd, nil
} | |
c160793 | Fingerprint: fingerprint.String(),
Username: owner.GetName(),
SignedAt: keybase1.TimeFromSeconds(signatureTime.Unix()),
}
return m.UIs().PgpUI.OutputSignatureSuccess(m.Ctx(), arg)
} | |
c160794 | SignedAt: keybase1.TimeFromSeconds(signatureTime.Unix()),
}
return m.UIs().PgpUI.OutputSignatureSuccessNonKeybase(m.Ctx(), arg)
} | |
c160795 | })
return &WalletUpkeepBackground{
Contextified: libkb.NewContextified(g),
args: args,
// Install the task early so that Shutdown can be called before RunEngine.
task: task,
}
} | |
c160796 | b.UnboxMessages(ctx, boxed.Messages, conv); err != nil {
return chat1.ThreadView{}, err
}
return thread, nil
} | |
c160797 | := libkb.MakeNaclSigningKeyPairFromSecret(allZeroSecretKey)
if err != nil {
panic("errors in key generation should be impossible: " + err.Error())
}
dummySigningKeyPtr = &dummyKeypair
})
return *dummySigningKeyPtr
} | |
c160798 | fmt.Sprintf("blank TLF name received: original: %s canonical: %s", tlfName,
msg.ClientHeader.TlfName)
return res, NewBoxingError(msg, true)
}
}
boxed, err := b.box(ctx, msg, info.Key, info.EphemeralSeed, info.SigningKeyPair, info.Version,
info.PairwiseMACRecipients)
if err != nil {
return res, NewBoxin... | |
c160799 | return NewBoxingError(err.Error(), false)
}
msg.ClientHeader.MerkleRoot = merkleRoot
if msg.ClientHeader.MerkleRoot == nil {
return NewBoxingError("cannot send message without merkle root", false)
}
default:
return fmt.Errorf("attachMerkleRoot unrecognized version: %s", version)
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.