id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
161,000 | keybase/client | go/kbfs/libfuse/fs.go | ReadDirAll | func (r *Root) ReadDirAll(ctx context.Context) (res []fuse.Dirent, err error) {
r.log().CDebugf(ctx, "FS ReadDirAll")
defer func() { err = r.private.fs.processError(ctx, libkbfs.ReadMode, err) }()
res = []fuse.Dirent{
{
Type: fuse.DT_Dir,
Name: PrivateName,
},
{
Type: fuse.DT_Dir,
Name: PublicName,
},
fuse.Dirent{
Type: fuse.DT_Dir,
Name: TeamName,
},
}
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
} | go | func (r *Root) ReadDirAll(ctx context.Context) (res []fuse.Dirent, err error) {
r.log().CDebugf(ctx, "FS ReadDirAll")
defer func() { err = r.private.fs.processError(ctx, libkbfs.ReadMode, err) }()
res = []fuse.Dirent{
{
Type: fuse.DT_Dir,
Name: PrivateName,
},
{
Type: fuse.DT_Dir,
Name: PublicName,
},
fuse.Dirent{
Type: fuse.DT_Dir,
Name: TeamName,
},
}
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
} | [
"func",
"(",
"r",
"*",
"Root",
")",
"ReadDirAll",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"res",
"[",
"]",
"fuse",
".",
"Dirent",
",",
"err",
"error",
")",
"{",
"r",
".",
"log",
"(",
")",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
... | // ReadDirAll implements the ReadDirAll interface for Root. | [
"ReadDirAll",
"implements",
"the",
"ReadDirAll",
"interface",
"for",
"Root",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfuse/fs.go#L535-L560 |
161,001 | keybase/client | go/kbfs/libkbfs/disk_quota_cache.go | getQuotaLocked | func (cache *DiskQuotaCacheLocal) getQuotaLocked(
id keybase1.UserOrTeamID, metered bool) (
info kbfsblock.QuotaInfo, err error) {
var hitMeter, missMeter *CountMeter
if metered {
hitMeter = cache.hitMeter
missMeter = cache.missMeter
}
quotaBytes, err := cache.db.GetWithMeter(
[]byte(id.String()), hitMeter, missMeter)
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
err = cache.config.Codec().Decode(quotaBytes, &info)
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
return info, nil
} | go | func (cache *DiskQuotaCacheLocal) getQuotaLocked(
id keybase1.UserOrTeamID, metered bool) (
info kbfsblock.QuotaInfo, err error) {
var hitMeter, missMeter *CountMeter
if metered {
hitMeter = cache.hitMeter
missMeter = cache.missMeter
}
quotaBytes, err := cache.db.GetWithMeter(
[]byte(id.String()), hitMeter, missMeter)
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
err = cache.config.Codec().Decode(quotaBytes, &info)
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
return info, nil
} | [
"func",
"(",
"cache",
"*",
"DiskQuotaCacheLocal",
")",
"getQuotaLocked",
"(",
"id",
"keybase1",
".",
"UserOrTeamID",
",",
"metered",
"bool",
")",
"(",
"info",
"kbfsblock",
".",
"QuotaInfo",
",",
"err",
"error",
")",
"{",
"var",
"hitMeter",
",",
"missMeter",
... | // getQuotaLocked retrieves the quota info for a block in the cache,
// or returns leveldb.ErrNotFound and a zero-valued metadata
// otherwise. | [
"getQuotaLocked",
"retrieves",
"the",
"quota",
"info",
"for",
"a",
"block",
"in",
"the",
"cache",
"or",
"returns",
"leveldb",
".",
"ErrNotFound",
"and",
"a",
"zero",
"-",
"valued",
"metadata",
"otherwise",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/disk_quota_cache.go#L230-L249 |
161,002 | keybase/client | go/kbfs/libkbfs/disk_quota_cache.go | Get | func (cache *DiskQuotaCacheLocal) Get(
ctx context.Context, id keybase1.UserOrTeamID) (
info kbfsblock.QuotaInfo, err error) {
cache.lock.RLock()
defer cache.lock.RUnlock()
err = cache.checkCacheLocked(ctx, "Quota(Get)")
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
return cache.getQuotaLocked(id, metered)
} | go | func (cache *DiskQuotaCacheLocal) Get(
ctx context.Context, id keybase1.UserOrTeamID) (
info kbfsblock.QuotaInfo, err error) {
cache.lock.RLock()
defer cache.lock.RUnlock()
err = cache.checkCacheLocked(ctx, "Quota(Get)")
if err != nil {
return kbfsblock.QuotaInfo{}, err
}
return cache.getQuotaLocked(id, metered)
} | [
"func",
"(",
"cache",
"*",
"DiskQuotaCacheLocal",
")",
"Get",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"keybase1",
".",
"UserOrTeamID",
")",
"(",
"info",
"kbfsblock",
".",
"QuotaInfo",
",",
"err",
"error",
")",
"{",
"cache",
".",
"lock",
".",
... | // Get implements the DiskQuotaCache interface for DiskQuotaCacheLocal. | [
"Get",
"implements",
"the",
"DiskQuotaCache",
"interface",
"for",
"DiskQuotaCacheLocal",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/disk_quota_cache.go#L285-L296 |
161,003 | keybase/client | go/kbfs/libkbfs/disk_quota_cache.go | Put | func (cache *DiskQuotaCacheLocal) Put(
ctx context.Context, id keybase1.UserOrTeamID,
info kbfsblock.QuotaInfo) (err error) {
cache.lock.Lock()
defer cache.lock.Unlock()
err = cache.checkCacheLocked(ctx, "Quota(Put)")
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
} | go | func (cache *DiskQuotaCacheLocal) Put(
ctx context.Context, id keybase1.UserOrTeamID,
info kbfsblock.QuotaInfo) (err error) {
cache.lock.Lock()
defer cache.lock.Unlock()
err = cache.checkCacheLocked(ctx, "Quota(Put)")
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
} | [
"func",
"(",
"cache",
"*",
"DiskQuotaCacheLocal",
")",
"Put",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"keybase1",
".",
"UserOrTeamID",
",",
"info",
"kbfsblock",
".",
"QuotaInfo",
")",
"(",
"err",
"error",
")",
"{",
"cache",
".",
"lock",
".",
... | // Put implements the DiskQuotaCache interface for DiskQuotaCacheLocal. | [
"Put",
"implements",
"the",
"DiskQuotaCache",
"interface",
"for",
"DiskQuotaCacheLocal",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/disk_quota_cache.go#L299-L322 |
161,004 | keybase/client | go/kbfs/libkbfs/disk_quota_cache.go | Status | func (cache *DiskQuotaCacheLocal) Status(_ context.Context) DiskQuotaCacheStatus {
select {
case <-cache.startedCh:
case <-cache.startErrCh:
return DiskQuotaCacheStatus{StartState: DiskQuotaCacheStartStateFailed}
default:
return DiskQuotaCacheStatus{StartState: DiskQuotaCacheStartStateStarting}
}
cache.lock.RLock()
defer cache.lock.RUnlock()
return DiskQuotaCacheStatus{
StartState: DiskQuotaCacheStartStateStarted,
NumQuotas: uint64(len(cache.quotasCached)),
Hits: rateMeterToStatus(cache.hitMeter),
Misses: rateMeterToStatus(cache.missMeter),
Puts: rateMeterToStatus(cache.putMeter),
}
} | go | func (cache *DiskQuotaCacheLocal) Status(_ context.Context) DiskQuotaCacheStatus {
select {
case <-cache.startedCh:
case <-cache.startErrCh:
return DiskQuotaCacheStatus{StartState: DiskQuotaCacheStartStateFailed}
default:
return DiskQuotaCacheStatus{StartState: DiskQuotaCacheStartStateStarting}
}
cache.lock.RLock()
defer cache.lock.RUnlock()
return DiskQuotaCacheStatus{
StartState: DiskQuotaCacheStartStateStarted,
NumQuotas: uint64(len(cache.quotasCached)),
Hits: rateMeterToStatus(cache.hitMeter),
Misses: rateMeterToStatus(cache.missMeter),
Puts: rateMeterToStatus(cache.putMeter),
}
} | [
"func",
"(",
"cache",
"*",
"DiskQuotaCacheLocal",
")",
"Status",
"(",
"_",
"context",
".",
"Context",
")",
"DiskQuotaCacheStatus",
"{",
"select",
"{",
"case",
"<-",
"cache",
".",
"startedCh",
":",
"case",
"<-",
"cache",
".",
"startErrCh",
":",
"return",
"D... | // Status implements the DiskQuotaCache interface for DiskQuotaCacheLocal. | [
"Status",
"implements",
"the",
"DiskQuotaCache",
"interface",
"for",
"DiskQuotaCacheLocal",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/disk_quota_cache.go#L325-L344 |
161,005 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | NewBlockServerMeasured | func NewBlockServerMeasured(delegate BlockServer, r metrics.Registry) BlockServerMeasured {
getTimer := metrics.GetOrRegisterTimer("BlockServer.Get", r)
getEncodedSizeTimer := metrics.GetOrRegisterTimer(
"BlockServer.GetEncodedSize", r)
putTimer := metrics.GetOrRegisterTimer("BlockServer.Put", r)
addBlockReferenceTimer := metrics.GetOrRegisterTimer("BlockServer.AddBlockReference", r)
removeBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.RemoveBlockReferences", r)
archiveBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.ArchiveBlockReferences", r)
getLiveBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.GetLiveBlockReferences", r)
isUnflushedTimer := metrics.GetOrRegisterTimer("BlockServer.IsUnflushed", r)
return BlockServerMeasured{
delegate: delegate,
getTimer: getTimer,
getEncodedSizeTimer: getEncodedSizeTimer,
putTimer: putTimer,
addBlockReferenceTimer: addBlockReferenceTimer,
removeBlockReferencesTimer: removeBlockReferencesTimer,
archiveBlockReferencesTimer: archiveBlockReferencesTimer,
getLiveBlockReferencesTimer: getLiveBlockReferencesTimer,
isUnflushedTimer: isUnflushedTimer,
}
} | go | func NewBlockServerMeasured(delegate BlockServer, r metrics.Registry) BlockServerMeasured {
getTimer := metrics.GetOrRegisterTimer("BlockServer.Get", r)
getEncodedSizeTimer := metrics.GetOrRegisterTimer(
"BlockServer.GetEncodedSize", r)
putTimer := metrics.GetOrRegisterTimer("BlockServer.Put", r)
addBlockReferenceTimer := metrics.GetOrRegisterTimer("BlockServer.AddBlockReference", r)
removeBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.RemoveBlockReferences", r)
archiveBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.ArchiveBlockReferences", r)
getLiveBlockReferencesTimer := metrics.GetOrRegisterTimer("BlockServer.GetLiveBlockReferences", r)
isUnflushedTimer := metrics.GetOrRegisterTimer("BlockServer.IsUnflushed", r)
return BlockServerMeasured{
delegate: delegate,
getTimer: getTimer,
getEncodedSizeTimer: getEncodedSizeTimer,
putTimer: putTimer,
addBlockReferenceTimer: addBlockReferenceTimer,
removeBlockReferencesTimer: removeBlockReferencesTimer,
archiveBlockReferencesTimer: archiveBlockReferencesTimer,
getLiveBlockReferencesTimer: getLiveBlockReferencesTimer,
isUnflushedTimer: isUnflushedTimer,
}
} | [
"func",
"NewBlockServerMeasured",
"(",
"delegate",
"BlockServer",
",",
"r",
"metrics",
".",
"Registry",
")",
"BlockServerMeasured",
"{",
"getTimer",
":=",
"metrics",
".",
"GetOrRegisterTimer",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"getEncodedSizeTimer",
":=",
"m... | // NewBlockServerMeasured creates and returns a new
// BlockServerMeasured instance with the given delegate and registry. | [
"NewBlockServerMeasured",
"creates",
"and",
"returns",
"a",
"new",
"BlockServerMeasured",
"instance",
"with",
"the",
"given",
"delegate",
"and",
"registry",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L35-L56 |
161,006 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | Get | func (b BlockServerMeasured) Get(
ctx context.Context, tlfID tlf.ID, id kbfsblock.ID,
context kbfsblock.Context, cacheType DiskBlockCacheType) (
buf []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, err error) {
b.getTimer.Time(func() {
buf, serverHalf, err = b.delegate.Get(
ctx, tlfID, id, context, cacheType)
})
return buf, serverHalf, err
} | go | func (b BlockServerMeasured) Get(
ctx context.Context, tlfID tlf.ID, id kbfsblock.ID,
context kbfsblock.Context, cacheType DiskBlockCacheType) (
buf []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, err error) {
b.getTimer.Time(func() {
buf, serverHalf, err = b.delegate.Get(
ctx, tlfID, id, context, cacheType)
})
return buf, serverHalf, err
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"Get",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"id",
"kbfsblock",
".",
"ID",
",",
"context",
"kbfsblock",
".",
"Context",
",",
"cacheType",
"DiskBlockCacheType",
")",
"(",
... | // Get implements the BlockServer interface for BlockServerMeasured. | [
"Get",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L59-L68 |
161,007 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | GetEncodedSize | func (b BlockServerMeasured) GetEncodedSize(
ctx context.Context, tlfID tlf.ID, id kbfsblock.ID,
context kbfsblock.Context) (
size uint32, status keybase1.BlockStatus, err error) {
b.getEncodedSizeTimer.Time(func() {
size, status, err = b.delegate.GetEncodedSize(ctx, tlfID, id, context)
})
return size, status, err
} | go | func (b BlockServerMeasured) GetEncodedSize(
ctx context.Context, tlfID tlf.ID, id kbfsblock.ID,
context kbfsblock.Context) (
size uint32, status keybase1.BlockStatus, err error) {
b.getEncodedSizeTimer.Time(func() {
size, status, err = b.delegate.GetEncodedSize(ctx, tlfID, id, context)
})
return size, status, err
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"GetEncodedSize",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"id",
"kbfsblock",
".",
"ID",
",",
"context",
"kbfsblock",
".",
"Context",
")",
"(",
"size",
"uint32",
",",
"statu... | // GetEncodedSize implements the BlockServer interface for BlockServerMeasured. | [
"GetEncodedSize",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L71-L79 |
161,008 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | AddBlockReference | func (b BlockServerMeasured) AddBlockReference(ctx context.Context, tlfID tlf.ID,
id kbfsblock.ID, context kbfsblock.Context) (err error) {
b.addBlockReferenceTimer.Time(func() {
err = b.delegate.AddBlockReference(ctx, tlfID, id, context)
})
return err
} | go | func (b BlockServerMeasured) AddBlockReference(ctx context.Context, tlfID tlf.ID,
id kbfsblock.ID, context kbfsblock.Context) (err error) {
b.addBlockReferenceTimer.Time(func() {
err = b.delegate.AddBlockReference(ctx, tlfID, id, context)
})
return err
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"AddBlockReference",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"id",
"kbfsblock",
".",
"ID",
",",
"context",
"kbfsblock",
".",
"Context",
")",
"(",
"err",
"error",
")",
"{",
... | // AddBlockReference implements the BlockServer interface for
// BlockServerMeasured. | [
"AddBlockReference",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L109-L115 |
161,009 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | RemoveBlockReferences | func (b BlockServerMeasured) RemoveBlockReferences(ctx context.Context,
tlfID tlf.ID, contexts kbfsblock.ContextMap) (
liveCounts map[kbfsblock.ID]int, err error) {
b.removeBlockReferencesTimer.Time(func() {
liveCounts, err = b.delegate.RemoveBlockReferences(
ctx, tlfID, contexts)
})
return liveCounts, err
} | go | func (b BlockServerMeasured) RemoveBlockReferences(ctx context.Context,
tlfID tlf.ID, contexts kbfsblock.ContextMap) (
liveCounts map[kbfsblock.ID]int, err error) {
b.removeBlockReferencesTimer.Time(func() {
liveCounts, err = b.delegate.RemoveBlockReferences(
ctx, tlfID, contexts)
})
return liveCounts, err
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"RemoveBlockReferences",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"contexts",
"kbfsblock",
".",
"ContextMap",
")",
"(",
"liveCounts",
"map",
"[",
"kbfsblock",
".",
"ID",
"]",
... | // RemoveBlockReferences implements the BlockServer interface for
// BlockServerMeasured. | [
"RemoveBlockReferences",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L119-L127 |
161,010 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | ArchiveBlockReferences | func (b BlockServerMeasured) ArchiveBlockReferences(ctx context.Context,
tlfID tlf.ID, contexts kbfsblock.ContextMap) (err error) {
b.archiveBlockReferencesTimer.Time(func() {
err = b.delegate.ArchiveBlockReferences(ctx, tlfID, contexts)
})
return err
} | go | func (b BlockServerMeasured) ArchiveBlockReferences(ctx context.Context,
tlfID tlf.ID, contexts kbfsblock.ContextMap) (err error) {
b.archiveBlockReferencesTimer.Time(func() {
err = b.delegate.ArchiveBlockReferences(ctx, tlfID, contexts)
})
return err
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"ArchiveBlockReferences",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"contexts",
"kbfsblock",
".",
"ContextMap",
")",
"(",
"err",
"error",
")",
"{",
"b",
".",
"archiveBlockReferen... | // ArchiveBlockReferences implements the BlockServer interface for
// BlockServerMeasured. | [
"ArchiveBlockReferences",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L131-L137 |
161,011 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | IsUnflushed | func (b BlockServerMeasured) IsUnflushed(ctx context.Context, tlfID tlf.ID,
id kbfsblock.ID) (isUnflushed bool, err error) {
b.isUnflushedTimer.Time(func() {
isUnflushed, err = b.delegate.IsUnflushed(ctx, tlfID, id)
})
return isUnflushed, err
} | go | func (b BlockServerMeasured) IsUnflushed(ctx context.Context, tlfID tlf.ID,
id kbfsblock.ID) (isUnflushed bool, err error) {
b.isUnflushedTimer.Time(func() {
isUnflushed, err = b.delegate.IsUnflushed(ctx, tlfID, id)
})
return isUnflushed, err
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"IsUnflushed",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"id",
"kbfsblock",
".",
"ID",
")",
"(",
"isUnflushed",
"bool",
",",
"err",
"error",
")",
"{",
"b",
".",
"isUnflushe... | // IsUnflushed implements the BlockServer interface for BlockServerMeasured. | [
"IsUnflushed",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L152-L159 |
161,012 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | Shutdown | func (b BlockServerMeasured) Shutdown(ctx context.Context) {
b.delegate.Shutdown(ctx)
} | go | func (b BlockServerMeasured) Shutdown(ctx context.Context) {
b.delegate.Shutdown(ctx)
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"b",
".",
"delegate",
".",
"Shutdown",
"(",
"ctx",
")",
"\n",
"}"
] | // Shutdown implements the BlockServer interface for
// BlockServerMeasured. | [
"Shutdown",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L163-L165 |
161,013 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | RefreshAuthToken | func (b BlockServerMeasured) RefreshAuthToken(ctx context.Context) {
b.delegate.RefreshAuthToken(ctx)
} | go | func (b BlockServerMeasured) RefreshAuthToken(ctx context.Context) {
b.delegate.RefreshAuthToken(ctx)
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"RefreshAuthToken",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"b",
".",
"delegate",
".",
"RefreshAuthToken",
"(",
"ctx",
")",
"\n",
"}"
] | // RefreshAuthToken implements the BlockServer interface for
// BlockServerMeasured. | [
"RefreshAuthToken",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L169-L171 |
161,014 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | GetUserQuotaInfo | func (b BlockServerMeasured) GetUserQuotaInfo(ctx context.Context) (info *kbfsblock.QuotaInfo, err error) {
return b.delegate.GetUserQuotaInfo(ctx)
} | go | func (b BlockServerMeasured) GetUserQuotaInfo(ctx context.Context) (info *kbfsblock.QuotaInfo, err error) {
return b.delegate.GetUserQuotaInfo(ctx)
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"GetUserQuotaInfo",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"info",
"*",
"kbfsblock",
".",
"QuotaInfo",
",",
"err",
"error",
")",
"{",
"return",
"b",
".",
"delegate",
".",
"GetUserQuotaInfo",
"(",
"ctx... | // GetUserQuotaInfo implements the BlockServer interface for BlockServerMeasured | [
"GetUserQuotaInfo",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L174-L176 |
161,015 | keybase/client | go/kbfs/libkbfs/bserver_measured.go | GetTeamQuotaInfo | func (b BlockServerMeasured) GetTeamQuotaInfo(
ctx context.Context, tid keybase1.TeamID) (
info *kbfsblock.QuotaInfo, err error) {
return b.delegate.GetTeamQuotaInfo(ctx, tid)
} | go | func (b BlockServerMeasured) GetTeamQuotaInfo(
ctx context.Context, tid keybase1.TeamID) (
info *kbfsblock.QuotaInfo, err error) {
return b.delegate.GetTeamQuotaInfo(ctx, tid)
} | [
"func",
"(",
"b",
"BlockServerMeasured",
")",
"GetTeamQuotaInfo",
"(",
"ctx",
"context",
".",
"Context",
",",
"tid",
"keybase1",
".",
"TeamID",
")",
"(",
"info",
"*",
"kbfsblock",
".",
"QuotaInfo",
",",
"err",
"error",
")",
"{",
"return",
"b",
".",
"dele... | // GetTeamQuotaInfo implements the BlockServer interface for BlockServerMeasured | [
"GetTeamQuotaInfo",
"implements",
"the",
"BlockServer",
"interface",
"for",
"BlockServerMeasured"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/bserver_measured.go#L179-L183 |
161,016 | keybase/client | go/teams/implicit.go | attemptLoadImpteamAndConflict | func attemptLoadImpteamAndConflict(ctx context.Context, g *libkb.GlobalContext, impTeamName keybase1.ImplicitTeamDisplayName,
nameWithoutConflict string, preResolveDisplayName string, skipCache bool) (conflicts []keybase1.ImplicitTeamConflictInfo, teamID keybase1.TeamID, hitCache bool, err error) {
defer g.CTraceTimed(ctx,
fmt.Sprintf("attemptLoadImpteamAndConflict(impName=%q,woConflict=%q,preResolve=%q,skipCache=%t)", impTeamName, nameWithoutConflict, preResolveDisplayName, skipCache),
func() error { return err })()
imp, hitCache, err := loadImpteam(ctx, g, nameWithoutConflict, impTeamName.IsPublic, skipCache)
if err != nil {
return conflicts, teamID, hitCache, err
}
if len(imp.Conflicts) > 0 {
g.Log.CDebugf(ctx, "LookupImplicitTeam found %v conflicts", len(imp.Conflicts))
}
// We will use this team. Changed later if we selected a conflict.
var foundSelectedConflict bool
teamID = imp.TeamID
// We still need to iterate over Conflicts because we are returning parsed
// conflict 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, "LookupImplicitTeam got conflict suffix: %v", err)
err = nil
continue
}
conflicts = append(conflicts, *conflictInfo)
if conflictInfo == nil {
g.Log.CDebugf(ctx, "| got unexpected nil conflictInfo (iter %d)", i)
continue
}
g.Log.CDebugf(ctx, "| parsed conflict into conflictInfo: %+v", *conflictInfo)
if impTeamName.ConflictInfo != nil {
match := libkb.FormatImplicitTeamDisplayNameSuffix(*impTeamName.ConflictInfo) == libkb.FormatImplicitTeamDisplayNameSuffix(*conflictInfo)
if match {
teamID = conflict.TeamID
foundSelectedConflict = true
g.Log.CDebugf(ctx, "| found conflict suffix match: %v", teamID)
} else {
g.Log.CDebugf(ctx, "| conflict suffix didn't match (teamID %v)", conflict.TeamID)
}
}
}
if impTeamName.ConflictInfo != nil && !foundSelectedConflict {
// We got the team but didn't find the specific conflict requested.
return conflicts, teamID, hitCache, NewTeamDoesNotExistError(
impTeamName.IsPublic, "could not find team with suffix: %v", preResolveDisplayName)
}
return conflicts, teamID, hitCache, nil
} | go | func attemptLoadImpteamAndConflict(ctx context.Context, g *libkb.GlobalContext, impTeamName keybase1.ImplicitTeamDisplayName,
nameWithoutConflict string, preResolveDisplayName string, skipCache bool) (conflicts []keybase1.ImplicitTeamConflictInfo, teamID keybase1.TeamID, hitCache bool, err error) {
defer g.CTraceTimed(ctx,
fmt.Sprintf("attemptLoadImpteamAndConflict(impName=%q,woConflict=%q,preResolve=%q,skipCache=%t)", impTeamName, nameWithoutConflict, preResolveDisplayName, skipCache),
func() error { return err })()
imp, hitCache, err := loadImpteam(ctx, g, nameWithoutConflict, impTeamName.IsPublic, skipCache)
if err != nil {
return conflicts, teamID, hitCache, err
}
if len(imp.Conflicts) > 0 {
g.Log.CDebugf(ctx, "LookupImplicitTeam found %v conflicts", len(imp.Conflicts))
}
// We will use this team. Changed later if we selected a conflict.
var foundSelectedConflict bool
teamID = imp.TeamID
// We still need to iterate over Conflicts because we are returning parsed
// conflict 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, "LookupImplicitTeam got conflict suffix: %v", err)
err = nil
continue
}
conflicts = append(conflicts, *conflictInfo)
if conflictInfo == nil {
g.Log.CDebugf(ctx, "| got unexpected nil conflictInfo (iter %d)", i)
continue
}
g.Log.CDebugf(ctx, "| parsed conflict into conflictInfo: %+v", *conflictInfo)
if impTeamName.ConflictInfo != nil {
match := libkb.FormatImplicitTeamDisplayNameSuffix(*impTeamName.ConflictInfo) == libkb.FormatImplicitTeamDisplayNameSuffix(*conflictInfo)
if match {
teamID = conflict.TeamID
foundSelectedConflict = true
g.Log.CDebugf(ctx, "| found conflict suffix match: %v", teamID)
} else {
g.Log.CDebugf(ctx, "| conflict suffix didn't match (teamID %v)", conflict.TeamID)
}
}
}
if impTeamName.ConflictInfo != nil && !foundSelectedConflict {
// We got the team but didn't find the specific conflict requested.
return conflicts, teamID, hitCache, NewTeamDoesNotExistError(
impTeamName.IsPublic, "could not find team with suffix: %v", preResolveDisplayName)
}
return conflicts, teamID, hitCache, nil
} | [
"func",
"attemptLoadImpteamAndConflict",
"(",
"ctx",
"context",
".",
"Context",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"impTeamName",
"keybase1",
".",
"ImplicitTeamDisplayName",
",",
"nameWithoutConflict",
"string",
",",
"preResolveDisplayName",
"string",
... | // attemptLoadImpteamAndConflits attempts to lead the implicit team with
// conflict, but it might find the team but not the specific conflict if the
// conflict was not in cache. This can be detected with `hitCache` return
// value, and mitigated by passing skipCache=false argument. | [
"attemptLoadImpteamAndConflits",
"attempts",
"to",
"lead",
"the",
"implicit",
"team",
"with",
"conflict",
"but",
"it",
"might",
"find",
"the",
"team",
"but",
"not",
"the",
"specific",
"conflict",
"if",
"the",
"conflict",
"was",
"not",
"in",
"cache",
".",
"This... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/implicit.go#L121-L176 |
161,017 | keybase/client | go/teams/implicit.go | LookupOrCreateImplicitTeam | func LookupOrCreateImplicitTeam(ctx context.Context, g *libkb.GlobalContext, displayName string, public bool) (res *Team, teamName keybase1.TeamName, impTeamName keybase1.ImplicitTeamDisplayName, err error) {
defer g.CTraceTimed(ctx, fmt.Sprintf("LookupOrCreateImplicitTeam(%v)", displayName),
func() error { return err })()
lookupName, err := ResolveImplicitTeamDisplayName(ctx, g, displayName, public)
if err != nil {
return res, teamName, impTeamName, err
}
res, teamName, impTeamName, _, err = lookupImplicitTeamAndConflicts(ctx, g, displayName, lookupName, ImplicitTeamOptions{})
if err != nil {
if _, ok := err.(TeamDoesNotExistError); ok {
if lookupName.ConflictInfo != nil {
// Don't create it if a conflict is specified.
// Unlikely a caller would know the conflict info if it didn't exist.
return res, teamName, impTeamName, err
}
// If the team does not exist, then let's create it
impTeamName = lookupName
var teamID keybase1.TeamID
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, displayName,
lookupName, ImplicitTeamOptions{})
}
return res, teamName, impTeamName, err
}
res, err = Load(ctx, g, keybase1.LoadTeamArg{
ID: teamID,
Public: impTeamName.IsPublic,
ForceRepoll: true,
})
return res, teamName, impTeamName, err
}
return res, teamName, impTeamName, err
}
return res, teamName, impTeamName, nil
} | go | func LookupOrCreateImplicitTeam(ctx context.Context, g *libkb.GlobalContext, displayName string, public bool) (res *Team, teamName keybase1.TeamName, impTeamName keybase1.ImplicitTeamDisplayName, err error) {
defer g.CTraceTimed(ctx, fmt.Sprintf("LookupOrCreateImplicitTeam(%v)", displayName),
func() error { return err })()
lookupName, err := ResolveImplicitTeamDisplayName(ctx, g, displayName, public)
if err != nil {
return res, teamName, impTeamName, err
}
res, teamName, impTeamName, _, err = lookupImplicitTeamAndConflicts(ctx, g, displayName, lookupName, ImplicitTeamOptions{})
if err != nil {
if _, ok := err.(TeamDoesNotExistError); ok {
if lookupName.ConflictInfo != nil {
// Don't create it if a conflict is specified.
// Unlikely a caller would know the conflict info if it didn't exist.
return res, teamName, impTeamName, err
}
// If the team does not exist, then let's create it
impTeamName = lookupName
var teamID keybase1.TeamID
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, displayName,
lookupName, ImplicitTeamOptions{})
}
return res, teamName, impTeamName, err
}
res, err = Load(ctx, g, keybase1.LoadTeamArg{
ID: teamID,
Public: impTeamName.IsPublic,
ForceRepoll: true,
})
return res, teamName, impTeamName, err
}
return res, teamName, impTeamName, err
}
return res, teamName, impTeamName, nil
} | [
"func",
"LookupOrCreateImplicitTeam",
"(",
"ctx",
"context",
".",
"Context",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"displayName",
"string",
",",
"public",
"bool",
")",
"(",
"res",
"*",
"Team",
",",
"teamName",
"keybase1",
".",
"TeamName",
",",
... | // LookupOrCreateImplicitTeam by name like "alice,bob+bob@twitter (conflicted copy 2017-03-04 #1)"
// Resolves social assertions. | [
"LookupOrCreateImplicitTeam",
"by",
"name",
"like",
"alice",
"bob",
"+",
"bob"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/implicit.go#L257-L295 |
161,018 | keybase/client | go/teams/implicit.go | FormatImplicitTeamDisplayNameWithUserFront | func FormatImplicitTeamDisplayNameWithUserFront(ctx context.Context, g *libkb.GlobalContext, impTeamName keybase1.ImplicitTeamDisplayName, frontName libkb.NormalizedUsername) (string, error) {
return formatImplicitTeamDisplayNameCommon(ctx, g, impTeamName, &frontName)
} | go | func FormatImplicitTeamDisplayNameWithUserFront(ctx context.Context, g *libkb.GlobalContext, impTeamName keybase1.ImplicitTeamDisplayName, frontName libkb.NormalizedUsername) (string, error) {
return formatImplicitTeamDisplayNameCommon(ctx, g, impTeamName, &frontName)
} | [
"func",
"FormatImplicitTeamDisplayNameWithUserFront",
"(",
"ctx",
"context",
".",
"Context",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"impTeamName",
"keybase1",
".",
"ImplicitTeamDisplayName",
",",
"frontName",
"libkb",
".",
"NormalizedUsername",
")",
"(",
... | // Format an implicit display name, but order the specified username first in each of the writer and reader lists if it appears. | [
"Format",
"an",
"implicit",
"display",
"name",
"but",
"order",
"the",
"specified",
"username",
"first",
"in",
"each",
"of",
"the",
"writer",
"and",
"reader",
"lists",
"if",
"it",
"appears",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/implicit.go#L302-L304 |
161,019 | keybase/client | go/teams/implicit.go | sortStringsFront | func sortStringsFront(ss []string, front string) {
sort.Slice(ss, func(i, j int) bool {
a := ss[i]
b := ss[j]
if a == front {
return true
}
if b == front {
return false
}
return a < b
})
} | go | func sortStringsFront(ss []string, front string) {
sort.Slice(ss, func(i, j int) bool {
a := ss[i]
b := ss[j]
if a == front {
return true
}
if b == front {
return false
}
return a < b
})
} | [
"func",
"sortStringsFront",
"(",
"ss",
"[",
"]",
"string",
",",
"front",
"string",
")",
"{",
"sort",
".",
"Slice",
"(",
"ss",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"a",
":=",
"ss",
"[",
"i",
"]",
"\n",
"b",
":=",
"ss",
"["... | // Sort a list of strings but order `front` in front IF it appears. | [
"Sort",
"a",
"list",
"of",
"strings",
"but",
"order",
"front",
"in",
"front",
"IF",
"it",
"appears",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/implicit.go#L346-L358 |
161,020 | keybase/client | go/protocol/keybase1/kbfs.go | FSEditList | func (c KbfsClient) FSEditList(ctx context.Context, __arg FSEditListArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSEditList", []interface{}{__arg}, nil)
return
} | go | func (c KbfsClient) FSEditList(ctx context.Context, __arg FSEditListArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSEditList", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"FSEditList",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"FSEditListArg",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"[",
"]",
"in... | // kbfs calls this as a response to receiving an FSEditListRequest with a
// given requestID. | [
"kbfs",
"calls",
"this",
"as",
"a",
"response",
"to",
"receiving",
"an",
"FSEditListRequest",
"with",
"a",
"given",
"requestID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L330-L333 |
161,021 | keybase/client | go/protocol/keybase1/kbfs.go | FSSyncStatus | func (c KbfsClient) FSSyncStatus(ctx context.Context, __arg FSSyncStatusArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSSyncStatus", []interface{}{__arg}, nil)
return
} | go | func (c KbfsClient) FSSyncStatus(ctx context.Context, __arg FSSyncStatusArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSSyncStatus", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"FSSyncStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"FSSyncStatusArg",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"[",
"]",
... | // FSSyncStatus is called by KBFS as a response to receiving an
// FSSyncStatusRequest with a given requestID. | [
"FSSyncStatus",
"is",
"called",
"by",
"KBFS",
"as",
"a",
"response",
"to",
"receiving",
"an",
"FSSyncStatusRequest",
"with",
"a",
"given",
"requestID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L337-L340 |
161,022 | keybase/client | go/protocol/keybase1/kbfs.go | FSSyncEvent | func (c KbfsClient) FSSyncEvent(ctx context.Context, event FSPathSyncStatus) (err error) {
__arg := FSSyncEventArg{Event: event}
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSSyncEvent", []interface{}{__arg}, nil)
return
} | go | func (c KbfsClient) FSSyncEvent(ctx context.Context, event FSPathSyncStatus) (err error) {
__arg := FSSyncEventArg{Event: event}
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSSyncEvent", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"FSSyncEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"FSPathSyncStatus",
")",
"(",
"err",
"error",
")",
"{",
"__arg",
":=",
"FSSyncEventArg",
"{",
"Event",
":",
"event",
"}",
"\n",
"err",
"=",
"c",
".... | // FSSyncEvent is called by KBFS when the sync status of an individual path
// changes. | [
"FSSyncEvent",
"is",
"called",
"by",
"KBFS",
"when",
"the",
"sync",
"status",
"of",
"an",
"individual",
"path",
"changes",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L344-L348 |
161,023 | keybase/client | go/protocol/keybase1/kbfs.go | FSOverallSyncEvent | func (c KbfsClient) FSOverallSyncEvent(ctx context.Context, status FolderSyncStatus) (err error) {
__arg := FSOverallSyncEventArg{Status: status}
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSOverallSyncEvent", []interface{}{__arg}, nil)
return
} | go | func (c KbfsClient) FSOverallSyncEvent(ctx context.Context, status FolderSyncStatus) (err error) {
__arg := FSOverallSyncEventArg{Status: status}
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSOverallSyncEvent", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"FSOverallSyncEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"status",
"FolderSyncStatus",
")",
"(",
"err",
"error",
")",
"{",
"__arg",
":=",
"FSOverallSyncEventArg",
"{",
"Status",
":",
"status",
"}",
"\n",
"err",
... | // FSOverallSyncEvent is called by KBFS when the overall sync status
// changes. | [
"FSOverallSyncEvent",
"is",
"called",
"by",
"KBFS",
"when",
"the",
"overall",
"sync",
"status",
"changes",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L352-L356 |
161,024 | keybase/client | go/protocol/keybase1/kbfs.go | FSOnlineStatusChangedEvent | func (c KbfsClient) FSOnlineStatusChangedEvent(ctx context.Context, online bool) (err error) {
__arg := FSOnlineStatusChangedEventArg{Online: online}
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSOnlineStatusChangedEvent", []interface{}{__arg}, nil)
return
} | go | func (c KbfsClient) FSOnlineStatusChangedEvent(ctx context.Context, online bool) (err error) {
__arg := FSOnlineStatusChangedEventArg{Online: online}
err = c.Cli.Call(ctx, "keybase.1.kbfs.FSOnlineStatusChangedEvent", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"FSOnlineStatusChangedEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"online",
"bool",
")",
"(",
"err",
"error",
")",
"{",
"__arg",
":=",
"FSOnlineStatusChangedEventArg",
"{",
"Online",
":",
"online",
"}",
"\n",
"err... | // FSOnlineStatusChangedEvent is called by KBFS when the online status changes. | [
"FSOnlineStatusChangedEvent",
"is",
"called",
"by",
"KBFS",
"when",
"the",
"online",
"status",
"changes",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L359-L363 |
161,025 | keybase/client | go/protocol/keybase1/kbfs.go | CreateTLF | func (c KbfsClient) CreateTLF(ctx context.Context, __arg CreateTLFArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.createTLF", []interface{}{__arg}, nil)
return
} | go | func (c KbfsClient) CreateTLF(ctx context.Context, __arg CreateTLFArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.createTLF", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"CreateTLF",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"CreateTLFArg",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"[",
"]",
"inte... | // createTLF is called by KBFS to associate the tlfID with the given teamID,
// using the v2 Team-based system. | [
"createTLF",
"is",
"called",
"by",
"KBFS",
"to",
"associate",
"the",
"tlfID",
"with",
"the",
"given",
"teamID",
"using",
"the",
"v2",
"Team",
"-",
"based",
"system",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L367-L370 |
161,026 | keybase/client | go/protocol/keybase1/kbfs.go | GetKBFSTeamSettings | func (c KbfsClient) GetKBFSTeamSettings(ctx context.Context, __arg GetKBFSTeamSettingsArg) (res KBFSTeamSettings, err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.getKBFSTeamSettings", []interface{}{__arg}, &res)
return
} | go | func (c KbfsClient) GetKBFSTeamSettings(ctx context.Context, __arg GetKBFSTeamSettingsArg) (res KBFSTeamSettings, err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.getKBFSTeamSettings", []interface{}{__arg}, &res)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"GetKBFSTeamSettings",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"GetKBFSTeamSettingsArg",
")",
"(",
"res",
"KBFSTeamSettings",
",",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
... | // getKBFSTeamSettings gets the settings written for the team in the team's sigchain. | [
"getKBFSTeamSettings",
"gets",
"the",
"settings",
"written",
"for",
"the",
"team",
"in",
"the",
"team",
"s",
"sigchain",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L373-L376 |
161,027 | keybase/client | go/protocol/keybase1/kbfs.go | UpgradeTLF | func (c KbfsClient) UpgradeTLF(ctx context.Context, __arg UpgradeTLFArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.upgradeTLF", []interface{}{__arg}, nil)
return
} | go | func (c KbfsClient) UpgradeTLF(ctx context.Context, __arg UpgradeTLFArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.kbfs.upgradeTLF", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"UpgradeTLF",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"UpgradeTLFArg",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"[",
"]",
"in... | // upgradeTLF upgrades a TLF to use implicit team keys | [
"upgradeTLF",
"upgrades",
"a",
"TLF",
"to",
"use",
"implicit",
"team",
"keys"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L379-L382 |
161,028 | keybase/client | go/protocol/keybase1/kbfs.go | EncryptFavorites | func (c KbfsClient) EncryptFavorites(ctx context.Context, dataToEncrypt []byte) (res []byte, err error) {
__arg := EncryptFavoritesArg{DataToEncrypt: dataToEncrypt}
err = c.Cli.Call(ctx, "keybase.1.kbfs.encryptFavorites", []interface{}{__arg}, &res)
return
} | go | func (c KbfsClient) EncryptFavorites(ctx context.Context, dataToEncrypt []byte) (res []byte, err error) {
__arg := EncryptFavoritesArg{DataToEncrypt: dataToEncrypt}
err = c.Cli.Call(ctx, "keybase.1.kbfs.encryptFavorites", []interface{}{__arg}, &res)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"EncryptFavorites",
"(",
"ctx",
"context",
".",
"Context",
",",
"dataToEncrypt",
"[",
"]",
"byte",
")",
"(",
"res",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"__arg",
":=",
"EncryptFavoritesArg",
"{",
"DataToEn... | // Encrypt cached favorites to store on disk. | [
"Encrypt",
"cached",
"favorites",
"to",
"store",
"on",
"disk",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L385-L389 |
161,029 | keybase/client | go/protocol/keybase1/kbfs.go | DecryptFavorites | func (c KbfsClient) DecryptFavorites(ctx context.Context, dataToEncrypt []byte) (res []byte, err error) {
__arg := DecryptFavoritesArg{DataToEncrypt: dataToEncrypt}
err = c.Cli.Call(ctx, "keybase.1.kbfs.decryptFavorites", []interface{}{__arg}, &res)
return
} | go | func (c KbfsClient) DecryptFavorites(ctx context.Context, dataToEncrypt []byte) (res []byte, err error) {
__arg := DecryptFavoritesArg{DataToEncrypt: dataToEncrypt}
err = c.Cli.Call(ctx, "keybase.1.kbfs.decryptFavorites", []interface{}{__arg}, &res)
return
} | [
"func",
"(",
"c",
"KbfsClient",
")",
"DecryptFavorites",
"(",
"ctx",
"context",
".",
"Context",
",",
"dataToEncrypt",
"[",
"]",
"byte",
")",
"(",
"res",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"__arg",
":=",
"DecryptFavoritesArg",
"{",
"DataToEn... | // Decrypt cached favorites stored on disk. | [
"Decrypt",
"cached",
"favorites",
"stored",
"on",
"disk",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/kbfs.go#L392-L396 |
161,030 | keybase/client | go/qrcode/qrcode.go | Encode | func Encode(data []byte) (*Encodings, error) {
code, err := qr.Encode(string(data), qr.L)
if err != nil {
return nil, err
}
var result Encodings
result.PNG = code.PNG()
result.Terminal = terminal(code)
result.ASCII = ascii(code)
return &result, nil
} | go | func Encode(data []byte) (*Encodings, error) {
code, err := qr.Encode(string(data), qr.L)
if err != nil {
return nil, err
}
var result Encodings
result.PNG = code.PNG()
result.Terminal = terminal(code)
result.ASCII = ascii(code)
return &result, nil
} | [
"func",
"Encode",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"Encodings",
",",
"error",
")",
"{",
"code",
",",
"err",
":=",
"qr",
".",
"Encode",
"(",
"string",
"(",
"data",
")",
",",
"qr",
".",
"L",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{"... | // Encode makes a QR code out of data and encodes it into three
// different representations. | [
"Encode",
"makes",
"a",
"QR",
"code",
"out",
"of",
"data",
"and",
"encodes",
"it",
"into",
"three",
"different",
"representations",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/qrcode/qrcode.go#L24-L36 |
161,031 | keybase/client | go/kbfs/libkbfs/block_retrieval_worker.go | run | func (brw *blockRetrievalWorker) run() {
defer close(brw.doneCh)
for {
err := brw.HandleRequest()
// Only io.EOF is relevant to the loop; other errors are handled in
// FinalizeRequest
if err == io.EOF {
return
}
}
} | go | func (brw *blockRetrievalWorker) run() {
defer close(brw.doneCh)
for {
err := brw.HandleRequest()
// Only io.EOF is relevant to the loop; other errors are handled in
// FinalizeRequest
if err == io.EOF {
return
}
}
} | [
"func",
"(",
"brw",
"*",
"blockRetrievalWorker",
")",
"run",
"(",
")",
"{",
"defer",
"close",
"(",
"brw",
".",
"doneCh",
")",
"\n",
"for",
"{",
"err",
":=",
"brw",
".",
"HandleRequest",
"(",
")",
"\n",
"// Only io.EOF is relevant to the loop; other errors are ... | // run runs the worker loop until Shutdown is called | [
"run",
"runs",
"the",
"worker",
"loop",
"until",
"Shutdown",
"is",
"called"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_retrieval_worker.go#L24-L34 |
161,032 | keybase/client | go/kbfs/libkbfs/block_retrieval_worker.go | newBlockRetrievalWorker | func newBlockRetrievalWorker(bg blockGetter, q *blockRetrievalQueue,
workCh channels.Channel) *blockRetrievalWorker {
brw := &blockRetrievalWorker{
blockGetter: bg,
stopCh: make(chan struct{}),
doneCh: make(chan struct{}),
queue: q,
workCh: workCh,
}
go brw.run()
return brw
} | go | func newBlockRetrievalWorker(bg blockGetter, q *blockRetrievalQueue,
workCh channels.Channel) *blockRetrievalWorker {
brw := &blockRetrievalWorker{
blockGetter: bg,
stopCh: make(chan struct{}),
doneCh: make(chan struct{}),
queue: q,
workCh: workCh,
}
go brw.run()
return brw
} | [
"func",
"newBlockRetrievalWorker",
"(",
"bg",
"blockGetter",
",",
"q",
"*",
"blockRetrievalQueue",
",",
"workCh",
"channels",
".",
"Channel",
")",
"*",
"blockRetrievalWorker",
"{",
"brw",
":=",
"&",
"blockRetrievalWorker",
"{",
"blockGetter",
":",
"bg",
",",
"st... | // newBlockRetrievalWorker returns a blockRetrievalWorker for a given
// blockRetrievalQueue, using the passed in blockGetter to obtain blocks for
// requests. | [
"newBlockRetrievalWorker",
"returns",
"a",
"blockRetrievalWorker",
"for",
"a",
"given",
"blockRetrievalQueue",
"using",
"the",
"passed",
"in",
"blockGetter",
"to",
"obtain",
"blocks",
"for",
"requests",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_retrieval_worker.go#L39-L50 |
161,033 | keybase/client | go/kbfs/libkbfs/block_retrieval_worker.go | HandleRequest | func (brw *blockRetrievalWorker) HandleRequest() (err error) {
var retrieval *blockRetrieval
select {
case <-brw.workCh.Out():
retrieval = brw.queue.popIfNotEmpty()
if retrieval == nil {
return nil
}
case <-brw.stopCh:
return io.EOF
}
var block data.Block
var cacheType DiskBlockCacheType
defer func() {
brw.queue.FinalizeRequest(retrieval, block, cacheType, err)
}()
// Handle canceled contexts.
select {
case <-retrieval.ctx.Done():
return retrieval.ctx.Err()
default:
}
var action BlockRequestAction
func() {
retrieval.reqMtx.RLock()
defer retrieval.reqMtx.RUnlock()
block = retrieval.requests[0].block.NewEmpty()
action = retrieval.action
}()
// If we running with a "stop-if-full" action, before we fetch the
// block, make sure the disk cache has room for it.
if action.StopIfFull() {
dbc := brw.queue.config.DiskBlockCache()
if dbc != nil {
hasRoom, err := dbc.DoesCacheHaveSpace(
retrieval.ctx, action.CacheType())
if err != 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.WithoutDelayedCacheCheckAction())
if err == nil {
return nil
}
}
return brw.getBlock(
retrieval.ctx, retrieval.kmd, retrieval.blockPtr, block, cacheType)
} | go | func (brw *blockRetrievalWorker) HandleRequest() (err error) {
var retrieval *blockRetrieval
select {
case <-brw.workCh.Out():
retrieval = brw.queue.popIfNotEmpty()
if retrieval == nil {
return nil
}
case <-brw.stopCh:
return io.EOF
}
var block data.Block
var cacheType DiskBlockCacheType
defer func() {
brw.queue.FinalizeRequest(retrieval, block, cacheType, err)
}()
// Handle canceled contexts.
select {
case <-retrieval.ctx.Done():
return retrieval.ctx.Err()
default:
}
var action BlockRequestAction
func() {
retrieval.reqMtx.RLock()
defer retrieval.reqMtx.RUnlock()
block = retrieval.requests[0].block.NewEmpty()
action = retrieval.action
}()
// If we running with a "stop-if-full" action, before we fetch the
// block, make sure the disk cache has room for it.
if action.StopIfFull() {
dbc := brw.queue.config.DiskBlockCache()
if dbc != nil {
hasRoom, err := dbc.DoesCacheHaveSpace(
retrieval.ctx, action.CacheType())
if err != 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.WithoutDelayedCacheCheckAction())
if err == nil {
return nil
}
}
return brw.getBlock(
retrieval.ctx, retrieval.kmd, retrieval.blockPtr, block, cacheType)
} | [
"func",
"(",
"brw",
"*",
"blockRetrievalWorker",
")",
"HandleRequest",
"(",
")",
"(",
"err",
"error",
")",
"{",
"var",
"retrieval",
"*",
"blockRetrieval",
"\n",
"select",
"{",
"case",
"<-",
"brw",
".",
"workCh",
".",
"Out",
"(",
")",
":",
"retrieval",
... | // HandleRequest is the main work method for the worker. It obtains a
// blockRetrieval from the queue, retrieves the block using
// blockGetter.getBlock, and responds to the subscribed requestors with the
// results. | [
"HandleRequest",
"is",
"the",
"main",
"work",
"method",
"for",
"the",
"worker",
".",
"It",
"obtains",
"a",
"blockRetrieval",
"from",
"the",
"queue",
"retrieves",
"the",
"block",
"using",
"blockGetter",
".",
"getBlock",
"and",
"responds",
"to",
"the",
"subscrib... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_retrieval_worker.go#L56-L117 |
161,034 | keybase/client | go/kbfs/libkbfs/block_retrieval_worker.go | Shutdown | func (brw *blockRetrievalWorker) Shutdown() <-chan struct{} {
select {
case <-brw.stopCh:
default:
close(brw.stopCh)
}
return brw.doneCh
} | go | func (brw *blockRetrievalWorker) Shutdown() <-chan struct{} {
select {
case <-brw.stopCh:
default:
close(brw.stopCh)
}
return brw.doneCh
} | [
"func",
"(",
"brw",
"*",
"blockRetrievalWorker",
")",
"Shutdown",
"(",
")",
"<-",
"chan",
"struct",
"{",
"}",
"{",
"select",
"{",
"case",
"<-",
"brw",
".",
"stopCh",
":",
"default",
":",
"close",
"(",
"brw",
".",
"stopCh",
")",
"\n",
"}",
"\n",
"re... | // Shutdown shuts down the blockRetrievalWorker once its current work is done. | [
"Shutdown",
"shuts",
"down",
"the",
"blockRetrievalWorker",
"once",
"its",
"current",
"work",
"is",
"done",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_retrieval_worker.go#L120-L127 |
161,035 | keybase/client | go/kbfs/libpages/stathat.go | NewStathatReporter | func NewStathatReporter(logger *zap.Logger, prefix string, ezKey string,
enableActivityBasedStats *ActivityStatsEnabler) StatsReporter {
if len(ezKey) == 0 {
return &stathatReporter{}
}
enabler := enableActivityBasedStats
if enabler == nil {
enabler = &ActivityStatsEnabler{
Storer: nullActivityStatsStorer{},
Durations: nil,
}
}
prefix = strings.TrimSpace(prefix) + " "
reporter := &stathatReporter{
logger: logger,
ezKey: ezKey,
reporter: stathat.NewBatchReporter(
stathat.DefaultReporter, stathatReportInterval),
statNameRequests: prefix + "requests",
statNameAuthenticated: prefix + "authenticated",
statNameCloningShown: prefix + "cloningShown",
statNameInvalidConfig: prefix + "invalidConfig",
statPrefixProto: prefix + "proto:",
statPrefixStatus: prefix + "status:",
statPrefixTlfType: prefix + "tlfType:",
statPrefixRootType: prefix + "rootType:",
activityStats: *enabler,
statPrefixActiveHosts: prefix + "activeHosts:",
statPrefixActiveTlfs: prefix + "activeTlfs:",
}
go reporter.activityStatsReportLoop()
return reporter
} | go | func NewStathatReporter(logger *zap.Logger, prefix string, ezKey string,
enableActivityBasedStats *ActivityStatsEnabler) StatsReporter {
if len(ezKey) == 0 {
return &stathatReporter{}
}
enabler := enableActivityBasedStats
if enabler == nil {
enabler = &ActivityStatsEnabler{
Storer: nullActivityStatsStorer{},
Durations: nil,
}
}
prefix = strings.TrimSpace(prefix) + " "
reporter := &stathatReporter{
logger: logger,
ezKey: ezKey,
reporter: stathat.NewBatchReporter(
stathat.DefaultReporter, stathatReportInterval),
statNameRequests: prefix + "requests",
statNameAuthenticated: prefix + "authenticated",
statNameCloningShown: prefix + "cloningShown",
statNameInvalidConfig: prefix + "invalidConfig",
statPrefixProto: prefix + "proto:",
statPrefixStatus: prefix + "status:",
statPrefixTlfType: prefix + "tlfType:",
statPrefixRootType: prefix + "rootType:",
activityStats: *enabler,
statPrefixActiveHosts: prefix + "activeHosts:",
statPrefixActiveTlfs: prefix + "activeTlfs:",
}
go reporter.activityStatsReportLoop()
return reporter
} | [
"func",
"NewStathatReporter",
"(",
"logger",
"*",
"zap",
".",
"Logger",
",",
"prefix",
"string",
",",
"ezKey",
"string",
",",
"enableActivityBasedStats",
"*",
"ActivityStatsEnabler",
")",
"StatsReporter",
"{",
"if",
"len",
"(",
"ezKey",
")",
"==",
"0",
"{",
... | // NewStathatReporter create a new StatsReporter that reports stats to stathat.
// If enableActivityBasedStats, if set to non-nil, causes the reporter to
// generate activity-based stats. Caller should not modify
// enableActivityBasedStats passed into this function. | [
"NewStathatReporter",
"create",
"a",
"new",
"StatsReporter",
"that",
"reports",
"stats",
"to",
"stathat",
".",
"If",
"enableActivityBasedStats",
"if",
"set",
"to",
"non",
"-",
"nil",
"causes",
"the",
"reporter",
"to",
"generate",
"activity",
"-",
"based",
"stats... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libpages/stathat.go#L81-L117 |
161,036 | keybase/client | go/kbfs/libpages/stathat.go | ReportServedRequest | func (s *stathatReporter) ReportServedRequest(sri *ServedRequestInfo) {
s.postCountOneOrLog(s.statNameRequests)
s.postCountOneOrLog(s.statPrefixProto + sri.Proto)
s.postCountOneOrLog(s.statPrefixStatus + strconv.Itoa(sri.HTTPStatus))
if sri.Authenticated {
s.postCountOneOrLog(s.statNameAuthenticated)
}
if sri.CloningShown {
s.postCountOneOrLog(s.statNameCloningShown)
}
if sri.InvalidConfig {
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)
} | go | func (s *stathatReporter) ReportServedRequest(sri *ServedRequestInfo) {
s.postCountOneOrLog(s.statNameRequests)
s.postCountOneOrLog(s.statPrefixProto + sri.Proto)
s.postCountOneOrLog(s.statPrefixStatus + strconv.Itoa(sri.HTTPStatus))
if sri.Authenticated {
s.postCountOneOrLog(s.statNameAuthenticated)
}
if sri.CloningShown {
s.postCountOneOrLog(s.statNameCloningShown)
}
if sri.InvalidConfig {
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)
} | [
"func",
"(",
"s",
"*",
"stathatReporter",
")",
"ReportServedRequest",
"(",
"sri",
"*",
"ServedRequestInfo",
")",
"{",
"s",
".",
"postCountOneOrLog",
"(",
"s",
".",
"statNameRequests",
")",
"\n",
"s",
".",
"postCountOneOrLog",
"(",
"s",
".",
"statPrefixProto",
... | // ReportServedRequest implementes the StatsReporter interface. | [
"ReportServedRequest",
"implementes",
"the",
"StatsReporter",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libpages/stathat.go#L126-L143 |
161,037 | keybase/client | go/kbfs/cache/size_utils.go | StaticSizeOfMapWithSize | func StaticSizeOfMapWithSize(
keyStaticSize, valueStaticSize int, count int) (bytes int) {
keySize := mapKeyOrValueSizeWithIndirectPointerOverhead(keyStaticSize)
valueSize := mapKeyOrValueSizeWithIndirectPointerOverhead(valueStaticSize)
// See the comment of `B` field of `hmap` struct above.
B := math.Ceil(math.Log2(float64(count) / mapLoadFactor))
numBuckets := int(math.Exp2(B))
return hmapStructSize +
bucketSizeWithoutIndirectPointerOverhead*numBuckets +
(keySize+valueSize)*count
} | go | func StaticSizeOfMapWithSize(
keyStaticSize, valueStaticSize int, count int) (bytes int) {
keySize := mapKeyOrValueSizeWithIndirectPointerOverhead(keyStaticSize)
valueSize := mapKeyOrValueSizeWithIndirectPointerOverhead(valueStaticSize)
// See the comment of `B` field of `hmap` struct above.
B := math.Ceil(math.Log2(float64(count) / mapLoadFactor))
numBuckets := int(math.Exp2(B))
return hmapStructSize +
bucketSizeWithoutIndirectPointerOverhead*numBuckets +
(keySize+valueSize)*count
} | [
"func",
"StaticSizeOfMapWithSize",
"(",
"keyStaticSize",
",",
"valueStaticSize",
"int",
",",
"count",
"int",
")",
"(",
"bytes",
"int",
")",
"{",
"keySize",
":=",
"mapKeyOrValueSizeWithIndirectPointerOverhead",
"(",
"keyStaticSize",
")",
"\n",
"valueSize",
":=",
"map... | // StaticSizeOfMapWithSize is a slightly more efficient version of
// StaticSizeOfMap for when the caller knows the static size of key and value
// without having to use `reflect`. | [
"StaticSizeOfMapWithSize",
"is",
"a",
"slightly",
"more",
"efficient",
"version",
"of",
"StaticSizeOfMap",
"for",
"when",
"the",
"caller",
"knows",
"the",
"static",
"size",
"of",
"key",
"and",
"value",
"without",
"having",
"to",
"use",
"reflect",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/cache/size_utils.go#L109-L121 |
161,038 | keybase/client | go/kbfs/dokan/winacl/ace.go | AddAllowAccess | func (acl *ACL) AddAllowAccess(accessMask uint32, sid *SID) {
acl.initIfEmpty()
ssize := sidSize(sid)
var bs [8]byte
// ACLs are little endian...
binary.LittleEndian.PutUint16(bs[2:], uint16(8+align4up(uint32(sidSize(sid)))))
binary.LittleEndian.PutUint32(bs[4:], accessMask)
acl.raw = append(acl.raw, bs[:]...)
acl.raw = append(acl.raw, bufToSlice(unsafe.Pointer(sid), ssize)...)
for len(acl.raw)&3 != 0 {
acl.raw = append(acl.raw, 0)
}
acl.aceCount++
} | go | func (acl *ACL) AddAllowAccess(accessMask uint32, sid *SID) {
acl.initIfEmpty()
ssize := sidSize(sid)
var bs [8]byte
// ACLs are little endian...
binary.LittleEndian.PutUint16(bs[2:], uint16(8+align4up(uint32(sidSize(sid)))))
binary.LittleEndian.PutUint32(bs[4:], accessMask)
acl.raw = append(acl.raw, bs[:]...)
acl.raw = append(acl.raw, bufToSlice(unsafe.Pointer(sid), ssize)...)
for len(acl.raw)&3 != 0 {
acl.raw = append(acl.raw, 0)
}
acl.aceCount++
} | [
"func",
"(",
"acl",
"*",
"ACL",
")",
"AddAllowAccess",
"(",
"accessMask",
"uint32",
",",
"sid",
"*",
"SID",
")",
"{",
"acl",
".",
"initIfEmpty",
"(",
")",
"\n",
"ssize",
":=",
"sidSize",
"(",
"sid",
")",
"\n",
"var",
"bs",
"[",
"8",
"]",
"byte",
... | // AddAllowAccess add a new ALLOW_ACCESS ACE to the ACL. | [
"AddAllowAccess",
"add",
"a",
"new",
"ALLOW_ACCESS",
"ACE",
"to",
"the",
"ACL",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/dokan/winacl/ace.go#L40-L53 |
161,039 | keybase/client | go/externals/init.go | NewParamProofStoreAndInstall | func NewParamProofStoreAndInstall(g *libkb.GlobalContext) libkb.MerkleStore {
supportedVersion := keybase1.MerkleStoreSupportedVersion(SupportedVersion)
tag := "paramproofs"
endpoint := "merkle/proof_params"
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
} | go | func NewParamProofStoreAndInstall(g *libkb.GlobalContext) libkb.MerkleStore {
supportedVersion := keybase1.MerkleStoreSupportedVersion(SupportedVersion)
tag := "paramproofs"
endpoint := "merkle/proof_params"
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
} | [
"func",
"NewParamProofStoreAndInstall",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"libkb",
".",
"MerkleStore",
"{",
"supportedVersion",
":=",
"keybase1",
".",
"MerkleStoreSupportedVersion",
"(",
"SupportedVersion",
")",
"\n",
"tag",
":=",
"\"",
"\"",
"\n"... | // NewParamProofStore creates a new source and installs it into G. | [
"NewParamProofStore",
"creates",
"a",
"new",
"source",
"and",
"installs",
"it",
"into",
"G",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/externals/init.go#L11-L22 |
161,040 | keybase/client | go/badges/badger.go | Send | func (b *Badger) Send(ctx context.Context) error {
state, err := b.badgeState.Export()
if err != nil {
return err
}
b.log(ctx, state)
b.notifyCh <- state
return nil
} | go | func (b *Badger) Send(ctx context.Context) error {
state, err := b.badgeState.Export()
if err != nil {
return err
}
b.log(ctx, state)
b.notifyCh <- state
return nil
} | [
"func",
"(",
"b",
"*",
"Badger",
")",
"Send",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"state",
",",
"err",
":=",
"b",
".",
"badgeState",
".",
"Export",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
... | // Send the badgestate to electron | [
"Send",
"the",
"badgestate",
"to",
"electron"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/badges/badger.go#L132-L140 |
161,041 | keybase/client | go/badges/badger.go | log | func (b *Badger) log(ctx context.Context, state1 keybase1.BadgeState) {
var state2 keybase1.BadgeState
state2 = state1
state2.Conversations = nil
for _, c1 := range state1.Conversations {
if c1.UnreadMessages == 0 {
continue
}
c2id := c1.ConvID
if len(c1.ConvID) >= chat1.DbShortFormLen {
// This is the db short form for logging brevity only.
// Don't let this leave this method.
c2id = chat1.ConversationID([]byte(c1.ConvID)).DbShortForm()
}
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)
} | go | func (b *Badger) log(ctx context.Context, state1 keybase1.BadgeState) {
var state2 keybase1.BadgeState
state2 = state1
state2.Conversations = nil
for _, c1 := range state1.Conversations {
if c1.UnreadMessages == 0 {
continue
}
c2id := c1.ConvID
if len(c1.ConvID) >= chat1.DbShortFormLen {
// This is the db short form for logging brevity only.
// Don't let this leave this method.
c2id = chat1.ConversationID([]byte(c1.ConvID)).DbShortForm()
}
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)
} | [
"func",
"(",
"b",
"*",
"Badger",
")",
"log",
"(",
"ctx",
"context",
".",
"Context",
",",
"state1",
"keybase1",
".",
"BadgeState",
")",
"{",
"var",
"state2",
"keybase1",
".",
"BadgeState",
"\n",
"state2",
"=",
"state1",
"\n",
"state2",
".",
"Conversations... | // Log a copy of the badgestate with some zeros stripped off for brevity. | [
"Log",
"a",
"copy",
"of",
"the",
"badgestate",
"with",
"some",
"zeros",
"stripped",
"off",
"for",
"brevity",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/badges/badger.go#L147-L170 |
161,042 | keybase/client | go/pinentry/pinentry_windows.go | canExec | func canExec(s string) error {
if strings.IndexAny(s, `:\/`) == -1 {
s += string(filepath.Separator)
}
_, err := exec.LookPath(s)
return err
} | go | func canExec(s string) error {
if strings.IndexAny(s, `:\/`) == -1 {
s += string(filepath.Separator)
}
_, err := exec.LookPath(s)
return err
} | [
"func",
"canExec",
"(",
"s",
"string",
")",
"error",
"{",
"if",
"strings",
".",
"IndexAny",
"(",
"s",
",",
"`:\\/`",
")",
"==",
"-",
"1",
"{",
"s",
"+=",
"string",
"(",
"filepath",
".",
"Separator",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
... | // LookPath searches for an executable binary named file
// in the directories named by the PATH environment variable.
// If file contains a slash, it is tried directly and the PATH is not consulted. | [
"LookPath",
"searches",
"for",
"an",
"executable",
"binary",
"named",
"file",
"in",
"the",
"directories",
"named",
"by",
"the",
"PATH",
"environment",
"variable",
".",
"If",
"file",
"contains",
"a",
"slash",
"it",
"is",
"tried",
"directly",
"and",
"the",
"PA... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/pinentry/pinentry_windows.go#L28-L34 |
161,043 | keybase/client | go/kbfs/libfs/user_edit_history.go | GetEncodedUserEditHistory | func GetEncodedUserEditHistory(ctx context.Context, config libkbfs.Config) (
data []byte, t time.Time, err error) {
session, err := idutil.GetCurrentSessionIfPossible(
ctx, config.KBPKI(), true)
if err != nil {
return nil, time.Time{}, err
}
edits := config.UserHistory().Get(string(session.Name))
data, err = PrettyJSON(edits)
return data, time.Time{}, err
} | go | func GetEncodedUserEditHistory(ctx context.Context, config libkbfs.Config) (
data []byte, t time.Time, err error) {
session, err := idutil.GetCurrentSessionIfPossible(
ctx, config.KBPKI(), true)
if err != nil {
return nil, time.Time{}, err
}
edits := config.UserHistory().Get(string(session.Name))
data, err = PrettyJSON(edits)
return data, time.Time{}, err
} | [
"func",
"GetEncodedUserEditHistory",
"(",
"ctx",
"context",
".",
"Context",
",",
"config",
"libkbfs",
".",
"Config",
")",
"(",
"data",
"[",
"]",
"byte",
",",
"t",
"time",
".",
"Time",
",",
"err",
"error",
")",
"{",
"session",
",",
"err",
":=",
"idutil"... | // GetEncodedUserEditHistory returns serialized JSON containing the
// file edit history for the user. | [
"GetEncodedUserEditHistory",
"returns",
"serialized",
"JSON",
"containing",
"the",
"file",
"edit",
"history",
"for",
"the",
"user",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/user_edit_history.go#L17-L28 |
161,044 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | NewMDServerRemote | func NewMDServerRemote(config Config, srvRemote rpc.Remote,
rpcLogFactory rpc.LogFactory) *MDServerRemote {
log := config.MakeLogger("")
deferLog := log.CloneWithAddedDepth(1)
mdServer := &MDServerRemote{
config: config,
observers: make(map[tlf.ID]chan<- error),
log: traceLogger{log},
deferLog: traceLogger{deferLog},
mdSrvRemote: srvRemote,
rpcLogFactory: rpcLogFactory,
rekeyTimer: time.NewTimer(nextRekeyTime()),
}
mdServer.pinger = pinger{
name: "MDServerRemote",
doPing: mdServer.pingOnce,
timeout: MdServerPingTimeout,
log: mdServer.log,
}
mdServer.authToken = kbfscrypto.NewAuthToken(config.Crypto(),
kbfsmd.ServerTokenServer, kbfsmd.ServerTokenExpireIn,
"libkbfs_mdserver_remote", VersionString(), mdServer)
constBackoff := backoff.NewConstantBackOff(RPCReconnectInterval)
mdServer.connOpts = rpc.ConnectionOpts{
WrapErrorFunc: libkb.WrapError,
TagsFunc: libkb.LogTagsFromContext,
ReconnectBackoff: func() backoff.BackOff { return constBackoff },
DialerTimeout: dialerTimeout,
InitialReconnectBackoffWindow: func() time.Duration { return mdserverReconnectBackoffWindow },
}
mdServer.initNewConnection()
// Check for rekey opportunities periodically.
rekeyCtx, rekeyCancel := context.WithCancel(context.Background())
mdServer.rekeyCancel = rekeyCancel
if config.Mode().RekeyWorkers() > 0 {
go mdServer.backgroundRekeyChecker(rekeyCtx)
}
return mdServer
} | go | func NewMDServerRemote(config Config, srvRemote rpc.Remote,
rpcLogFactory rpc.LogFactory) *MDServerRemote {
log := config.MakeLogger("")
deferLog := log.CloneWithAddedDepth(1)
mdServer := &MDServerRemote{
config: config,
observers: make(map[tlf.ID]chan<- error),
log: traceLogger{log},
deferLog: traceLogger{deferLog},
mdSrvRemote: srvRemote,
rpcLogFactory: rpcLogFactory,
rekeyTimer: time.NewTimer(nextRekeyTime()),
}
mdServer.pinger = pinger{
name: "MDServerRemote",
doPing: mdServer.pingOnce,
timeout: MdServerPingTimeout,
log: mdServer.log,
}
mdServer.authToken = kbfscrypto.NewAuthToken(config.Crypto(),
kbfsmd.ServerTokenServer, kbfsmd.ServerTokenExpireIn,
"libkbfs_mdserver_remote", VersionString(), mdServer)
constBackoff := backoff.NewConstantBackOff(RPCReconnectInterval)
mdServer.connOpts = rpc.ConnectionOpts{
WrapErrorFunc: libkb.WrapError,
TagsFunc: libkb.LogTagsFromContext,
ReconnectBackoff: func() backoff.BackOff { return constBackoff },
DialerTimeout: dialerTimeout,
InitialReconnectBackoffWindow: func() time.Duration { return mdserverReconnectBackoffWindow },
}
mdServer.initNewConnection()
// Check for rekey opportunities periodically.
rekeyCtx, rekeyCancel := context.WithCancel(context.Background())
mdServer.rekeyCancel = rekeyCancel
if config.Mode().RekeyWorkers() > 0 {
go mdServer.backgroundRekeyChecker(rekeyCtx)
}
return mdServer
} | [
"func",
"NewMDServerRemote",
"(",
"config",
"Config",
",",
"srvRemote",
"rpc",
".",
"Remote",
",",
"rpcLogFactory",
"rpc",
".",
"LogFactory",
")",
"*",
"MDServerRemote",
"{",
"log",
":=",
"config",
".",
"MakeLogger",
"(",
"\"",
"\"",
")",
"\n",
"deferLog",
... | // NewMDServerRemote returns a new instance of MDServerRemote. | [
"NewMDServerRemote",
"returns",
"a",
"new",
"instance",
"of",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L97-L139 |
161,045 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | resetAuth | func (md *MDServerRemote) resetAuth(
ctx context.Context, c keybase1.MetadataClient) (int, error) {
ctx = context.WithValue(ctx, ctxMDServerResetKey, "1")
isAuthenticated := false
defer func() {
md.setIsAuthenticated(isAuthenticated)
}()
session, err := md.config.KBPKI().GetCurrentSession(ctx)
if err != nil {
md.log.CInfof(ctx,
"Error getting current session (%+v), skipping resetAuth", err)
return MdServerDefaultPingIntervalSeconds, err
}
challenge, err := c.GetChallenge(ctx)
if err != nil {
md.log.CWarningf(ctx, "challenge request error: %v", err)
return 0, err
}
md.log.CDebugf(ctx, "received challenge")
// get a new signature
signature, err := md.authToken.Sign(ctx, session.Name, session.UID,
session.VerifyingKey, challenge)
if err != nil {
md.log.CWarningf(ctx, "error signing authentication token: %v", err)
return 0, err
}
md.log.CDebugf(ctx, "authentication token signed")
// authenticate
pingIntervalSeconds, err := c.Authenticate(ctx, signature)
if err != nil {
md.log.CWarningf(ctx, "authentication error: %v", err)
return 0, err
}
md.log.CInfof(ctx, "authentication successful; ping interval: %ds",
pingIntervalSeconds)
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)
}
md.deferLog.CDebugf(ctx,
"requested list of folders for rekey")
}()
}
// Need to ensure that any conflicting thread gets the updated value
md.isAuthenticated = true
md.authenticatedMtx.Unlock()
return pingIntervalSeconds, nil
} | go | func (md *MDServerRemote) resetAuth(
ctx context.Context, c keybase1.MetadataClient) (int, error) {
ctx = context.WithValue(ctx, ctxMDServerResetKey, "1")
isAuthenticated := false
defer func() {
md.setIsAuthenticated(isAuthenticated)
}()
session, err := md.config.KBPKI().GetCurrentSession(ctx)
if err != nil {
md.log.CInfof(ctx,
"Error getting current session (%+v), skipping resetAuth", err)
return MdServerDefaultPingIntervalSeconds, err
}
challenge, err := c.GetChallenge(ctx)
if err != nil {
md.log.CWarningf(ctx, "challenge request error: %v", err)
return 0, err
}
md.log.CDebugf(ctx, "received challenge")
// get a new signature
signature, err := md.authToken.Sign(ctx, session.Name, session.UID,
session.VerifyingKey, challenge)
if err != nil {
md.log.CWarningf(ctx, "error signing authentication token: %v", err)
return 0, err
}
md.log.CDebugf(ctx, "authentication token signed")
// authenticate
pingIntervalSeconds, err := c.Authenticate(ctx, signature)
if err != nil {
md.log.CWarningf(ctx, "authentication error: %v", err)
return 0, err
}
md.log.CInfof(ctx, "authentication successful; ping interval: %ds",
pingIntervalSeconds)
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)
}
md.deferLog.CDebugf(ctx,
"requested list of folders for rekey")
}()
}
// Need to ensure that any conflicting thread gets the updated value
md.isAuthenticated = true
md.authenticatedMtx.Unlock()
return pingIntervalSeconds, nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"resetAuth",
"(",
"ctx",
"context",
".",
"Context",
",",
"c",
"keybase1",
".",
"MetadataClient",
")",
"(",
"int",
",",
"error",
")",
"{",
"ctx",
"=",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"ctxMDSer... | // resetAuth is called to reset the authorization on an MDServer
// connection. If this function returns
// idutil.NoCurrentSessionError, the caller should treat this as a
// logged-out user. | [
"resetAuth",
"is",
"called",
"to",
"reset",
"the",
"authorization",
"on",
"an",
"MDServer",
"connection",
".",
"If",
"this",
"function",
"returns",
"idutil",
".",
"NoCurrentSessionError",
"the",
"caller",
"should",
"treat",
"this",
"as",
"a",
"logged",
"-",
"o... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L251-L310 |
161,046 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | CheckReachability | func (md *MDServerRemote) CheckReachability(ctx context.Context) {
conn, err := net.DialTimeout("tcp",
// The peeked address is the top choice in most cases.
md.mdSrvRemote.Peek(), MdServerPingTimeout)
if err != nil {
if md.getIsAuthenticated() {
md.log.CInfof(ctx, "MDServerRemote: CheckReachability(): "+
"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 {
conn.Close()
}
} | go | func (md *MDServerRemote) CheckReachability(ctx context.Context) {
conn, err := net.DialTimeout("tcp",
// The peeked address is the top choice in most cases.
md.mdSrvRemote.Peek(), MdServerPingTimeout)
if err != nil {
if md.getIsAuthenticated() {
md.log.CInfof(ctx, "MDServerRemote: CheckReachability(): "+
"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 {
conn.Close()
}
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"CheckReachability",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"conn",
",",
"err",
":=",
"net",
".",
"DialTimeout",
"(",
"\"",
"\"",
",",
"// The peeked address is the top choice in most cases.",
"md",
".",
... | // CheckReachability implements the MDServer interface. | [
"CheckReachability",
"implements",
"the",
"MDServer",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L462-L481 |
161,047 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | cancelObservers | func (md *MDServerRemote) cancelObservers() {
md.observerMu.Lock()
defer md.observerMu.Unlock()
// fire errors for any registered observers
for id, observerChan := range md.observers {
md.signalObserverLocked(observerChan, id, MDServerDisconnected{})
}
} | go | func (md *MDServerRemote) cancelObservers() {
md.observerMu.Lock()
defer md.observerMu.Unlock()
// fire errors for any registered observers
for id, observerChan := range md.observers {
md.signalObserverLocked(observerChan, id, MDServerDisconnected{})
}
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"cancelObservers",
"(",
")",
"{",
"md",
".",
"observerMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"md",
".",
"observerMu",
".",
"Unlock",
"(",
")",
"\n",
"// fire errors for any registered observers",
"for",
"id"... | // Signal errors and clear any registered observers. | [
"Signal",
"errors",
"and",
"clear",
"any",
"registered",
"observers",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L484-L491 |
161,048 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | CancelRegistration | func (md *MDServerRemote) CancelRegistration(ctx context.Context, id tlf.ID) {
md.observerMu.Lock()
defer md.observerMu.Unlock()
observerChan, ok := md.observers[id]
if !ok {
// not registered
return
}
// signal that we've seen the update
md.signalObserverLocked(
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
} | go | func (md *MDServerRemote) CancelRegistration(ctx context.Context, id tlf.ID) {
md.observerMu.Lock()
defer md.observerMu.Unlock()
observerChan, ok := md.observers[id]
if !ok {
// not registered
return
}
// signal that we've seen the update
md.signalObserverLocked(
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
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"CancelRegistration",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"tlf",
".",
"ID",
")",
"{",
"md",
".",
"observerMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"md",
".",
"observerMu",
".",
"Unlock",
... | // CancelRegistration implements the MDServer interface for MDServerRemote. | [
"CancelRegistration",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L494-L509 |
161,049 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | signalObserverLocked | func (md *MDServerRemote) signalObserverLocked(observerChan chan<- error, id tlf.ID, err error) {
if observerChan != nil {
observerChan <- err
close(observerChan)
}
delete(md.observers, id)
} | go | func (md *MDServerRemote) signalObserverLocked(observerChan chan<- error, id tlf.ID, err error) {
if observerChan != nil {
observerChan <- err
close(observerChan)
}
delete(md.observers, id)
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"signalObserverLocked",
"(",
"observerChan",
"chan",
"<-",
"error",
",",
"id",
"tlf",
".",
"ID",
",",
"err",
"error",
")",
"{",
"if",
"observerChan",
"!=",
"nil",
"{",
"observerChan",
"<-",
"err",
"\n",
"clo... | // Signal an observer. The observer lock must be held. | [
"Signal",
"an",
"observer",
".",
"The",
"observer",
"lock",
"must",
"be",
"held",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L512-L518 |
161,050 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | get | func (md *MDServerRemote) get(ctx context.Context, arg keybase1.GetMetadataArg) (
tlfID tlf.ID, rmdses []*RootMetadataSigned, err error) {
// request
response, err := md.getClient().GetMetadata(ctx, arg)
if err != nil {
return tlf.ID{}, nil, err
}
// response
tlfID, err = tlf.ParseID(response.FolderID)
if err != nil {
return tlf.ID{}, nil, err
}
// deserialize blocks
rmdses = make([]*RootMetadataSigned, len(response.MdBlocks))
diskMDCache := md.config.DiskMDCache()
for i, block := range response.MdBlocks {
ver, max := kbfsmd.MetadataVer(block.Version), md.config.MetadataVersion()
timestamp := keybase1.FromTime(block.Timestamp)
rmds, err := DecodeRootMetadataSigned(
md.config.Codec(), tlfID, ver, max, 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 {
return tlf.ID{}, nil, err
}
}
}
return tlfID, rmdses, nil
} | go | func (md *MDServerRemote) get(ctx context.Context, arg keybase1.GetMetadataArg) (
tlfID tlf.ID, rmdses []*RootMetadataSigned, err error) {
// request
response, err := md.getClient().GetMetadata(ctx, arg)
if err != nil {
return tlf.ID{}, nil, err
}
// response
tlfID, err = tlf.ParseID(response.FolderID)
if err != nil {
return tlf.ID{}, nil, err
}
// deserialize blocks
rmdses = make([]*RootMetadataSigned, len(response.MdBlocks))
diskMDCache := md.config.DiskMDCache()
for i, block := range response.MdBlocks {
ver, max := kbfsmd.MetadataVer(block.Version), md.config.MetadataVersion()
timestamp := keybase1.FromTime(block.Timestamp)
rmds, err := DecodeRootMetadataSigned(
md.config.Codec(), tlfID, ver, max, 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 {
return tlf.ID{}, nil, err
}
}
}
return tlfID, rmdses, nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"get",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"keybase1",
".",
"GetMetadataArg",
")",
"(",
"tlfID",
"tlf",
".",
"ID",
",",
"rmdses",
"[",
"]",
"*",
"RootMetadataSigned",
",",
"err",
"error",
")... | // Helper used to retrieve metadata blocks from the MD server. | [
"Helper",
"used",
"to",
"retrieve",
"metadata",
"blocks",
"from",
"the",
"MD",
"server",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L536-L573 |
161,051 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | GetForHandle | func (md *MDServerRemote) GetForHandle(ctx context.Context,
handle tlf.Handle, mStatus kbfsmd.MergeStatus, lockBeforeGet *keybase1.LockID) (
tlfID tlf.ID, rmds *RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
// TODO: Ideally, *tlf.Handle would have a nicer String() function.
md.log.LazyTrace(ctx, "MDServer: GetForHandle %+v %s", handle, mStatus)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: GetForHandle %+v %s done (err=%v)", handle, mStatus, err)
}()
encodedHandle, err := md.config.Codec().Encode(handle)
if err != nil {
return tlf.ID{}, nil, err
}
// kbfsmd.BranchID needs to be present when Unmerged is true;
// 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, arg)
if err != nil {
return tlf.ID{}, nil, err
}
if len(rmdses) == 0 {
return id, nil, nil
}
// TODO: Error if server returns more than one rmds.
return id, rmdses[0], nil
} | go | func (md *MDServerRemote) GetForHandle(ctx context.Context,
handle tlf.Handle, mStatus kbfsmd.MergeStatus, lockBeforeGet *keybase1.LockID) (
tlfID tlf.ID, rmds *RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
// TODO: Ideally, *tlf.Handle would have a nicer String() function.
md.log.LazyTrace(ctx, "MDServer: GetForHandle %+v %s", handle, mStatus)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: GetForHandle %+v %s done (err=%v)", handle, mStatus, err)
}()
encodedHandle, err := md.config.Codec().Encode(handle)
if err != nil {
return tlf.ID{}, nil, err
}
// kbfsmd.BranchID needs to be present when Unmerged is true;
// 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, arg)
if err != nil {
return tlf.ID{}, nil, err
}
if len(rmdses) == 0 {
return id, nil, nil
}
// TODO: Error if server returns more than one rmds.
return id, rmdses[0], nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"GetForHandle",
"(",
"ctx",
"context",
".",
"Context",
",",
"handle",
"tlf",
".",
"Handle",
",",
"mStatus",
"kbfsmd",
".",
"MergeStatus",
",",
"lockBeforeGet",
"*",
"keybase1",
".",
"LockID",
")",
"(",
"tlfID"... | // GetForHandle implements the MDServer interface for MDServerRemote. | [
"GetForHandle",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L576-L609 |
161,052 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | GetForTLF | func (md *MDServerRemote) GetForTLF(ctx context.Context, id tlf.ID,
bid kbfsmd.BranchID, mStatus kbfsmd.MergeStatus, lockBeforeGet *keybase1.LockID) (rmds *RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: GetForTLF %s %s %s", id, bid, mStatus)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: GetForTLF %s %s %s done (err=%v)", id, bid, mStatus, err)
}()
var cachedRmds *RootMetadataSigned
getCtx := ctx
if mStatus == kbfsmd.Merged && lockBeforeGet == nil {
cachedRmds, err = md.getLatestFromCache(ctx, id)
if err == nil && cachedRmds != nil {
md.log.CDebugf(ctx,
"Read revision %d for TLF %s from the disk cache",
cachedRmds.MD.RevisionNumber(), id)
var cancel context.CancelFunc
getCtx, cancel = context.WithTimeout(
ctx, mdServerTimeoutWhenMDCached)
defer cancel()
}
}
arg := keybase1.GetMetadataArg{
FolderID: id.String(),
BranchID: bid.String(),
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 nil, err
default:
return nil, err
}
if len(rmdses) == 0 {
return nil, nil
}
if cachedRmds != nil {
md.log.CDebugf(ctx, "Read revision %d for TLF %s from the server",
rmdses[0].MD.RevisionNumber(), id)
}
// TODO: Error if server returns more than one rmds.
return rmdses[0], nil
} | go | func (md *MDServerRemote) GetForTLF(ctx context.Context, id tlf.ID,
bid kbfsmd.BranchID, mStatus kbfsmd.MergeStatus, lockBeforeGet *keybase1.LockID) (rmds *RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: GetForTLF %s %s %s", id, bid, mStatus)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: GetForTLF %s %s %s done (err=%v)", id, bid, mStatus, err)
}()
var cachedRmds *RootMetadataSigned
getCtx := ctx
if mStatus == kbfsmd.Merged && lockBeforeGet == nil {
cachedRmds, err = md.getLatestFromCache(ctx, id)
if err == nil && cachedRmds != nil {
md.log.CDebugf(ctx,
"Read revision %d for TLF %s from the disk cache",
cachedRmds.MD.RevisionNumber(), id)
var cancel context.CancelFunc
getCtx, cancel = context.WithTimeout(
ctx, mdServerTimeoutWhenMDCached)
defer cancel()
}
}
arg := keybase1.GetMetadataArg{
FolderID: id.String(),
BranchID: bid.String(),
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 nil, err
default:
return nil, err
}
if len(rmdses) == 0 {
return nil, nil
}
if cachedRmds != nil {
md.log.CDebugf(ctx, "Read revision %d for TLF %s from the server",
rmdses[0].MD.RevisionNumber(), id)
}
// TODO: Error if server returns more than one rmds.
return rmdses[0], nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"GetForTLF",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"tlf",
".",
"ID",
",",
"bid",
"kbfsmd",
".",
"BranchID",
",",
"mStatus",
"kbfsmd",
".",
"MergeStatus",
",",
"lockBeforeGet",
"*",
"keybase1",
".... | // GetForTLF implements the MDServer interface for MDServerRemote. | [
"GetForTLF",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L612-L666 |
161,053 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | GetForTLFByTime | func (md *MDServerRemote) GetForTLFByTime(
ctx context.Context, id tlf.ID, serverTime time.Time) (
rmds *RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: GetForTLFByTime %s %s", id, serverTime)
defer func() {
md.deferLog.LazyTrace(
ctx, "MDServer: GetForTLFByTime %s %s done (err=%v)",
id, serverTime, err)
}()
arg := keybase1.GetMetadataByTimestampArg{
FolderID: id.String(),
ServerTime: keybase1.ToTime(serverTime),
}
block, err := md.getClient().GetMetadataByTimestamp(ctx, arg)
if err != nil {
return nil, err
} else if len(block.Block) == 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
}
return rmds, nil
} | go | func (md *MDServerRemote) GetForTLFByTime(
ctx context.Context, id tlf.ID, serverTime time.Time) (
rmds *RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: GetForTLFByTime %s %s", id, serverTime)
defer func() {
md.deferLog.LazyTrace(
ctx, "MDServer: GetForTLFByTime %s %s done (err=%v)",
id, serverTime, err)
}()
arg := keybase1.GetMetadataByTimestampArg{
FolderID: id.String(),
ServerTime: keybase1.ToTime(serverTime),
}
block, err := md.getClient().GetMetadataByTimestamp(ctx, arg)
if err != nil {
return nil, err
} else if len(block.Block) == 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
}
return rmds, nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"GetForTLFByTime",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"tlf",
".",
"ID",
",",
"serverTime",
"time",
".",
"Time",
")",
"(",
"rmds",
"*",
"RootMetadataSigned",
",",
"err",
"error",
")",
"{",
"c... | // GetForTLFByTime implements the MDServer interface for MDServerRemote. | [
"GetForTLFByTime",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L669-L700 |
161,054 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | GetRange | func (md *MDServerRemote) GetRange(ctx context.Context, id tlf.ID,
bid kbfsmd.BranchID, mStatus kbfsmd.MergeStatus,
start, stop kbfsmd.Revision, lockBeforeGet *keybase1.LockID) (
rmdses []*RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: GetRange %s %s %s %d-%d", id, bid, mStatus, start, stop)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: GetRange %s %s %s %d-%d done (err=%v)", id, bid, mStatus, start, stop, err)
}()
arg := keybase1.GetMetadataArg{
FolderID: 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
} | go | func (md *MDServerRemote) GetRange(ctx context.Context, id tlf.ID,
bid kbfsmd.BranchID, mStatus kbfsmd.MergeStatus,
start, stop kbfsmd.Revision, lockBeforeGet *keybase1.LockID) (
rmdses []*RootMetadataSigned, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: GetRange %s %s %s %d-%d", id, bid, mStatus, start, stop)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: GetRange %s %s %s %d-%d done (err=%v)", id, bid, mStatus, start, stop, err)
}()
arg := keybase1.GetMetadataArg{
FolderID: 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
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"GetRange",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"tlf",
".",
"ID",
",",
"bid",
"kbfsmd",
".",
"BranchID",
",",
"mStatus",
"kbfsmd",
".",
"MergeStatus",
",",
"start",
",",
"stop",
"kbfsmd",
"."... | // GetRange implements the MDServer interface for MDServerRemote. | [
"GetRange",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L703-L724 |
161,055 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | Lock | func (md *MDServerRemote) Lock(ctx context.Context,
tlfID tlf.ID, lockID keybase1.LockID) error {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: Lock %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,
})
} | go | func (md *MDServerRemote) Lock(ctx context.Context,
tlfID tlf.ID, lockID keybase1.LockID) error {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: Lock %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,
})
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"Lock",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"lockID",
"keybase1",
".",
"LockID",
")",
"error",
"{",
"ctx",
"=",
"rpc",
".",
"WithFireNow",
"(",
"ctx",
")",
"\n",
... | // Lock implements the MDServer interface for MDServerRemote. | [
"Lock",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L818-L829 |
161,056 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | PruneBranch | func (md *MDServerRemote) PruneBranch(
ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) (err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: PruneBranch %s %s", id, bid)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: PruneBranch %s %s (err=%v)", id, bid, err)
}()
arg := keybase1.PruneBranchArg{
FolderID: id.String(),
BranchID: bid.String(),
LogTags: nil,
}
return md.getClient().PruneBranch(ctx, arg)
} | go | func (md *MDServerRemote) PruneBranch(
ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) (err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "MDServer: PruneBranch %s %s", id, bid)
defer func() {
md.deferLog.LazyTrace(ctx, "MDServer: PruneBranch %s %s (err=%v)", id, bid, err)
}()
arg := keybase1.PruneBranchArg{
FolderID: id.String(),
BranchID: bid.String(),
LogTags: nil,
}
return md.getClient().PruneBranch(ctx, arg)
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"PruneBranch",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"tlf",
".",
"ID",
",",
"bid",
"kbfsmd",
".",
"BranchID",
")",
"(",
"err",
"error",
")",
"{",
"ctx",
"=",
"rpc",
".",
"WithFireNow",
"(",
... | // PruneBranch implements the MDServer interface for MDServerRemote. | [
"PruneBranch",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L860-L874 |
161,057 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | MetadataUpdate | func (md *MDServerRemote) MetadataUpdate(_ context.Context, arg keybase1.MetadataUpdateArg) error {
id, err := tlf.ParseID(arg.FolderID)
if err != nil {
return err
}
md.observerMu.Lock()
defer md.observerMu.Unlock()
observerChan, ok := md.observers[id]
if !ok {
// not registered
return nil
}
// signal that we've seen the update
md.signalObserverLocked(observerChan, id, nil)
return nil
} | go | func (md *MDServerRemote) MetadataUpdate(_ context.Context, arg keybase1.MetadataUpdateArg) error {
id, err := tlf.ParseID(arg.FolderID)
if err != nil {
return err
}
md.observerMu.Lock()
defer md.observerMu.Unlock()
observerChan, ok := md.observers[id]
if !ok {
// not registered
return nil
}
// signal that we've seen the update
md.signalObserverLocked(observerChan, id, nil)
return nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"MetadataUpdate",
"(",
"_",
"context",
".",
"Context",
",",
"arg",
"keybase1",
".",
"MetadataUpdateArg",
")",
"error",
"{",
"id",
",",
"err",
":=",
"tlf",
".",
"ParseID",
"(",
"arg",
".",
"FolderID",
")",
... | // MetadataUpdate implements the MetadataUpdateProtocol interface. | [
"MetadataUpdate",
"implements",
"the",
"MetadataUpdateProtocol",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L877-L894 |
161,058 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | FoldersNeedRekey | func (md *MDServerRemote) FoldersNeedRekey(ctx context.Context,
requests []keybase1.RekeyRequest) error {
if md.squelchRekey {
md.log.CDebugf(ctx, "MDServerRemote: rekey updates squelched for testing")
return nil
}
for _, req := range requests {
id, err := tlf.ParseID(req.FolderID)
if err != nil {
return err
}
md.log.CDebugf(ctx, "MDServerRemote: folder needs rekey: %s", id.String())
// 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
} | go | func (md *MDServerRemote) FoldersNeedRekey(ctx context.Context,
requests []keybase1.RekeyRequest) error {
if md.squelchRekey {
md.log.CDebugf(ctx, "MDServerRemote: rekey updates squelched for testing")
return nil
}
for _, req := range requests {
id, err := tlf.ParseID(req.FolderID)
if err != nil {
return err
}
md.log.CDebugf(ctx, "MDServerRemote: folder needs rekey: %s", id.String())
// 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
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"FoldersNeedRekey",
"(",
"ctx",
"context",
".",
"Context",
",",
"requests",
"[",
"]",
"keybase1",
".",
"RekeyRequest",
")",
"error",
"{",
"if",
"md",
".",
"squelchRekey",
"{",
"md",
".",
"log",
".",
"CDebugf... | // FoldersNeedRekey implements the MetadataUpdateProtocol interface. | [
"FoldersNeedRekey",
"implements",
"the",
"MetadataUpdateProtocol",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L897-L916 |
161,059 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | FolderNeedsRekey | func (md *MDServerRemote) FolderNeedsRekey(ctx context.Context,
arg keybase1.FolderNeedsRekeyArg) error {
id, err := tlf.ParseID(arg.FolderID)
if err != nil {
return err
}
md.log.CDebugf(ctx, "MDServerRemote: folder needs rekey: %s", id.String())
if md.squelchRekey {
md.log.CDebugf(ctx, "MDServerRemote: rekey updates squelched for testing")
return 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
} | go | func (md *MDServerRemote) FolderNeedsRekey(ctx context.Context,
arg keybase1.FolderNeedsRekeyArg) error {
id, err := tlf.ParseID(arg.FolderID)
if err != nil {
return err
}
md.log.CDebugf(ctx, "MDServerRemote: folder needs rekey: %s", id.String())
if md.squelchRekey {
md.log.CDebugf(ctx, "MDServerRemote: rekey updates squelched for testing")
return 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
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"FolderNeedsRekey",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"keybase1",
".",
"FolderNeedsRekeyArg",
")",
"error",
"{",
"id",
",",
"err",
":=",
"tlf",
".",
"ParseID",
"(",
"arg",
".",
"FolderID",
"... | // FolderNeedsRekey implements the MetadataUpdateProtocol interface. | [
"FolderNeedsRekey",
"implements",
"the",
"MetadataUpdateProtocol",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L919-L936 |
161,060 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | RegisterForUpdate | func (md *MDServerRemote) RegisterForUpdate(ctx context.Context, id tlf.ID,
currHead kbfsmd.Revision) (<-chan error, error) {
arg := keybase1.RegisterForUpdatesArg{
FolderID: id.String(),
CurrRevision: currHead.Number(),
LogTags: nil,
}
// register
var c chan error
conn := md.getConn()
err := conn.DoCommand(ctx, "register", func(rawClient rpc.GenericClient) error {
// set up the server to receive updates, since we may
// get disconnected between retries.
server := conn.GetServer()
err := server.Register(keybase1.MetadataUpdateProtocol(md))
if err != nil {
if _, ok := err.(rpc.AlreadyRegisteredError); !ok {
return err
}
}
// TODO: Do something with server.Err() when server is
// done?
server.Run()
// keep re-adding the observer on retries, since
// disconnects or connection errors clear observers.
alreadyRegistered := func() bool {
md.observerMu.Lock()
defer md.observerMu.Unlock()
// It's possible for a nil channel to be in
// `md.observers`, if we are still registered with the
// server after a previous cancellation.
existingCh, alreadyRegistered := md.observers[id]
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().
c := keybase1.MetadataClient{Cli: rawClient}
err = c.RegisterForUpdates(ctx, arg)
if err != nil {
func() {
md.observerMu.Lock()
defer md.observerMu.Unlock()
// we could've been canceled by a shutdown so look this up
// again before closing and deleting.
if updateChan, ok := md.observers[id]; ok {
close(updateChan)
delete(md.observers, id)
}
}()
}
return err
})
if err != nil {
c = nil
}
return c, err
} | go | func (md *MDServerRemote) RegisterForUpdate(ctx context.Context, id tlf.ID,
currHead kbfsmd.Revision) (<-chan error, error) {
arg := keybase1.RegisterForUpdatesArg{
FolderID: id.String(),
CurrRevision: currHead.Number(),
LogTags: nil,
}
// register
var c chan error
conn := md.getConn()
err := conn.DoCommand(ctx, "register", func(rawClient rpc.GenericClient) error {
// set up the server to receive updates, since we may
// get disconnected between retries.
server := conn.GetServer()
err := server.Register(keybase1.MetadataUpdateProtocol(md))
if err != nil {
if _, ok := err.(rpc.AlreadyRegisteredError); !ok {
return err
}
}
// TODO: Do something with server.Err() when server is
// done?
server.Run()
// keep re-adding the observer on retries, since
// disconnects or connection errors clear observers.
alreadyRegistered := func() bool {
md.observerMu.Lock()
defer md.observerMu.Unlock()
// It's possible for a nil channel to be in
// `md.observers`, if we are still registered with the
// server after a previous cancellation.
existingCh, alreadyRegistered := md.observers[id]
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().
c := keybase1.MetadataClient{Cli: rawClient}
err = c.RegisterForUpdates(ctx, arg)
if err != nil {
func() {
md.observerMu.Lock()
defer md.observerMu.Unlock()
// we could've been canceled by a shutdown so look this up
// again before closing and deleting.
if updateChan, ok := md.observers[id]; ok {
close(updateChan)
delete(md.observers, id)
}
}()
}
return err
})
if err != nil {
c = nil
}
return c, err
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"RegisterForUpdate",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"tlf",
".",
"ID",
",",
"currHead",
"kbfsmd",
".",
"Revision",
")",
"(",
"<-",
"chan",
"error",
",",
"error",
")",
"{",
"arg",
":=",
... | // RegisterForUpdate implements the MDServer interface for MDServerRemote. | [
"RegisterForUpdate",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L945-L1013 |
161,061 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | OffsetFromServerTime | func (md *MDServerRemote) OffsetFromServerTime() (time.Duration, bool) {
md.serverOffsetMu.RLock()
defer md.serverOffsetMu.RUnlock()
return md.serverOffset, md.serverOffsetKnown
} | go | func (md *MDServerRemote) OffsetFromServerTime() (time.Duration, bool) {
md.serverOffsetMu.RLock()
defer md.serverOffsetMu.RUnlock()
return md.serverOffset, md.serverOffsetKnown
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"OffsetFromServerTime",
"(",
")",
"(",
"time",
".",
"Duration",
",",
"bool",
")",
"{",
"md",
".",
"serverOffsetMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"md",
".",
"serverOffsetMu",
".",
"RUnlock",
"(",
... | // OffsetFromServerTime implements the MDServer interface for
// MDServerRemote. | [
"OffsetFromServerTime",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1102-L1106 |
161,062 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | getFoldersForRekey | func (md *MDServerRemote) getFoldersForRekey(ctx context.Context,
client keybase1.MetadataClient) error {
// get this device's crypt public key
session, err := md.config.KBPKI().GetCurrentSession(ctx)
if err != nil {
return err
}
return client.GetFoldersForRekey(ctx, session.CryptPublicKey.KID())
} | go | func (md *MDServerRemote) getFoldersForRekey(ctx context.Context,
client keybase1.MetadataClient) error {
// get this device's crypt public key
session, err := md.config.KBPKI().GetCurrentSession(ctx)
if err != nil {
return err
}
return client.GetFoldersForRekey(ctx, session.CryptPublicKey.KID())
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"getFoldersForRekey",
"(",
"ctx",
"context",
".",
"Context",
",",
"client",
"keybase1",
".",
"MetadataClient",
")",
"error",
"{",
"// get this device's crypt public key",
"session",
",",
"err",
":=",
"md",
".",
"con... | // getFoldersForRekey registers to receive updates about folders needing rekey actions. | [
"getFoldersForRekey",
"registers",
"to",
"receive",
"updates",
"about",
"folders",
"needing",
"rekey",
"actions",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1146-L1154 |
161,063 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | Shutdown | func (md *MDServerRemote) Shutdown() {
md.connMu.Lock()
defer md.connMu.Unlock()
// close the connection
md.conn.Shutdown()
// cancel pending observers
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()
}
} | go | func (md *MDServerRemote) Shutdown() {
md.connMu.Lock()
defer md.connMu.Unlock()
// close the connection
md.conn.Shutdown()
// cancel pending observers
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()
}
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"Shutdown",
"(",
")",
"{",
"md",
".",
"connMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"md",
".",
"connMu",
".",
"Unlock",
"(",
")",
"\n\n",
"// close the connection",
"md",
".",
"conn",
".",
"Shutdown",
... | // Shutdown implements the MDServer interface for MDServerRemote. | [
"Shutdown",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1157-L1174 |
161,064 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | IsConnected | func (md *MDServerRemote) IsConnected() bool {
conn := md.getConn()
return conn != nil && conn.IsConnected()
} | go | func (md *MDServerRemote) IsConnected() bool {
conn := md.getConn()
return conn != nil && conn.IsConnected()
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"IsConnected",
"(",
")",
"bool",
"{",
"conn",
":=",
"md",
".",
"getConn",
"(",
")",
"\n",
"return",
"conn",
"!=",
"nil",
"&&",
"conn",
".",
"IsConnected",
"(",
")",
"\n",
"}"
] | // IsConnected implements the MDServer interface for MDServerLocal | [
"IsConnected",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerLocal"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1177-L1180 |
161,065 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | GetTLFCryptKeyServerHalf | func (md *MDServerRemote) GetTLFCryptKeyServerHalf(ctx context.Context,
serverHalfID kbfscrypto.TLFCryptKeyServerHalfID,
cryptKey kbfscrypto.CryptPublicKey) (
serverHalf kbfscrypto.TLFCryptKeyServerHalf, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: GetTLFCryptKeyServerHalf %s", serverHalfID)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: GetTLFCryptKeyServerHalf %s (err=%v)", serverHalfID, err)
}()
// encode the ID
idBytes, err := md.config.Codec().Encode(serverHalfID)
if err != nil {
return
}
// get the key
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
} | go | func (md *MDServerRemote) GetTLFCryptKeyServerHalf(ctx context.Context,
serverHalfID kbfscrypto.TLFCryptKeyServerHalfID,
cryptKey kbfscrypto.CryptPublicKey) (
serverHalf kbfscrypto.TLFCryptKeyServerHalf, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: GetTLFCryptKeyServerHalf %s", serverHalfID)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: GetTLFCryptKeyServerHalf %s (err=%v)", serverHalfID, err)
}()
// encode the ID
idBytes, err := md.config.Codec().Encode(serverHalfID)
if err != nil {
return
}
// get the key
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
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"GetTLFCryptKeyServerHalf",
"(",
"ctx",
"context",
".",
"Context",
",",
"serverHalfID",
"kbfscrypto",
".",
"TLFCryptKeyServerHalfID",
",",
"cryptKey",
"kbfscrypto",
".",
"CryptPublicKey",
")",
"(",
"serverHalf",
"kbfscr... | //
// The below methods support the MD server acting as the key server.
// This will be the case for v1 of KBFS but we may move to our own
// separate key server at some point.
//
// GetTLFCryptKeyServerHalf is an implementation of the KeyServer interface. | [
"The",
"below",
"methods",
"support",
"the",
"MD",
"server",
"acting",
"as",
"the",
"key",
"server",
".",
"This",
"will",
"be",
"the",
"case",
"for",
"v1",
"of",
"KBFS",
"but",
"we",
"may",
"move",
"to",
"our",
"own",
"separate",
"key",
"server",
"at",... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1189-L1223 |
161,066 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | PutTLFCryptKeyServerHalves | func (md *MDServerRemote) PutTLFCryptKeyServerHalves(ctx context.Context,
keyServerHalves kbfsmd.UserDeviceKeyServerHalves) (err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: PutTLFCryptKeyServerHalves %v", keyServerHalves)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: PutTLFCryptKeyServerHalves %v (err=%v)", keyServerHalves, err)
}()
// flatten out the map into an array
var keyHalves []keybase1.KeyHalf
for user, deviceMap := range keyServerHalves {
for devicePubKey, serverHalf := range deviceMap {
keyHalf, 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: nil,
}
return md.getClient().PutKeys(ctx, arg)
} | go | func (md *MDServerRemote) PutTLFCryptKeyServerHalves(ctx context.Context,
keyServerHalves kbfsmd.UserDeviceKeyServerHalves) (err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: PutTLFCryptKeyServerHalves %v", keyServerHalves)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: PutTLFCryptKeyServerHalves %v (err=%v)", keyServerHalves, err)
}()
// flatten out the map into an array
var keyHalves []keybase1.KeyHalf
for user, deviceMap := range keyServerHalves {
for devicePubKey, serverHalf := range deviceMap {
keyHalf, 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: nil,
}
return md.getClient().PutKeys(ctx, arg)
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"PutTLFCryptKeyServerHalves",
"(",
"ctx",
"context",
".",
"Context",
",",
"keyServerHalves",
"kbfsmd",
".",
"UserDeviceKeyServerHalves",
")",
"(",
"err",
"error",
")",
"{",
"ctx",
"=",
"rpc",
".",
"WithFireNow",
"... | // PutTLFCryptKeyServerHalves is an implementation of the KeyServer interface. | [
"PutTLFCryptKeyServerHalves",
"is",
"an",
"implementation",
"of",
"the",
"KeyServer",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1226-L1256 |
161,067 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | DeleteTLFCryptKeyServerHalf | func (md *MDServerRemote) DeleteTLFCryptKeyServerHalf(ctx context.Context,
uid keybase1.UID, key kbfscrypto.CryptPublicKey,
serverHalfID kbfscrypto.TLFCryptKeyServerHalfID) (err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: DeleteTLFCryptKeyServerHalf %s %s", uid, serverHalfID)
defer func() {
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(),
KeyHalfID: idBytes,
LogTags: nil,
}
err = md.getClient().DeleteKey(ctx, arg)
if err != nil {
return err
}
return nil
} | go | func (md *MDServerRemote) DeleteTLFCryptKeyServerHalf(ctx context.Context,
uid keybase1.UID, key kbfscrypto.CryptPublicKey,
serverHalfID kbfscrypto.TLFCryptKeyServerHalfID) (err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: DeleteTLFCryptKeyServerHalf %s %s", uid, serverHalfID)
defer func() {
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(),
KeyHalfID: idBytes,
LogTags: nil,
}
err = md.getClient().DeleteKey(ctx, arg)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"DeleteTLFCryptKeyServerHalf",
"(",
"ctx",
"context",
".",
"Context",
",",
"uid",
"keybase1",
".",
"UID",
",",
"key",
"kbfscrypto",
".",
"CryptPublicKey",
",",
"serverHalfID",
"kbfscrypto",
".",
"TLFCryptKeyServerHalf... | // DeleteTLFCryptKeyServerHalf is an implementation of the KeyServer interface. | [
"DeleteTLFCryptKeyServerHalf",
"is",
"an",
"implementation",
"of",
"the",
"KeyServer",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1259-L1287 |
161,068 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | GetKeyBundles | func (md *MDServerRemote) GetKeyBundles(ctx context.Context,
tlf tlf.ID, wkbID kbfsmd.TLFWriterKeyBundleID, rkbID kbfsmd.TLFReaderKeyBundleID) (
wkb *kbfsmd.TLFWriterKeyBundleV3, rkb *kbfsmd.TLFReaderKeyBundleV3, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: GetKeyBundles %s %s %s", tlf, wkbID, rkbID)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: GetKeyBundles %s %s %s done (err=%v)", tlf, wkbID, rkbID, err)
}()
arg := keybase1.GetKeyBundlesArg{
FolderID: tlf.String(),
WriterBundleID: wkbID.String(),
ReaderBundleID: rkbID.String(),
}
response, err := md.getClient().GetKeyBundles(ctx, arg)
if err != nil {
return nil, nil, err
}
if response.WriterBundle.Bundle != nil {
if response.WriterBundle.Version != int(kbfsmd.SegregatedKeyBundlesVer) {
err = fmt.Errorf("Unsupported writer bundle version: %d",
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(), *wkb)
if err != nil {
return nil, nil, err
}
if bundleID != wkbID {
err = fmt.Errorf("Expected writer bundle ID %s, got: %s",
wkbID, bundleID)
return nil, nil, err
}
}
if response.ReaderBundle.Bundle != nil {
if response.ReaderBundle.Version != int(kbfsmd.SegregatedKeyBundlesVer) {
err = fmt.Errorf("Unsupported reader bundle version: %d",
response.ReaderBundle.Version)
return nil, nil, err
}
rkb = new(kbfsmd.TLFReaderKeyBundleV3)
err = md.config.Codec().Decode(response.ReaderBundle.Bundle, rkb)
if err != nil {
return nil, nil, err
}
// Verify it's what we expect.
bundleID, err := kbfsmd.MakeTLFReaderKeyBundleID(md.config.Codec(), *rkb)
if err != nil {
return nil, nil, err
}
if bundleID != rkbID {
err = fmt.Errorf("Expected reader bundle ID %s, got: %s",
rkbID, bundleID)
return nil, nil, err
}
}
return wkb, rkb, nil
} | go | func (md *MDServerRemote) GetKeyBundles(ctx context.Context,
tlf tlf.ID, wkbID kbfsmd.TLFWriterKeyBundleID, rkbID kbfsmd.TLFReaderKeyBundleID) (
wkb *kbfsmd.TLFWriterKeyBundleV3, rkb *kbfsmd.TLFReaderKeyBundleV3, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: GetKeyBundles %s %s %s", tlf, wkbID, rkbID)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: GetKeyBundles %s %s %s done (err=%v)", tlf, wkbID, rkbID, err)
}()
arg := keybase1.GetKeyBundlesArg{
FolderID: tlf.String(),
WriterBundleID: wkbID.String(),
ReaderBundleID: rkbID.String(),
}
response, err := md.getClient().GetKeyBundles(ctx, arg)
if err != nil {
return nil, nil, err
}
if response.WriterBundle.Bundle != nil {
if response.WriterBundle.Version != int(kbfsmd.SegregatedKeyBundlesVer) {
err = fmt.Errorf("Unsupported writer bundle version: %d",
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(), *wkb)
if err != nil {
return nil, nil, err
}
if bundleID != wkbID {
err = fmt.Errorf("Expected writer bundle ID %s, got: %s",
wkbID, bundleID)
return nil, nil, err
}
}
if response.ReaderBundle.Bundle != nil {
if response.ReaderBundle.Version != int(kbfsmd.SegregatedKeyBundlesVer) {
err = fmt.Errorf("Unsupported reader bundle version: %d",
response.ReaderBundle.Version)
return nil, nil, err
}
rkb = new(kbfsmd.TLFReaderKeyBundleV3)
err = md.config.Codec().Decode(response.ReaderBundle.Bundle, rkb)
if err != nil {
return nil, nil, err
}
// Verify it's what we expect.
bundleID, err := kbfsmd.MakeTLFReaderKeyBundleID(md.config.Codec(), *rkb)
if err != nil {
return nil, nil, err
}
if bundleID != rkbID {
err = fmt.Errorf("Expected reader bundle ID %s, got: %s",
rkbID, bundleID)
return nil, nil, err
}
}
return wkb, rkb, nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"GetKeyBundles",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlf",
"tlf",
".",
"ID",
",",
"wkbID",
"kbfsmd",
".",
"TLFWriterKeyBundleID",
",",
"rkbID",
"kbfsmd",
".",
"TLFReaderKeyBundleID",
")",
"(",
"wkb",
... | // GetKeyBundles implements the MDServer interface for MDServerRemote. | [
"GetKeyBundles",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1334-L1401 |
161,069 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | FastForwardBackoff | func (md *MDServerRemote) FastForwardBackoff() {
md.connMu.RLock()
defer md.connMu.RUnlock()
md.conn.FastForwardInitialBackoffTimer()
} | go | func (md *MDServerRemote) FastForwardBackoff() {
md.connMu.RLock()
defer md.connMu.RUnlock()
md.conn.FastForwardInitialBackoffTimer()
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"FastForwardBackoff",
"(",
")",
"{",
"md",
".",
"connMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"md",
".",
"connMu",
".",
"RUnlock",
"(",
")",
"\n",
"md",
".",
"conn",
".",
"FastForwardInitialBackoffTimer",... | // FastForwardBackoff implements the MDServer interface for MDServerRemote. | [
"FastForwardBackoff",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1404-L1408 |
161,070 | keybase/client | go/kbfs/libkbfs/mdserver_remote.go | FindNextMD | func (md *MDServerRemote) FindNextMD(
ctx context.Context, tlfID tlf.ID, rootSeqno keybase1.Seqno) (
nextKbfsRoot *kbfsmd.MerkleRoot, nextMerkleNodes [][]byte,
nextRootSeqno keybase1.Seqno, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: FindNextMD %s %d", tlfID, rootSeqno)
md.log.CDebugf(ctx, "KeyServer: FindNextMD %s %d", tlfID, rootSeqno)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: FindNextMD %s %d done (err=%v)",
tlfID, rootSeqno, err)
md.deferLog.CDebugf(ctx, "KeyServer: FindNextMD %s %d done (err=%v)",
tlfID, rootSeqno, err)
}()
arg := keybase1.FindNextMDArg{
FolderID: tlfID.String(),
Seqno: rootSeqno,
}
response, err := md.getClient().FindNextMD(ctx, arg)
if err != nil {
return nil, nil, 0, err
}
if len(response.MerkleNodes) == 0 {
md.log.CDebugf(ctx, "No merkle data found for %s, seqno=%d",
tlfID, rootSeqno)
return nil, nil, 0, nil
}
if response.KbfsRoot.Version != 1 {
return nil, nil, 0,
kbfsmd.NewMerkleVersionError{Version: response.KbfsRoot.Version}
}
// Verify this is a valid merkle root and KBFS root before we
// decode the bytes.
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().VerifyMerkleRoot(ctx, root, expectedKbfsRoot)
if err != nil {
return nil, nil, 0, err
}
var kbfsRoot kbfsmd.MerkleRoot
err = md.config.Codec().Decode(response.KbfsRoot.Root, &kbfsRoot)
if err != nil {
return nil, nil, 0, err
}
// Validate the hashes of the nodes all the way down to the leaf.
err = verifyMerkleNodes(ctx, &kbfsRoot, response.MerkleNodes, tlfID)
if err != nil {
return nil, nil, 0, err
}
return &kbfsRoot, response.MerkleNodes, response.RootSeqno, nil
} | go | func (md *MDServerRemote) FindNextMD(
ctx context.Context, tlfID tlf.ID, rootSeqno keybase1.Seqno) (
nextKbfsRoot *kbfsmd.MerkleRoot, nextMerkleNodes [][]byte,
nextRootSeqno keybase1.Seqno, err error) {
ctx = rpc.WithFireNow(ctx)
md.log.LazyTrace(ctx, "KeyServer: FindNextMD %s %d", tlfID, rootSeqno)
md.log.CDebugf(ctx, "KeyServer: FindNextMD %s %d", tlfID, rootSeqno)
defer func() {
md.deferLog.LazyTrace(ctx, "KeyServer: FindNextMD %s %d done (err=%v)",
tlfID, rootSeqno, err)
md.deferLog.CDebugf(ctx, "KeyServer: FindNextMD %s %d done (err=%v)",
tlfID, rootSeqno, err)
}()
arg := keybase1.FindNextMDArg{
FolderID: tlfID.String(),
Seqno: rootSeqno,
}
response, err := md.getClient().FindNextMD(ctx, arg)
if err != nil {
return nil, nil, 0, err
}
if len(response.MerkleNodes) == 0 {
md.log.CDebugf(ctx, "No merkle data found for %s, seqno=%d",
tlfID, rootSeqno)
return nil, nil, 0, nil
}
if response.KbfsRoot.Version != 1 {
return nil, nil, 0,
kbfsmd.NewMerkleVersionError{Version: response.KbfsRoot.Version}
}
// Verify this is a valid merkle root and KBFS root before we
// decode the bytes.
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().VerifyMerkleRoot(ctx, root, expectedKbfsRoot)
if err != nil {
return nil, nil, 0, err
}
var kbfsRoot kbfsmd.MerkleRoot
err = md.config.Codec().Decode(response.KbfsRoot.Root, &kbfsRoot)
if err != nil {
return nil, nil, 0, err
}
// Validate the hashes of the nodes all the way down to the leaf.
err = verifyMerkleNodes(ctx, &kbfsRoot, response.MerkleNodes, tlfID)
if err != nil {
return nil, nil, 0, err
}
return &kbfsRoot, response.MerkleNodes, response.RootSeqno, nil
} | [
"func",
"(",
"md",
"*",
"MDServerRemote",
")",
"FindNextMD",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"rootSeqno",
"keybase1",
".",
"Seqno",
")",
"(",
"nextKbfsRoot",
"*",
"kbfsmd",
".",
"MerkleRoot",
",",
"nextMerkleNode... | // FindNextMD implements the MDServer interface for MDServerRemote. | [
"FindNextMD",
"implements",
"the",
"MDServer",
"interface",
"for",
"MDServerRemote",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/mdserver_remote.go#L1411-L1475 |
161,071 | keybase/client | go/kbfs/idutil/tlf_names.go | normalizeNames | func normalizeNames(names []string, t tlf.Type) (changesMade bool, err error) {
for i, name := range names {
x, err := normalizeAssertionOrName(name, t)
if err != nil {
return false, err
}
if x != name {
names[i] = x
changesMade = true
}
}
return changesMade, nil
} | go | func normalizeNames(names []string, t tlf.Type) (changesMade bool, err error) {
for i, name := range names {
x, err := normalizeAssertionOrName(name, t)
if err != nil {
return false, err
}
if x != name {
names[i] = x
changesMade = true
}
}
return changesMade, nil
} | [
"func",
"normalizeNames",
"(",
"names",
"[",
"]",
"string",
",",
"t",
"tlf",
".",
"Type",
")",
"(",
"changesMade",
"bool",
",",
"err",
"error",
")",
"{",
"for",
"i",
",",
"name",
":=",
"range",
"names",
"{",
"x",
",",
"err",
":=",
"normalizeAssertion... | // normalizeNames normalizes a slice of names and returns
// whether any of them changed. | [
"normalizeNames",
"normalizes",
"a",
"slice",
"of",
"names",
"and",
"returns",
"whether",
"any",
"of",
"them",
"changed",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/idutil/tlf_names.go#L62-L74 |
161,072 | keybase/client | go/kbfs/idutil/tlf_names.go | NormalizeNamesInTLF | func NormalizeNamesInTLF(writerNames, readerNames []string,
t tlf.Type, extensionSuffix string) (normalizedName string,
changesMade bool, err error) {
changesMade, err = normalizeNames(writerNames, t)
if err != nil {
return "", false, err
}
sort.Strings(writerNames)
normalizedName = strings.Join(writerNames, ",")
if len(readerNames) > 0 {
rchanges, err := normalizeNames(readerNames, t)
if err != nil {
return "", false, err
}
changesMade = changesMade || rchanges
sort.Strings(readerNames)
normalizedName += tlf.ReaderSep + strings.Join(readerNames, ",")
}
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 normalizedName, changesMade, nil
} | go | func NormalizeNamesInTLF(writerNames, readerNames []string,
t tlf.Type, extensionSuffix string) (normalizedName string,
changesMade bool, err error) {
changesMade, err = normalizeNames(writerNames, t)
if err != nil {
return "", false, err
}
sort.Strings(writerNames)
normalizedName = strings.Join(writerNames, ",")
if len(readerNames) > 0 {
rchanges, err := normalizeNames(readerNames, t)
if err != nil {
return "", false, err
}
changesMade = changesMade || rchanges
sort.Strings(readerNames)
normalizedName += tlf.ReaderSep + strings.Join(readerNames, ",")
}
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 normalizedName, changesMade, nil
} | [
"func",
"NormalizeNamesInTLF",
"(",
"writerNames",
",",
"readerNames",
"[",
"]",
"string",
",",
"t",
"tlf",
".",
"Type",
",",
"extensionSuffix",
"string",
")",
"(",
"normalizedName",
"string",
",",
"changesMade",
"bool",
",",
"err",
"error",
")",
"{",
"chang... | // NormalizeNamesInTLF takes a split TLF name and, without doing any
// resolutions or identify calls, normalizes all elements of the
// name. It then returns the normalized name and a boolean flag
// whether any names were modified.
// This modifies the slices passed as arguments. | [
"NormalizeNamesInTLF",
"takes",
"a",
"split",
"TLF",
"name",
"and",
"without",
"doing",
"any",
"resolutions",
"or",
"identify",
"calls",
"normalizes",
"all",
"elements",
"of",
"the",
"name",
".",
"It",
"then",
"returns",
"the",
"normalized",
"name",
"and",
"a"... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/idutil/tlf_names.go#L81-L108 |
161,073 | keybase/client | go/kbfs/idutil/tlf_names.go | SplitAndNormalizeTLFName | func SplitAndNormalizeTLFName(name string, t tlf.Type) (
writerNames, readerNames []string,
extensionSuffix string, err error) {
writerNames, readerNames, extensionSuffix, err = tlf.SplitName(name)
if err != nil {
return nil, nil, "", err
}
if t == tlf.SingleTeam && len(writerNames) != 1 {
// No team folder can have more than one writer.
return nil, nil, "", NoSuchNameError{Name: name}
}
hasReaders := len(readerNames) != 0
if t != tlf.Private && hasReaders {
// No public/team folder can have readers.
return nil, nil, "", NoSuchNameError{Name: name}
}
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})
}
return writerNames, readerNames, strings.ToLower(extensionSuffix), nil
} | go | func SplitAndNormalizeTLFName(name string, t tlf.Type) (
writerNames, readerNames []string,
extensionSuffix string, err error) {
writerNames, readerNames, extensionSuffix, err = tlf.SplitName(name)
if err != nil {
return nil, nil, "", err
}
if t == tlf.SingleTeam && len(writerNames) != 1 {
// No team folder can have more than one writer.
return nil, nil, "", NoSuchNameError{Name: name}
}
hasReaders := len(readerNames) != 0
if t != tlf.Private && hasReaders {
// No public/team folder can have readers.
return nil, nil, "", NoSuchNameError{Name: name}
}
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})
}
return writerNames, readerNames, strings.ToLower(extensionSuffix), nil
} | [
"func",
"SplitAndNormalizeTLFName",
"(",
"name",
"string",
",",
"t",
"tlf",
".",
"Type",
")",
"(",
"writerNames",
",",
"readerNames",
"[",
"]",
"string",
",",
"extensionSuffix",
"string",
",",
"err",
"error",
")",
"{",
"writerNames",
",",
"readerNames",
",",... | // SplitAndNormalizeTLFName takes a tlf name as a string
// and tries to normalize it offline. In addition to other
// checks it returns TlfNameNotCanonical if it does not
// look canonical.
// Note that ordering differences do not result in TlfNameNotCanonical
// being returned. | [
"SplitAndNormalizeTLFName",
"takes",
"a",
"tlf",
"name",
"as",
"a",
"string",
"and",
"tries",
"to",
"normalize",
"it",
"offline",
".",
"In",
"addition",
"to",
"other",
"checks",
"it",
"returns",
"TlfNameNotCanonical",
"if",
"it",
"does",
"not",
"look",
"canoni... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/idutil/tlf_names.go#L116-L145 |
161,074 | keybase/client | go/kbfs/libkbfs/journal_manager.go | MakeFBOsForExistingJournals | func (j *JournalManager) MakeFBOsForExistingJournals(
ctx context.Context) *sync.WaitGroup {
var wg sync.WaitGroup
j.lock.Lock()
defer j.lock.Unlock()
for tlfID, tj := range j.tlfJournals {
wg.Add(1)
tlfID := tlfID
tj := tj
go func() {
ctx := CtxWithRandomIDReplayable(
context.Background(), CtxFBOIDKey, CtxFBOOpID, j.log)
// Turn off tracker popups.
ctx, err := tlfhandle.MakeExtendedIdentify(
ctx, keybase1.TLFIdentifyBehavior_KBFS_INIT)
if err != nil {
j.log.CWarningf(ctx, "Error making extended identify: %+v", err)
}
defer wg.Done()
j.log.CDebugf(ctx,
"Initializing FBO for non-empty journal: %s", tlfID)
err = j.makeFBOForJournal(ctx, tj, tlfID)
if err != nil {
j.log.CWarningf(ctx,
"Error when 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.
_ = tlfhandle.GetExtendedIdentify(ctx).GetTlfBreakAndClose()
}()
}
return &wg
} | go | func (j *JournalManager) MakeFBOsForExistingJournals(
ctx context.Context) *sync.WaitGroup {
var wg sync.WaitGroup
j.lock.Lock()
defer j.lock.Unlock()
for tlfID, tj := range j.tlfJournals {
wg.Add(1)
tlfID := tlfID
tj := tj
go func() {
ctx := CtxWithRandomIDReplayable(
context.Background(), CtxFBOIDKey, CtxFBOOpID, j.log)
// Turn off tracker popups.
ctx, err := tlfhandle.MakeExtendedIdentify(
ctx, keybase1.TLFIdentifyBehavior_KBFS_INIT)
if err != nil {
j.log.CWarningf(ctx, "Error making extended identify: %+v", err)
}
defer wg.Done()
j.log.CDebugf(ctx,
"Initializing FBO for non-empty journal: %s", tlfID)
err = j.makeFBOForJournal(ctx, tj, tlfID)
if err != nil {
j.log.CWarningf(ctx,
"Error when 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.
_ = tlfhandle.GetExtendedIdentify(ctx).GetTlfBreakAndClose()
}()
}
return &wg
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"MakeFBOsForExistingJournals",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"sync",
".",
"WaitGroup",
"{",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n\n",
"j",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"... | // MakeFBOsForExistingJournals creates folderBranchOps objects for all
// existing, non-empty journals. This is useful to initialize the
// unflushed edit history, for example. It returns a wait group that
// the caller can use to determine when all the FBOs have been
// initialized. If the caller is not going to wait on the group, it
// should provoide a context that won't be canceled before the wait
// group is finished. | [
"MakeFBOsForExistingJournals",
"creates",
"folderBranchOps",
"objects",
"for",
"all",
"existing",
"non",
"-",
"empty",
"journals",
".",
"This",
"is",
"useful",
"to",
"initialize",
"the",
"unflushed",
"edit",
"history",
"for",
"example",
".",
"It",
"returns",
"a",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L323-L363 |
161,075 | keybase/client | go/kbfs/libkbfs/journal_manager.go | enableLocked | func (j *JournalManager) enableLocked(
ctx context.Context, tlfID tlf.ID, chargedTo keybase1.UserOrTeamID,
bws TLFJournalBackgroundWorkStatus, allowEnableIfDirty bool) (
tj *tlfJournal, err error) {
j.log.CDebugf(ctx, "Enabling journal for %s (%s)", tlfID, bws)
defer func() {
if err != nil {
j.deferLog.CDebugf(ctx,
"Error when enabling journal for %s: %+v",
tlfID, err)
}
}()
if j.currentUID == keybase1.UID("") {
return nil, errors.New("Current UID is empty")
}
if j.currentVerifyingKey == (kbfscrypto.VerifyingKey{}) {
return nil, errors.New("Current verifying key is empty")
}
if tj, ok := j.tlfJournals[tlfID]; ok {
err = tj.enable()
if err != nil {
return nil, err
}
return tj, nil
}
err = func() error {
if j.dirtyOps[tlfID] > 0 {
return errors.Errorf("Can't enable journal for %s while there "+
"are outstanding dirty ops", tlfID)
}
if j.delegateDirtyBlockCache.IsAnyDirty(tlfID) {
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 := j.tlfJournalPathLocked(tlfID)
tj, err = makeTLFJournal(
ctx, j.currentUID, j.currentVerifyingKey, tlfDir,
tlfID, chargedTo, tlfJournalConfigAdapter{j.config},
j.delegateBlockServer,
bws, nil, j.onBranchChange, j.onMDFlush, j.config.DiskLimiter())
if err != nil {
return nil, err
}
return tj, nil
} | go | func (j *JournalManager) enableLocked(
ctx context.Context, tlfID tlf.ID, chargedTo keybase1.UserOrTeamID,
bws TLFJournalBackgroundWorkStatus, allowEnableIfDirty bool) (
tj *tlfJournal, err error) {
j.log.CDebugf(ctx, "Enabling journal for %s (%s)", tlfID, bws)
defer func() {
if err != nil {
j.deferLog.CDebugf(ctx,
"Error when enabling journal for %s: %+v",
tlfID, err)
}
}()
if j.currentUID == keybase1.UID("") {
return nil, errors.New("Current UID is empty")
}
if j.currentVerifyingKey == (kbfscrypto.VerifyingKey{}) {
return nil, errors.New("Current verifying key is empty")
}
if tj, ok := j.tlfJournals[tlfID]; ok {
err = tj.enable()
if err != nil {
return nil, err
}
return tj, nil
}
err = func() error {
if j.dirtyOps[tlfID] > 0 {
return errors.Errorf("Can't enable journal for %s while there "+
"are outstanding dirty ops", tlfID)
}
if j.delegateDirtyBlockCache.IsAnyDirty(tlfID) {
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 := j.tlfJournalPathLocked(tlfID)
tj, err = makeTLFJournal(
ctx, j.currentUID, j.currentVerifyingKey, tlfDir,
tlfID, chargedTo, tlfJournalConfigAdapter{j.config},
j.delegateBlockServer,
bws, nil, j.onBranchChange, j.onMDFlush, j.config.DiskLimiter())
if err != nil {
return nil, err
}
return tj, nil
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"enableLocked",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"chargedTo",
"keybase1",
".",
"UserOrTeamID",
",",
"bws",
"TLFJournalBackgroundWorkStatus",
",",
"allowEnableIfDirty",
"bool... | // enabledLocked returns an enabled journal; it is the caller's
// responsibility to add it to `j.tlfJournals`. This allows this
// method to be called in parallel during initialization, if desired. | [
"enabledLocked",
"returns",
"an",
"enabled",
"journal",
";",
"it",
"is",
"the",
"caller",
"s",
"responsibility",
"to",
"add",
"it",
"to",
"j",
".",
"tlfJournals",
".",
"This",
"allows",
"this",
"method",
"to",
"be",
"called",
"in",
"parallel",
"during",
"i... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L564-L624 |
161,076 | keybase/client | go/kbfs/libkbfs/journal_manager.go | Enable | func (j *JournalManager) Enable(ctx context.Context, tlfID tlf.ID,
h *tlfhandle.Handle, bws TLFJournalBackgroundWorkStatus) (err error) {
j.lock.Lock()
defer j.lock.Unlock()
chargedTo := j.currentUID.AsUserOrTeam()
if tlfID.Type() == tlf.SingleTeam {
if h == nil {
// Any path that creates a single-team TLF journal should
// also provide a handle. If not, we'd have to fetch it
// from the server, which isn't a trusted path.
return errors.Errorf(
"No handle provided for single-team TLF %s", tlfID)
}
chargedTo = h.FirstResolvedWriter()
if 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.enableLocked(ctx, tlfID, chargedTo, bws, false)
if err != nil {
return err
}
j.tlfJournals[tlfID] = tj
return nil
} | go | func (j *JournalManager) Enable(ctx context.Context, tlfID tlf.ID,
h *tlfhandle.Handle, bws TLFJournalBackgroundWorkStatus) (err error) {
j.lock.Lock()
defer j.lock.Unlock()
chargedTo := j.currentUID.AsUserOrTeam()
if tlfID.Type() == tlf.SingleTeam {
if h == nil {
// Any path that creates a single-team TLF journal should
// also provide a handle. If not, we'd have to fetch it
// from the server, which isn't a trusted path.
return errors.Errorf(
"No handle provided for single-team TLF %s", tlfID)
}
chargedTo = h.FirstResolvedWriter()
if 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.enableLocked(ctx, tlfID, chargedTo, bws, false)
if err != nil {
return err
}
j.tlfJournals[tlfID] = tj
return nil
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"Enable",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"h",
"*",
"tlfhandle",
".",
"Handle",
",",
"bws",
"TLFJournalBackgroundWorkStatus",
")",
"(",
"err",
"error",
")",
"{",
... | // Enable turns on the write journal for the given TLF. If h is nil,
// it will be attempted to be fetched from the remote MD server. | [
"Enable",
"turns",
"on",
"the",
"write",
"journal",
"for",
"the",
"given",
"TLF",
".",
"If",
"h",
"is",
"nil",
"it",
"will",
"be",
"attempted",
"to",
"be",
"fetched",
"from",
"the",
"remote",
"MD",
"server",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L628-L659 |
161,077 | keybase/client | go/kbfs/libkbfs/journal_manager.go | EnableAuto | func (j *JournalManager) EnableAuto(ctx context.Context) error {
j.lock.Lock()
defer j.lock.Unlock()
if j.serverConfig.EnableAuto {
// Nothing to do.
return nil
}
j.log.CDebugf(ctx, "Enabling auto-journaling")
j.serverConfig.EnableAuto = true
j.serverConfig.EnableAutoSetByUser = true
return j.writeConfig()
} | go | func (j *JournalManager) EnableAuto(ctx context.Context) error {
j.lock.Lock()
defer j.lock.Unlock()
if j.serverConfig.EnableAuto {
// Nothing to do.
return nil
}
j.log.CDebugf(ctx, "Enabling auto-journaling")
j.serverConfig.EnableAuto = true
j.serverConfig.EnableAutoSetByUser = true
return j.writeConfig()
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"EnableAuto",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"j",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"j",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"j",
".",
"server... | // EnableAuto turns on the write journal for all TLFs, even new ones,
// persistently. | [
"EnableAuto",
"turns",
"on",
"the",
"write",
"journal",
"for",
"all",
"TLFs",
"even",
"new",
"ones",
"persistently",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L663-L675 |
161,078 | keybase/client | go/kbfs/libkbfs/journal_manager.go | DisableAuto | func (j *JournalManager) DisableAuto(ctx context.Context) error {
j.lock.Lock()
defer j.lock.Unlock()
if enabled, _ := j.getEnableAutoLocked(); !enabled {
// Nothing to do.
return nil
}
j.log.CDebugf(ctx, "Disabling auto-journaling")
j.serverConfig.EnableAuto = false
j.serverConfig.EnableAutoSetByUser = true
return j.writeConfig()
} | go | func (j *JournalManager) DisableAuto(ctx context.Context) error {
j.lock.Lock()
defer j.lock.Unlock()
if enabled, _ := j.getEnableAutoLocked(); !enabled {
// Nothing to do.
return nil
}
j.log.CDebugf(ctx, "Disabling auto-journaling")
j.serverConfig.EnableAuto = false
j.serverConfig.EnableAutoSetByUser = true
return j.writeConfig()
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"DisableAuto",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"j",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"j",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"enabled",
",",
... | // DisableAuto turns off automatic write journal for any
// newly-accessed TLFs. Existing journaled TLFs need to be disabled
// manually. | [
"DisableAuto",
"turns",
"off",
"automatic",
"write",
"journal",
"for",
"any",
"newly",
"-",
"accessed",
"TLFs",
".",
"Existing",
"journaled",
"TLFs",
"need",
"to",
"be",
"disabled",
"manually",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L680-L692 |
161,079 | keybase/client | go/kbfs/libkbfs/journal_manager.go | PauseBackgroundWork | func (j *JournalManager) PauseBackgroundWork(ctx context.Context, tlfID tlf.ID) {
j.log.CDebugf(ctx, "Signaling pause for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
tlfJournal.pauseBackgroundWork()
return
}
j.log.CDebugf(ctx,
"Could not find journal for %s; dropping pause signal",
tlfID)
} | go | func (j *JournalManager) PauseBackgroundWork(ctx context.Context, tlfID tlf.ID) {
j.log.CDebugf(ctx, "Signaling pause for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
tlfJournal.pauseBackgroundWork()
return
}
j.log.CDebugf(ctx,
"Could not find journal for %s; dropping pause signal",
tlfID)
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"PauseBackgroundWork",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
")",
"{",
"j",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"tlfID",
")",
"\n",
"if",
"tlfJ... | // PauseBackgroundWork pauses the background work goroutine, if it's
// not already paused. | [
"PauseBackgroundWork",
"pauses",
"the",
"background",
"work",
"goroutine",
"if",
"it",
"s",
"not",
"already",
"paused",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L717-L727 |
161,080 | keybase/client | go/kbfs/libkbfs/journal_manager.go | ResumeBackgroundWork | func (j *JournalManager) ResumeBackgroundWork(ctx context.Context, tlfID tlf.ID) {
j.log.CDebugf(ctx, "Signaling resume for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
tlfJournal.resumeBackgroundWork()
return
}
j.log.CDebugf(ctx,
"Could not find journal for %s; dropping resume signal",
tlfID)
} | go | func (j *JournalManager) ResumeBackgroundWork(ctx context.Context, tlfID tlf.ID) {
j.log.CDebugf(ctx, "Signaling resume for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
tlfJournal.resumeBackgroundWork()
return
}
j.log.CDebugf(ctx,
"Could not find journal for %s; dropping resume signal",
tlfID)
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"ResumeBackgroundWork",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
")",
"{",
"j",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"tlfID",
")",
"\n",
"if",
"tlf... | // ResumeBackgroundWork resumes the background work goroutine, if it's
// not already resumed. | [
"ResumeBackgroundWork",
"resumes",
"the",
"background",
"work",
"goroutine",
"if",
"it",
"s",
"not",
"already",
"resumed",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L731-L741 |
161,081 | keybase/client | go/kbfs/libkbfs/journal_manager.go | Flush | func (j *JournalManager) Flush(ctx context.Context, tlfID tlf.ID) (err error) {
j.log.CDebugf(ctx, "Flushing journal for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
// TODO: do we want to plumb lc through here as well?
return tlfJournal.flush(ctx)
}
j.log.CDebugf(ctx, "Journal not enabled for %s", tlfID)
return nil
} | go | func (j *JournalManager) Flush(ctx context.Context, tlfID tlf.ID) (err error) {
j.log.CDebugf(ctx, "Flushing journal for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
// TODO: do we want to plumb lc through here as well?
return tlfJournal.flush(ctx)
}
j.log.CDebugf(ctx, "Journal not enabled for %s", tlfID)
return nil
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"Flush",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
")",
"(",
"err",
"error",
")",
"{",
"j",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"tlfID",
")",
"... | // Flush flushes the write journal for the given TLF. | [
"Flush",
"flushes",
"the",
"write",
"journal",
"for",
"the",
"given",
"TLF",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L744-L753 |
161,082 | keybase/client | go/kbfs/libkbfs/journal_manager.go | FinishSingleOp | func (j *JournalManager) FinishSingleOp(ctx context.Context, tlfID tlf.ID,
lc *keybase1.LockContext, priority keybase1.MDPriority) (err error) {
j.log.CDebugf(ctx, "Finishing single op for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
return tlfJournal.finishSingleOp(ctx, lc, priority)
}
j.log.CDebugf(ctx, "Journal not enabled for %s", tlfID)
return nil
} | go | func (j *JournalManager) FinishSingleOp(ctx context.Context, tlfID tlf.ID,
lc *keybase1.LockContext, priority keybase1.MDPriority) (err error) {
j.log.CDebugf(ctx, "Finishing single op for %s", tlfID)
if tlfJournal, ok := j.getTLFJournal(tlfID, nil); ok {
return tlfJournal.finishSingleOp(ctx, lc, priority)
}
j.log.CDebugf(ctx, "Journal not enabled for %s", tlfID)
return nil
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"FinishSingleOp",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"lc",
"*",
"keybase1",
".",
"LockContext",
",",
"priority",
"keybase1",
".",
"MDPriority",
")",
"(",
"err",
"error... | // FinishSingleOp lets the write journal know that the application has
// finished a single op, and then blocks until the write journal has
// finished flushing everything. | [
"FinishSingleOp",
"lets",
"the",
"write",
"journal",
"know",
"that",
"the",
"application",
"has",
"finished",
"a",
"single",
"op",
"and",
"then",
"blocks",
"until",
"the",
"write",
"journal",
"has",
"finished",
"flushing",
"everything",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L788-L797 |
161,083 | keybase/client | go/kbfs/libkbfs/journal_manager.go | Disable | func (j *JournalManager) Disable(ctx context.Context, tlfID tlf.ID) (
wasEnabled bool, err error) {
j.log.CDebugf(ctx, "Disabling journal for %s", tlfID)
defer func() {
if err != nil {
j.deferLog.CDebugf(ctx,
"Error when disabling journal for %s: %+v",
tlfID, err)
}
}()
j.lock.Lock()
defer j.lock.Unlock()
tlfJournal, ok := j.tlfJournals[tlfID]
if !ok {
j.log.CDebugf(ctx, "Journal doesn't exist for %s", tlfID)
return false, nil
}
if j.dirtyOps[tlfID] > 0 {
return false, errors.Errorf("Can't 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
// journal from j.tlfJournals, to avoid cases where something
// keeps it around doing background work or re-enables it, at the
// same time JournalManager creates a new journal for the same TLF.
wasEnabled, err = tlfJournal.disable()
if err != nil {
return false, err
}
if wasEnabled {
j.log.CDebugf(ctx, "Disabled journal for %s", tlfID)
}
return wasEnabled, nil
} | go | func (j *JournalManager) Disable(ctx context.Context, tlfID tlf.ID) (
wasEnabled bool, err error) {
j.log.CDebugf(ctx, "Disabling journal for %s", tlfID)
defer func() {
if err != nil {
j.deferLog.CDebugf(ctx,
"Error when disabling journal for %s: %+v",
tlfID, err)
}
}()
j.lock.Lock()
defer j.lock.Unlock()
tlfJournal, ok := j.tlfJournals[tlfID]
if !ok {
j.log.CDebugf(ctx, "Journal doesn't exist for %s", tlfID)
return false, nil
}
if j.dirtyOps[tlfID] > 0 {
return false, errors.Errorf("Can't 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
// journal from j.tlfJournals, to avoid cases where something
// keeps it around doing background work or re-enables it, at the
// same time JournalManager creates a new journal for the same TLF.
wasEnabled, err = tlfJournal.disable()
if err != nil {
return false, err
}
if wasEnabled {
j.log.CDebugf(ctx, "Disabled journal for %s", tlfID)
}
return wasEnabled, nil
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"Disable",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
")",
"(",
"wasEnabled",
"bool",
",",
"err",
"error",
")",
"{",
"j",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
... | // Disable turns off the write journal for the given TLF. | [
"Disable",
"turns",
"off",
"the",
"write",
"journal",
"for",
"the",
"given",
"TLF",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L800-L841 |
161,084 | keybase/client | go/kbfs/libkbfs/journal_manager.go | Status | func (j *JournalManager) Status(
ctx context.Context) (JournalManagerStatus, []tlf.ID) {
j.lock.RLock()
defer j.lock.RUnlock()
var totalStoredBytes, totalStoredFiles, totalUnflushedBytes int64
tlfIDs := make([]tlf.ID, 0, len(j.tlfJournals))
for _, tlfJournal := range j.tlfJournals {
storedBytes, storedFiles, unflushedBytes, err :=
tlfJournal.getByteCounts()
if err != nil {
j.log.CWarningf(ctx,
"Couldn't calculate stored bytes/stored files/unflushed bytes for %s: %+v",
tlfJournal.tlfID, err)
}
totalStoredBytes += storedBytes
totalStoredFiles += storedFiles
totalUnflushedBytes += unflushedBytes
tlfIDs = append(tlfIDs, tlfJournal.tlfID)
}
enableAuto, enableAutoSetByUser := j.getEnableAutoLocked()
return JournalManagerStatus{
RootDir: j.rootPath(),
Version: 1,
CurrentUID: j.currentUID,
CurrentVerifyingKey: j.currentVerifyingKey,
EnableAuto: enableAuto,
EnableAutoSetByUser: enableAutoSetByUser,
JournalCount: len(tlfIDs),
StoredBytes: totalStoredBytes,
StoredFiles: totalStoredFiles,
UnflushedBytes: totalUnflushedBytes,
DiskLimiterStatus: j.config.DiskLimiter().getStatus(
ctx, j.currentUID.AsUserOrTeam()),
}, tlfIDs
} | go | func (j *JournalManager) Status(
ctx context.Context) (JournalManagerStatus, []tlf.ID) {
j.lock.RLock()
defer j.lock.RUnlock()
var totalStoredBytes, totalStoredFiles, totalUnflushedBytes int64
tlfIDs := make([]tlf.ID, 0, len(j.tlfJournals))
for _, tlfJournal := range j.tlfJournals {
storedBytes, storedFiles, unflushedBytes, err :=
tlfJournal.getByteCounts()
if err != nil {
j.log.CWarningf(ctx,
"Couldn't calculate stored bytes/stored files/unflushed bytes for %s: %+v",
tlfJournal.tlfID, err)
}
totalStoredBytes += storedBytes
totalStoredFiles += storedFiles
totalUnflushedBytes += unflushedBytes
tlfIDs = append(tlfIDs, tlfJournal.tlfID)
}
enableAuto, enableAutoSetByUser := j.getEnableAutoLocked()
return JournalManagerStatus{
RootDir: j.rootPath(),
Version: 1,
CurrentUID: j.currentUID,
CurrentVerifyingKey: j.currentVerifyingKey,
EnableAuto: enableAuto,
EnableAutoSetByUser: enableAutoSetByUser,
JournalCount: len(tlfIDs),
StoredBytes: totalStoredBytes,
StoredFiles: totalStoredFiles,
UnflushedBytes: totalUnflushedBytes,
DiskLimiterStatus: j.config.DiskLimiter().getStatus(
ctx, j.currentUID.AsUserOrTeam()),
}, tlfIDs
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"Status",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"JournalManagerStatus",
",",
"[",
"]",
"tlf",
".",
"ID",
")",
"{",
"j",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"j",
".",
"lock",
... | // Status returns a JournalManagerStatus object suitable for
// diagnostics. It also returns a list of TLF IDs which have journals
// enabled. | [
"Status",
"returns",
"a",
"JournalManagerStatus",
"object",
"suitable",
"for",
"diagnostics",
".",
"It",
"also",
"returns",
"a",
"list",
"of",
"TLF",
"IDs",
"which",
"have",
"journals",
"enabled",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L908-L942 |
161,085 | keybase/client | go/kbfs/libkbfs/journal_manager.go | JournalStatus | func (j *JournalManager) JournalStatus(tlfID tlf.ID) (
TLFJournalStatus, error) {
tlfJournal, ok := j.getTLFJournal(tlfID, nil)
if !ok {
return TLFJournalStatus{},
errors.Errorf("Journal not enabled for %s", tlfID)
}
return tlfJournal.getJournalStatus()
} | go | func (j *JournalManager) JournalStatus(tlfID tlf.ID) (
TLFJournalStatus, error) {
tlfJournal, ok := j.getTLFJournal(tlfID, nil)
if !ok {
return TLFJournalStatus{},
errors.Errorf("Journal not enabled for %s", tlfID)
}
return tlfJournal.getJournalStatus()
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"JournalStatus",
"(",
"tlfID",
"tlf",
".",
"ID",
")",
"(",
"TLFJournalStatus",
",",
"error",
")",
"{",
"tlfJournal",
",",
"ok",
":=",
"j",
".",
"getTLFJournal",
"(",
"tlfID",
",",
"nil",
")",
"\n",
"if",
... | // JournalStatus returns a TLFServerStatus object for the given TLF
// suitable for diagnostics. | [
"JournalStatus",
"returns",
"a",
"TLFServerStatus",
"object",
"for",
"the",
"given",
"TLF",
"suitable",
"for",
"diagnostics",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L946-L955 |
161,086 | keybase/client | go/kbfs/libkbfs/journal_manager.go | JournalStatusWithPaths | func (j *JournalManager) JournalStatusWithPaths(ctx context.Context,
tlfID tlf.ID, cpp chainsPathPopulator) (TLFJournalStatus, error) {
tlfJournal, ok := j.getTLFJournal(tlfID, nil)
if !ok {
return TLFJournalStatus{},
errors.Errorf("Journal not enabled for %s", tlfID)
}
return tlfJournal.getJournalStatusWithPaths(ctx, cpp)
} | go | func (j *JournalManager) JournalStatusWithPaths(ctx context.Context,
tlfID tlf.ID, cpp chainsPathPopulator) (TLFJournalStatus, error) {
tlfJournal, ok := j.getTLFJournal(tlfID, nil)
if !ok {
return TLFJournalStatus{},
errors.Errorf("Journal not enabled for %s", tlfID)
}
return tlfJournal.getJournalStatusWithPaths(ctx, cpp)
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"JournalStatusWithPaths",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"cpp",
"chainsPathPopulator",
")",
"(",
"TLFJournalStatus",
",",
"error",
")",
"{",
"tlfJournal",
",",
"ok",
... | // JournalStatusWithPaths returns a TLFServerStatus object for the
// given TLF suitable for diagnostics, including paths for all the
// unflushed entries. | [
"JournalStatusWithPaths",
"returns",
"a",
"TLFServerStatus",
"object",
"for",
"the",
"given",
"TLF",
"suitable",
"for",
"diagnostics",
"including",
"paths",
"for",
"all",
"the",
"unflushed",
"entries",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L960-L969 |
161,087 | keybase/client | go/kbfs/libkbfs/journal_manager.go | shutdownExistingJournalsLocked | func (j *JournalManager) shutdownExistingJournalsLocked(ctx context.Context) {
for len(j.dirtyOps) > 0 {
j.log.CDebugf(ctx,
"Waiting for %d TLFS with dirty ops before shutting down "+
"existing journals...", len(j.dirtyOps))
j.dirtyOpsDone.Wait()
}
j.log.CDebugf(ctx, "Shutting down existing journals")
for _, tlfJournal := range j.tlfJournals {
tlfJournal.shutdown(ctx)
}
j.tlfJournals = make(map[tlf.ID]*tlfJournal)
j.currentUID = keybase1.UID("")
j.currentVerifyingKey = kbfscrypto.VerifyingKey{}
} | go | func (j *JournalManager) shutdownExistingJournalsLocked(ctx context.Context) {
for len(j.dirtyOps) > 0 {
j.log.CDebugf(ctx,
"Waiting for %d TLFS with dirty ops before shutting down "+
"existing journals...", len(j.dirtyOps))
j.dirtyOpsDone.Wait()
}
j.log.CDebugf(ctx, "Shutting down existing journals")
for _, tlfJournal := range j.tlfJournals {
tlfJournal.shutdown(ctx)
}
j.tlfJournals = make(map[tlf.ID]*tlfJournal)
j.currentUID = keybase1.UID("")
j.currentVerifyingKey = kbfscrypto.VerifyingKey{}
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"shutdownExistingJournalsLocked",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"for",
"len",
"(",
"j",
".",
"dirtyOps",
")",
">",
"0",
"{",
"j",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\""... | // shutdownExistingJournalsLocked shuts down all write journals, sets
// the current UID and verifying key to zero, and returns once all
// shutdowns are complete. It is safe to call multiple times in a row,
// and once this is called, EnableExistingJournals may be called
// again. | [
"shutdownExistingJournalsLocked",
"shuts",
"down",
"all",
"write",
"journals",
"sets",
"the",
"current",
"UID",
"and",
"verifying",
"key",
"to",
"zero",
"and",
"returns",
"once",
"all",
"shutdowns",
"are",
"complete",
".",
"It",
"is",
"safe",
"to",
"call",
"mu... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L976-L993 |
161,088 | keybase/client | go/kbfs/libkbfs/journal_manager.go | shutdownExistingJournals | func (j *JournalManager) shutdownExistingJournals(ctx context.Context) {
j.lock.Lock()
defer j.lock.Unlock()
j.shutdownExistingJournalsLocked(ctx)
} | go | func (j *JournalManager) shutdownExistingJournals(ctx context.Context) {
j.lock.Lock()
defer j.lock.Unlock()
j.shutdownExistingJournalsLocked(ctx)
} | [
"func",
"(",
"j",
"*",
"JournalManager",
")",
"shutdownExistingJournals",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"j",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"j",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"j",
".",
"shutdownExi... | // shutdownExistingJournals shuts down all write journals, sets the
// current UID and verifying key to zero, and returns once all
// shutdowns are complete. It is safe to call multiple times in a row,
// and once this is called, EnableExistingJournals may be called
// again. | [
"shutdownExistingJournals",
"shuts",
"down",
"all",
"write",
"journals",
"sets",
"the",
"current",
"UID",
"and",
"verifying",
"key",
"to",
"zero",
"and",
"returns",
"once",
"all",
"shutdowns",
"are",
"complete",
".",
"It",
"is",
"safe",
"to",
"call",
"multiple... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/journal_manager.go#L1000-L1004 |
161,089 | keybase/client | go/chat/s3/mem.go | NumPutParts | func (m *MemMulti) NumPutParts() int {
m.Lock()
defer m.Unlock()
return m.numPutParts
} | go | func (m *MemMulti) NumPutParts() int {
m.Lock()
defer m.Unlock()
return m.numPutParts
} | [
"func",
"(",
"m",
"*",
"MemMulti",
")",
"NumPutParts",
"(",
")",
"int",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"m",
".",
"numPutParts",
"\n",
"}"
] | // NumPutParts returns the number of times PutPart was called. | [
"NumPutParts",
"returns",
"the",
"number",
"of",
"times",
"PutPart",
"was",
"called",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/s3/mem.go#L223-L228 |
161,090 | keybase/client | go/kbfs/kbfsblock/context.go | MakeRefNonce | func MakeRefNonce() (RefNonce, error) {
var nonce RefNonce
for nonce == ZeroRefNonce {
err := kbfscrypto.RandRead(nonce[:])
if err != nil {
return ZeroRefNonce, err
}
}
return nonce, nil
} | go | func MakeRefNonce() (RefNonce, error) {
var nonce RefNonce
for nonce == ZeroRefNonce {
err := kbfscrypto.RandRead(nonce[:])
if err != nil {
return ZeroRefNonce, err
}
}
return nonce, nil
} | [
"func",
"MakeRefNonce",
"(",
")",
"(",
"RefNonce",
",",
"error",
")",
"{",
"var",
"nonce",
"RefNonce",
"\n",
"for",
"nonce",
"==",
"ZeroRefNonce",
"{",
"err",
":=",
"kbfscrypto",
".",
"RandRead",
"(",
"nonce",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"... | // MakeRefNonce generates a non-zero block reference nonce using a
// CSPRNG. This is used for distinguishing different references to the
// same ID. | [
"MakeRefNonce",
"generates",
"a",
"non",
"-",
"zero",
"block",
"reference",
"nonce",
"using",
"a",
"CSPRNG",
".",
"This",
"is",
"used",
"for",
"distinguishing",
"different",
"references",
"to",
"the",
"same",
"ID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsblock/context.go#L31-L40 |
161,091 | keybase/client | go/kbfs/kbfsblock/context.go | MakeFirstContext | func MakeFirstContext(
creator keybase1.UserOrTeamID, bType keybase1.BlockType) Context {
return Context{Creator: creator, BlockType: bType}
} | go | func MakeFirstContext(
creator keybase1.UserOrTeamID, bType keybase1.BlockType) Context {
return Context{Creator: creator, BlockType: bType}
} | [
"func",
"MakeFirstContext",
"(",
"creator",
"keybase1",
".",
"UserOrTeamID",
",",
"bType",
"keybase1",
".",
"BlockType",
")",
"Context",
"{",
"return",
"Context",
"{",
"Creator",
":",
"creator",
",",
"BlockType",
":",
"bType",
"}",
"\n",
"}"
] | // MakeFirstContext makes the initial context for a block with the
// given creator. | [
"MakeFirstContext",
"makes",
"the",
"initial",
"context",
"for",
"a",
"block",
"with",
"the",
"given",
"creator",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsblock/context.go#L73-L76 |
161,092 | keybase/client | go/kbfs/kbfsblock/context.go | MakeContext | func MakeContext(
creator keybase1.UserOrTeamID, writer keybase1.UserOrTeamID, nonce RefNonce,
bType keybase1.BlockType) Context {
return Context{
Creator: creator,
Writer: writer,
RefNonce: nonce,
BlockType: bType,
}
} | go | func MakeContext(
creator keybase1.UserOrTeamID, writer keybase1.UserOrTeamID, nonce RefNonce,
bType keybase1.BlockType) Context {
return Context{
Creator: creator,
Writer: writer,
RefNonce: nonce,
BlockType: bType,
}
} | [
"func",
"MakeContext",
"(",
"creator",
"keybase1",
".",
"UserOrTeamID",
",",
"writer",
"keybase1",
".",
"UserOrTeamID",
",",
"nonce",
"RefNonce",
",",
"bType",
"keybase1",
".",
"BlockType",
")",
"Context",
"{",
"return",
"Context",
"{",
"Creator",
":",
"creato... | // MakeContext makes a context with the given creator, writer, and
// nonce, where the writer is not necessarily equal to the creator,
// and the nonce is usually non-zero. | [
"MakeContext",
"makes",
"a",
"context",
"with",
"the",
"given",
"creator",
"writer",
"and",
"nonce",
"where",
"the",
"writer",
"is",
"not",
"necessarily",
"equal",
"to",
"the",
"creator",
"and",
"the",
"nonce",
"is",
"usually",
"non",
"-",
"zero",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsblock/context.go#L81-L90 |
161,093 | keybase/client | go/kbfs/kbfsblock/context.go | GetWriter | func (c Context) GetWriter() keybase1.UserOrTeamID {
if !c.Writer.IsNil() {
return c.Writer
}
return c.Creator
} | go | func (c Context) GetWriter() keybase1.UserOrTeamID {
if !c.Writer.IsNil() {
return c.Writer
}
return c.Creator
} | [
"func",
"(",
"c",
"Context",
")",
"GetWriter",
"(",
")",
"keybase1",
".",
"UserOrTeamID",
"{",
"if",
"!",
"c",
".",
"Writer",
".",
"IsNil",
"(",
")",
"{",
"return",
"c",
".",
"Writer",
"\n",
"}",
"\n",
"return",
"c",
".",
"Creator",
"\n",
"}"
] | // GetWriter returns the writer of the associated block. | [
"GetWriter",
"returns",
"the",
"writer",
"of",
"the",
"associated",
"block",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsblock/context.go#L98-L103 |
161,094 | keybase/client | go/kbfs/kbfsblock/context.go | SetWriter | func (c *Context) SetWriter(newWriter keybase1.UserOrTeamID) {
if c.Creator != newWriter {
c.Writer = newWriter
} else {
// save some bytes by not populating the separate Writer
// field if it matches the creator.
c.Writer = ""
}
} | go | func (c *Context) SetWriter(newWriter keybase1.UserOrTeamID) {
if c.Creator != newWriter {
c.Writer = newWriter
} else {
// save some bytes by not populating the separate Writer
// field if it matches the creator.
c.Writer = ""
}
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"SetWriter",
"(",
"newWriter",
"keybase1",
".",
"UserOrTeamID",
")",
"{",
"if",
"c",
".",
"Creator",
"!=",
"newWriter",
"{",
"c",
".",
"Writer",
"=",
"newWriter",
"\n",
"}",
"else",
"{",
"// save some bytes by not pop... | // SetWriter sets the Writer field, if necessary. | [
"SetWriter",
"sets",
"the",
"Writer",
"field",
"if",
"necessary",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsblock/context.go#L106-L114 |
161,095 | keybase/client | go/kbfs/kbfsmd/merkle_hash.go | MakeMerkleHash | func MakeMerkleHash(codec kbfscodec.Codec, md *RootMetadataSigned) (MerkleHash, error) {
buf, err := codec.Encode(md)
if err != nil {
return MerkleHash{}, err
}
h, err := kbfshash.DefaultHash(buf)
if err != nil {
return MerkleHash{}, err
}
return MerkleHash{h}, nil
} | go | func MakeMerkleHash(codec kbfscodec.Codec, md *RootMetadataSigned) (MerkleHash, error) {
buf, err := codec.Encode(md)
if err != nil {
return MerkleHash{}, err
}
h, err := kbfshash.DefaultHash(buf)
if err != nil {
return MerkleHash{}, err
}
return MerkleHash{h}, nil
} | [
"func",
"MakeMerkleHash",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"md",
"*",
"RootMetadataSigned",
")",
"(",
"MerkleHash",
",",
"error",
")",
"{",
"buf",
",",
"err",
":=",
"codec",
".",
"Encode",
"(",
"md",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // MakeMerkleHash hashes the given signed RootMetadata object. | [
"MakeMerkleHash",
"hashes",
"the",
"given",
"signed",
"RootMetadata",
"object",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/merkle_hash.go#L20-L30 |
161,096 | keybase/client | go/kbfs/kbfsmd/merkle_hash.go | MarshalBinary | func (h MerkleHash) MarshalBinary() (data []byte, err error) {
return h.h.MarshalBinary()
} | go | func (h MerkleHash) MarshalBinary() (data []byte, err error) {
return h.h.MarshalBinary()
} | [
"func",
"(",
"h",
"MerkleHash",
")",
"MarshalBinary",
"(",
")",
"(",
"data",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"return",
"h",
".",
"h",
".",
"MarshalBinary",
"(",
")",
"\n",
"}"
] | // MarshalBinary implements the encoding.BinaryMarshaler interface for
// MerkleHash. Returns an error if the MerkleHash is invalid and not the
// zero MerkleHash. | [
"MarshalBinary",
"implements",
"the",
"encoding",
".",
"BinaryMarshaler",
"interface",
"for",
"MerkleHash",
".",
"Returns",
"an",
"error",
"if",
"the",
"MerkleHash",
"is",
"invalid",
"and",
"not",
"the",
"zero",
"MerkleHash",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/merkle_hash.go#L48-L50 |
161,097 | keybase/client | go/kbfs/kbfsmd/merkle_hash.go | UnmarshalBinary | func (h *MerkleHash) UnmarshalBinary(data []byte) error {
return h.h.UnmarshalBinary(data)
} | go | func (h *MerkleHash) UnmarshalBinary(data []byte) error {
return h.h.UnmarshalBinary(data)
} | [
"func",
"(",
"h",
"*",
"MerkleHash",
")",
"UnmarshalBinary",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"return",
"h",
".",
"h",
".",
"UnmarshalBinary",
"(",
"data",
")",
"\n",
"}"
] | // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface
// for MerkleHash. Returns an error if the given byte array is non-empty and
// the MerkleHash is invalid. | [
"UnmarshalBinary",
"implements",
"the",
"encoding",
".",
"BinaryUnmarshaler",
"interface",
"for",
"MerkleHash",
".",
"Returns",
"an",
"error",
"if",
"the",
"given",
"byte",
"array",
"is",
"non",
"-",
"empty",
"and",
"the",
"MerkleHash",
"is",
"invalid",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/merkle_hash.go#L55-L57 |
161,098 | keybase/client | go/libkb/keymerge.go | MergeKey | func (to *PGPKeyBundle) MergeKey(from *PGPKeyBundle) {
// First, merge identities, adding any signatures found in matching identities
for name, fromIdentity := range from.Identities {
if toIdentity, ok := to.Identities[name]; ok {
to.Identities[name].Signatures = combineSignatures(toIdentity.Signatures, fromIdentity.Signatures)
// There's a primary self-signature that we use. Always take the later
// of the two.
ssTo := to.Identities[name].SelfSignature
ssFrom := fromIdentity.SelfSignature
if ssFrom.CreationTime.After(ssTo.CreationTime) {
to.Identities[name].SelfSignature = ssFrom
}
} else {
to.Identities[fromIdentity.Name] = fromIdentity
}
}
// Then, merge revocations
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.Fingerprint]; ok {
if subkey.Sig.CreationTime.After(to.Subkeys[i].Sig.CreationTime) {
to.Subkeys[i].Sig = subkey.Sig
if subkey.Revocation != nil {
to.Subkeys[i].Revocation = subkey.Revocation
}
}
} else {
to.Subkeys = append(to.Subkeys, subkey)
}
}
} | go | func (to *PGPKeyBundle) MergeKey(from *PGPKeyBundle) {
// First, merge identities, adding any signatures found in matching identities
for name, fromIdentity := range from.Identities {
if toIdentity, ok := to.Identities[name]; ok {
to.Identities[name].Signatures = combineSignatures(toIdentity.Signatures, fromIdentity.Signatures)
// There's a primary self-signature that we use. Always take the later
// of the two.
ssTo := to.Identities[name].SelfSignature
ssFrom := fromIdentity.SelfSignature
if ssFrom.CreationTime.After(ssTo.CreationTime) {
to.Identities[name].SelfSignature = ssFrom
}
} else {
to.Identities[fromIdentity.Name] = fromIdentity
}
}
// Then, merge revocations
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.Fingerprint]; ok {
if subkey.Sig.CreationTime.After(to.Subkeys[i].Sig.CreationTime) {
to.Subkeys[i].Sig = subkey.Sig
if subkey.Revocation != nil {
to.Subkeys[i].Revocation = subkey.Revocation
}
}
} else {
to.Subkeys = append(to.Subkeys, subkey)
}
}
} | [
"func",
"(",
"to",
"*",
"PGPKeyBundle",
")",
"MergeKey",
"(",
"from",
"*",
"PGPKeyBundle",
")",
"{",
"// First, merge identities, adding any signatures found in matching identities",
"for",
"name",
",",
"fromIdentity",
":=",
"range",
"from",
".",
"Identities",
"{",
"i... | // MergeKey adds the identities, revocations, and subkeys of another PGPKeyBundle to this key | [
"MergeKey",
"adds",
"the",
"identities",
"revocations",
"and",
"subkeys",
"of",
"another",
"PGPKeyBundle",
"to",
"this",
"key"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/keymerge.go#L28-L68 |
161,099 | keybase/client | go/kex2/provisioner.go | RunProvisioner | func RunProvisioner(arg ProvisionerArg) error {
p := newProvisioner(arg)
err := p.run()
p.close() // ignore any errors in closing the channel
return err
} | go | func RunProvisioner(arg ProvisionerArg) error {
p := newProvisioner(arg)
err := p.run()
p.close() // ignore any errors in closing the channel
return err
} | [
"func",
"RunProvisioner",
"(",
"arg",
"ProvisionerArg",
")",
"error",
"{",
"p",
":=",
"newProvisioner",
"(",
"arg",
")",
"\n",
"err",
":=",
"p",
".",
"run",
"(",
")",
"\n",
"p",
".",
"close",
"(",
")",
"// ignore any errors in closing the channel",
"\n",
"... | // RunProvisioner runs a provisioner given the necessary arguments. | [
"RunProvisioner",
"runs",
"a",
"provisioner",
"given",
"the",
"necessary",
"arguments",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kex2/provisioner.go#L61-L66 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.