id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c161000 | }
if r.private.fs.platformParams.shouldAppendPlatformRootDirs() {
res = append(res, platformRootDirs...)
}
if name := r.private.fs.remoteStatus.ExtraFileName(); name != "" {
res = append(res, fuse.Dirent{Type: fuse.DT_File, Name: name})
}
return res, nil
} | |
c161001 |
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
err = cache.config.Codec().Decode(quotaBytes, &info)
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
return info, nil
} | |
c161002 | if err != nil {
return kbfsblock.QuotaInfo{}, err
}
return cache.getQuotaLocked(id, metered)
} | |
c161003 | if err != nil {
return err
}
encodedInfo, err := cache.config.Codec().Encode(&info)
if err != nil {
return err
}
err = cache.db.PutWithMeter(
[]byte(id.String()), encodedInfo, cache.putMeter)
if err != nil {
return err
}
cache.quotasCached[id] = true
return nil
} | |
c161004 | NumQuotas: uint64(len(cache.quotasCached)),
Hits: rateMeterToStatus(cache.hitMeter),
Misses: rateMeterToStatus(cache.missMeter),
Puts: rateMeterToStatus(cache.putMeter),
}
} | |
c161005 | getLiveBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.GetLiveBlockReferences", r)
isUnflushedTimer := metrics.GetOrRegisterTimer("BlockServer.IsUnflushed", r)
return BlockServerMeasured{
delegate: delegate,
getTimer: getTimer,
getEncodedSizeTimer: ... | |
c161006 |
b.getTimer.Time(func() {
buf, serverHalf, err = b.delegate.Get(
ctx, tlfID, id, context, cacheType)
})
return buf, serverHalf, err
} | |
c161007 |
size, status, err = b.delegate.GetEncodedSize(ctx, tlfID, id, context)
})
return size, status, err
} | |
c161008 | err = b.delegate.AddBlockReference(ctx, tlfID, id, context)
})
return err
} | |
c161009 | liveCounts, err = b.delegate.RemoveBlockReferences(
ctx, tlfID, contexts)
})
return liveCounts, err
} | |
c161010 | (err error) {
b.archiveBlockReferencesTimer.Time(func() {
err = b.delegate.ArchiveBlockReferences(ctx, tlfID, contexts)
})
return err
} | |
c161011 | isUnflushed, err = b.delegate.IsUnflushed(ctx, tlfID, id)
})
return isUnflushed, err
} | |
c161012 | context.Context) {
b.delegate.Shutdown(ctx)
} | |
c161013 | context.Context) {
b.delegate.RefreshAuthToken(ctx)
} | |
c161014 | {
return b.delegate.GetUserQuotaInfo(ctx)
} | |
c161015 | *kbfsblock.QuotaInfo, err error) {
return b.delegate.GetTeamQuotaInfo(ctx, tid)
} | |
c161016 | list. So even if caller is not requesting a conflict team, go
// through this loop.
for i, conflict := range imp.Conflicts {
g.Log.CDebugf(ctx, "| checking conflict: %+v (iter %d)", conflict, i)
conflictInfo, err := conflict.parse()
if err != nil {
// warn, don't fail
g.Log.CDebugf(ctx, "LookupImplicitT... | |
c161017 | teamID, teamName, err = CreateImplicitTeam(ctx, g, impTeamName)
if err != nil {
if isDupImplicitTeamError(ctx, err) {
g.Log.CDebugf(ctx, "LookupOrCreateImplicitTeam: duplicate team, trying to lookup again: err: %s", err)
res, teamName, impTeamName, _, err = lookupImplicitTeamAndConflicts(ctx, g, dis... | |
c161018 | frontName libkb.NormalizedUsername) (string, error) {
return formatImplicitTeamDisplayNameCommon(ctx, g, impTeamName, &frontName)
} | |
c161019 |
return true
}
if b == front {
return false
}
return a < b
})
} | |
c161020 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSEditList", []interface{}{__arg}, nil)
return
} | |
c161021 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSSyncStatus", []interface{}{__arg}, nil)
return
} | |
c161022 | c.Cli.Call(ctx, "keybase.1.kbfs.FSSyncEvent", []interface{}{__arg}, nil)
return
} | |
c161023 | "keybase.1.kbfs.FSOverallSyncEvent", []interface{}{__arg}, nil)
return
} | |
c161024 | = c.Cli.Call(ctx, "keybase.1.kbfs.FSOnlineStatusChangedEvent", []interface{}{__arg}, nil)
return
} | |
c161025 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.createTLF", []interface{}{__arg}, nil)
return
} | |
c161026 | "keybase.1.kbfs.getKBFSTeamSettings", []interface{}{__arg}, &res)
return
} | |
c161027 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.upgradeTLF", []interface{}{__arg}, nil)
return
} | |
c161028 |
__arg := EncryptFavoritesArg{DataToEncrypt: dataToEncrypt}
err = c.Cli.Call(ctx, "keybase.1.kbfs.encryptFavorites", []interface{}{__arg}, &res)
return
} | |
c161029 |
__arg := DecryptFavoritesArg{DataToEncrypt: dataToEncrypt}
err = c.Cli.Call(ctx, "keybase.1.kbfs.decryptFavorites", []interface{}{__arg}, &res)
return
} | |
c161030 | result.Terminal = terminal(code)
result.ASCII = ascii(code)
return &result, nil
} | |
c161031 | loop; other errors are handled in
// FinalizeRequest
if err == io.EOF {
return
}
}
} | |
c161032 | make(chan struct{}),
queue: q,
workCh: workCh,
}
go brw.run()
return brw
} | |
c161033 | nil {
return err
}
if !hasRoom {
return DiskCacheTooFullForBlockError{retrieval.blockPtr, action}
}
}
}
cacheType = action.CacheType()
if action.DelayCacheCheck() {
_, err := brw.queue.checkCaches(
retrieval.ctx, retrieval.kmd, retrieval.blockPtr, block,
action.WithoutDelayedCacheCheckAc... | |
c161034 |
close(brw.stopCh)
}
return brw.doneCh
} | |
c161035 |
statNameInvalidConfig: prefix + "invalidConfig",
statPrefixProto: prefix + "proto:",
statPrefixStatus: prefix + "status:",
statPrefixTlfType: prefix + "tlfType:",
statPrefixRootType: prefix + "rootType:",
activityStats: *enabler,
statPrefixActiveHosts: prefix + "activeHosts:",
... | |
c161036 |
s.postCountOneOrLog(s.statNameInvalidConfig)
}
s.postCountOneOrLog(s.statPrefixTlfType + sri.TlfType.String())
s.postCountOneOrLog(s.statPrefixRootType + sri.RootType.String())
s.activityStats.Storer.RecordActives(sri.TlfID, sri.Host)
} | |
c161037 | mapLoadFactor))
numBuckets := int(math.Exp2(B))
return hmapStructSize +
bucketSizeWithoutIndirectPointerOverhead*numBuckets +
(keySize+valueSize)*count
} | |
c161038 |
acl.raw = append(acl.raw, bufToSlice(unsafe.Pointer(sid), ssize)...)
for len(acl.raw)&3 != 0 {
acl.raw = append(acl.raw, 0)
}
acl.aceCount++
} | |
c161039 | getHash := func(root libkb.MerkleRoot) string {
return root.ProofServicesHash()
}
kitFilename := g.Env.GetParamProofKitFilename()
s := merklestore.NewMerkleStore(g, tag, endpoint, kitFilename, supportedVersion, getHash)
g.SetParamProofStore(s)
return s
} | |
c161040 | err
}
b.log(ctx, state)
b.notifyCh <- state
return nil
} | |
c161041 | c2 := keybase1.BadgeConversationInfo{
ConvID: c2id,
UnreadMessages: c1.UnreadMessages,
BadgeCounts: c1.BadgeCounts,
}
state2.Conversations = append(state2.Conversations, c2)
}
b.G().Log.CDebugf(ctx, "Badger send: %+v", state2)
} | |
c161042 | == -1 {
s += string(filepath.Separator)
}
_, err := exec.LookPath(s)
return err
} | |
c161043 | }
edits := config.UserHistory().Get(string(session.Name))
data, err = PrettyJSON(edits)
return data, time.Time{}, err
} | |
c161044 | func() backoff.BackOff { return constBackoff },
DialerTimeout: dialerTimeout,
InitialReconnectBackoffWindow: func() time.Duration { return mdserverReconnectBackoffWindow },
}
mdServer.initNewConnection()
// Check for rekey opportunities periodically.
rekeyCtx, rekeyCancel := contex... | |
c161045 |
isAuthenticated = true
md.authenticatedMtx.Lock()
if !md.isAuthenticated && md.config.Mode().RekeyWorkers() > 0 {
defer func() {
// request a list of folders needing rekey action
if err := md.getFoldersForRekey(ctx, c); err != nil {
md.log.CWarningf(ctx, "getFoldersForRekey failed with %v", err)
}
... | |
c161046 | "+
"failed to connect, reconnecting: %s", err.Error())
if err = md.reconnect(); err != nil {
md.log.CInfof(ctx, "reconnect error: %v", err)
}
} else {
md.log.CInfof(ctx, "MDServerRemote: CheckReachability(): "+
"failed to connect (%s), but not reconnecting", err.Error())
}
}
if conn != nil {... | |
c161047 | := range md.observers {
md.signalObserverLocked(observerChan, id, MDServerDisconnected{})
}
} | |
c161048 | observerChan, id, errors.New("Registration canceled"))
// Setting nil here indicates that the remote MD server thinks
// we're still registered, though locally no one is listening.
md.observers[id] = nil
} | |
c161049 |
observerChan <- err
close(observerChan)
}
delete(md.observers, id)
} | |
c161050 | block.Block,
keybase1.FromTime(block.Timestamp))
if err != nil {
return tlf.ID{}, nil, err
}
rmdses[i] = rmds
if diskMDCache != nil && rmds.MD.MergedStatus() == kbfsmd.Merged {
err = diskMDCache.Stage(
ctx, tlfID, rmds.MD.RevisionNumber(), block.Block, ver,
timestamp)
if err != nil {
re... | |
c161051 | // kbfsmd.NullBranchID signals that the folder's current branch ID
// should be looked up.
arg := keybase1.GetMetadataArg{
FolderHandle: encodedHandle,
BranchID: kbfsmd.NullBranchID.String(),
Unmerged: mStatus == kbfsmd.Unmerged,
LockBeforeGet: lockBeforeGet,
}
id, rmdses, err := md.get(ctx, ar... | |
c161052 | Unmerged: mStatus == kbfsmd.Unmerged,
LockBeforeGet: lockBeforeGet,
}
_, rmdses, err := md.get(getCtx, arg)
switch errors.Cause(err) {
case nil:
case context.DeadlineExceeded:
if cachedRmds != nil {
md.log.CDebugf(ctx, "Can't contact server; using cached MD")
return cachedRmds, nil
}
return ni... | |
c161053 | 0 {
return nil, errors.Errorf("No revision available at %s", serverTime)
}
ver, max := kbfsmd.MetadataVer(block.Version), md.config.MetadataVersion()
rmds, err = DecodeRootMetadataSigned(
md.config.Codec(), id, ver, max, block.Block,
keybase1.FromTime(block.Timestamp))
if err != nil {
return nil, err
}
... | |
c161054 | id.String(),
BranchID: bid.String(),
Unmerged: mStatus == kbfsmd.Unmerged,
StartRevision: start.Number(),
StopRevision: stop.Number(),
LockBeforeGet: lockBeforeGet,
}
_, rmds, err := md.get(ctx, arg)
return rmds, err
} | |
c161055 | %s %s", tlfID, lockID)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: Lock %s %s", tlfID, lockID)
}()
return md.getClient().Lock(ctx, keybase1.LockArg{
FolderID: tlfID.String(),
LockID: lockID,
})
} | |
c161056 |
}()
arg := keybase1.PruneBranchArg{
FolderID: id.String(),
BranchID: bid.String(),
LogTags: nil,
}
return md.getClient().PruneBranch(ctx, arg)
} | |
c161057 |
// not registered
return nil
}
// signal that we've seen the update
md.signalObserverLocked(observerChan, id, nil)
return nil
} | |
c161058 | folder for rekeying
md.config.RekeyQueue().Enqueue(id)
}
// Reset the timer in case there are a lot of rekey folders
// dribbling in from the server still.
md.resetRekeyTimer()
return nil
} | |
c161059 | nil
}
// queue the folder for rekeying
md.config.RekeyQueue().Enqueue(id)
// Reset the timer in case there are a lot of rekey folders
// dribbling in from the server still.
md.resetRekeyTimer()
return nil
} | |
c161060 | if existingCh != nil {
panic(fmt.Sprintf(
"Attempted double-registration for folder: %s", id))
}
c = make(chan error, 1)
md.observers[id] = c
return alreadyRegistered
}()
if alreadyRegistered {
return nil
}
// Use this instead of md.client since we're already
// inside a DoCommand().... | |
c161061 | md.serverOffsetMu.RUnlock()
return md.serverOffset, md.serverOffsetKnown
} | |
c161062 | if err != nil {
return err
}
return client.GetFoldersForRekey(ctx, session.CryptPublicKey.KID())
} | |
c161063 | md.cancelObservers()
// cancel the ping ticker
md.pinger.cancelTicker()
// cancel the auth token ticker
if md.authToken != nil {
md.authToken.Shutdown()
}
if md.rekeyCancel != nil {
md.rekeyCancel()
}
} | |
c161064 | {
conn := md.getConn()
return conn != nil && conn.IsConnected()
} | |
c161065 |
arg := keybase1.GetKeyArg{
KeyHalfID: idBytes,
DeviceKID: cryptKey.KID().String(),
LogTags: nil,
}
keyBytes, err := md.getClient().GetKey(ctx, arg)
if err != nil {
return
}
// decode the key
err = md.config.Codec().Decode(keyBytes, &serverHalf)
if err != nil {
return
}
return
} | |
c161066 | err := md.config.Codec().Encode(serverHalf)
if err != nil {
return err
}
keyHalves = append(keyHalves,
keybase1.KeyHalf{
User: user,
DeviceKID: devicePubKey.KID(),
Key: keyHalf,
})
}
}
// put the keys
arg := keybase1.PutKeysArg{
KeyHalves: keyHalves,
LogTags: n... | |
c161067 |
md.deferLog.LazyTrace(ctx, "KeyServer: DeleteTLFCryptKeyServerHalf %s %s done (err=%v)", uid, serverHalfID, err)
}()
// encode the ID
idBytes, err := md.config.Codec().Encode(serverHalfID)
if err != nil {
return err
}
// get the key
arg := keybase1.DeleteKeyArg{
Uid: uid,
DeviceKID: key.KID(),
... | |
c161068 | response.WriterBundle.Version)
return nil, nil, err
}
wkb = new(kbfsmd.TLFWriterKeyBundleV3)
err = md.config.Codec().Decode(response.WriterBundle.Bundle, wkb)
if err != nil {
return nil, nil, err
}
// Verify it's what we expect.
bundleID, err := kbfsmd.MakeTLFWriterKeyBundleID(md.config.Codec(), *w... | |
c161069 | md.conn.FastForwardInitialBackoffTimer()
} | |
c161070 |
md.log.CDebugf(ctx, "Verifying merkle root %d", response.RootSeqno)
root := keybase1.MerkleRootV2{
Seqno: response.RootSeqno,
HashMeta: response.RootHash,
}
expectedKbfsRoot := keybase1.KBFSRoot{
TreeID: tlfToMerkleTreeID(tlfID),
Root: response.KbfsRoot.Root,
}
err = md.config.KBPKI().VerifyMerkleRo... | |
c161071 | }
if x != name {
names[i] = x
changesMade = true
}
}
return changesMade, nil
} | |
c161072 | ",")
}
if len(extensionSuffix) != 0 {
// This *should* be normalized already but make sure. I can see not
// doing so might surprise a caller.
nExt := strings.ToLower(extensionSuffix)
normalizedName += tlf.HandleExtensionSep + nExt
changesMade = changesMade || nExt != extensionSuffix
}
return normalize... | |
c161073 | }
normalizedName, changes, err := NormalizeNamesInTLF(
writerNames, readerNames, t, extensionSuffix)
if err != nil {
return nil, nil, "", err
}
// Check for changes - not just ordering differences here.
if changes {
return nil, nil, "", errors.WithStack(TlfNameNotCanonical{name, normalizedName})
}
retur... | |
c161074 | making FBO for existing journal for %s: "+
"%+v", tlfID, err)
}
// The popups and errors were suppressed, but any errors would
// have been logged. So just close out the extended identify. If
// the user accesses the TLF directly, another proper identify
// should happen that shows errors.
_... | |
c161075 |
return errors.Errorf("Can't enable journal for %s while there "+
"are any dirty blocks outstanding", tlfID)
}
return nil
}()
if err != nil {
if !allowEnableIfDirty {
return nil, err
}
j.log.CWarningf(ctx,
"Got ignorable error on journal enable, and proceeding anyway: %+v",
err)
}
tlfDir... | |
c161076 | tid := chargedTo.AsTeamOrBust(); tid.IsSubTeam() {
// We can't charge to subteams; find the root team.
rootID, err := j.config.KBPKI().GetTeamRootID(
ctx, tid, j.config.OfflineAvailabilityForID(tlfID))
if err != nil {
return err
}
chargedTo = rootID.AsUserOrTeam()
}
}
tj, err := j.enableLock... | |
c161077 |
j.serverConfig.EnableAuto = true
j.serverConfig.EnableAutoSetByUser = true
return j.writeConfig()
} | |
c161078 | auto-journaling")
j.serverConfig.EnableAuto = false
j.serverConfig.EnableAutoSetByUser = true
return j.writeConfig()
} | |
c161079 |
tlfJournal.pauseBackgroundWork()
return
}
j.log.CDebugf(ctx,
"Could not find journal for %s; dropping pause signal",
tlfID)
} | |
c161080 |
tlfJournal.resumeBackgroundWork()
return
}
j.log.CDebugf(ctx,
"Could not find journal for %s; dropping resume signal",
tlfID)
} | |
c161081 | as well?
return tlfJournal.flush(ctx)
}
j.log.CDebugf(ctx, "Journal not enabled for %s", tlfID)
return nil
} | |
c161082 | tlfJournal.finishSingleOp(ctx, lc, priority)
}
j.log.CDebugf(ctx, "Journal not enabled for %s", tlfID)
return nil
} | |
c161083 | disable journal for %s while there "+
"are outstanding dirty ops", tlfID)
}
if j.delegateDirtyBlockCache.IsAnyDirty(tlfID) {
return false, errors.Errorf("Can't disable journal for %s while there "+
"are any dirty blocks outstanding", tlfID)
}
// Disable the journal. Note that we don't bother deleting the... | |
c161084 | j.currentUID,
CurrentVerifyingKey: j.currentVerifyingKey,
EnableAuto: enableAuto,
EnableAutoSetByUser: enableAutoSetByUser,
JournalCount: len(tlfIDs),
StoredBytes: totalStoredBytes,
StoredFiles: totalStoredFiles,
UnflushedBytes: totalUnflushedBytes,
DiskLimite... | |
c161085 |
errors.Errorf("Journal not enabled for %s", tlfID)
}
return tlfJournal.getJournalStatus()
} | |
c161086 | errors.Errorf("Journal not enabled for %s", tlfID)
}
return tlfJournal.getJournalStatusWithPaths(ctx, cpp)
} | |
c161087 | := range j.tlfJournals {
tlfJournal.shutdown(ctx)
}
j.tlfJournals = make(map[tlf.ID]*tlfJournal)
j.currentUID = keybase1.UID("")
j.currentVerifyingKey = kbfscrypto.VerifyingKey{}
} | |
c161088 | defer j.lock.Unlock()
j.shutdownExistingJournalsLocked(ctx)
} | |
c161089 | defer m.Unlock()
return m.numPutParts
} | |
c161090 | err != nil {
return ZeroRefNonce, err
}
}
return nonce, nil
} | |
c161091 | return Context{Creator: creator, BlockType: bType}
} | |
c161092 | Creator: creator,
Writer: writer,
RefNonce: nonce,
BlockType: bType,
}
} | |
c161093 | {
if !c.Writer.IsNil() {
return c.Writer
}
return c.Creator
} | |
c161094 | newWriter
} else {
// save some bytes by not populating the separate Writer
// field if it matches the creator.
c.Writer = ""
}
} | |
c161095 | if err != nil {
return MerkleHash{}, err
}
h, err := kbfshash.DefaultHash(buf)
if err != nil {
return MerkleHash{}, err
}
return MerkleHash{h}, nil
} | |
c161096 |
return h.h.MarshalBinary()
} | |
c161097 | return h.h.UnmarshalBinary(data)
} | |
c161098 | to.Revocations = combineSignatures(to.Revocations, from.Revocations)
// Finally, merge subkeys
existingSubkeys := make(map[[20]byte]int)
for i, subkey := range to.Subkeys {
existingSubkeys[subkey.PublicKey.Fingerprint] = i
}
for _, subkey := range from.Subkeys {
if i, ok := existingSubkeys[subkey.PublicKey.F... | |
c161099 |
err := p.run()
p.close() // ignore any errors in closing the channel
return err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.