libkbfs

package

Go to main page

Versions in this module

v1

v1.0.48

May 8, 2018

Changes in this version

+ const InitConstrainedString

type ImpatientDebugDumper

+ func NewImpatientDebugDumperForForcedDumps(config Config) *ImpatientDebugDumper

+ func (d *ImpatientDebugDumper) ForceDump(ctx context.Context)

type InitMode

+ func NewInitModeFromType(t InitModeType) InitMode

+ BackgroundFlushesEnabled func() bool

+ BlockManagementEnabled func() bool

+ BlockWorkers func() int

+ ClientType func() keybase1.ClientType

+ ConflictResolutionEnabled func() bool

+ DirtyBlockCacheEnabled func() bool

+ IsTestMode func() bool

+ JournalEnabled func() bool

+ KBFSServiceEnabled func() bool

+ MetricsEnabled func() bool

+ NodeCacheEnabled func() bool

+ PrefetchWorkers func() int

+ QuotaReclamationEnabled func() bool

+ RekeyWorkers func() int

+ ServiceKeepaliveEnabled func() bool

+ TLFEditHistoryEnabled func() bool

+ TLFUpdatesEnabled func() bool

+ Type func() InitModeType

+ UnmergedTLFsEnabled func() bool

+ type InitModeType int

+ const InitConstrained

+ func (im InitModeType) String() string

type KBFSOps

+ MigrateToImplicitTeam func(ctx context.Context, id tlf.ID) error

+ TeamAbandoned func(ctx context.Context, tid keybase1.TeamID)

type KBFSOpsStandard

+ func (fs *KBFSOpsStandard) MigrateToImplicitTeam(ctx context.Context, id tlf.ID) error

+ func (fs *KBFSOpsStandard) TeamAbandoned(ctx context.Context, tid keybase1.TeamID)

type KBPKIClient

+ func (k *KBPKIClient) ListResolvedTeamMembers(ctx context.Context, tid keybase1.TeamID) (writers, readers []keybase1.UID, err error)

type KeybaseServiceBase

+ func (k *KeybaseServiceBase) FinalizeMigration(ctx context.Context, folder keybase1.Folder) (err error)

type MDServer

+ FindNextMD func(ctx context.Context, tlfID tlf.ID, rootSeqno keybase1.Seqno) (nextKbfsRoot *kbfsmd.MerkleRoot, nextMerkleNodes [][]byte, ...)

type MDServerDisk

+ func (md *MDServerDisk) FindNextMD(ctx context.Context, tlfID tlf.ID, rootSeqno keybase1.Seqno) (nextKbfsRoot *kbfsmd.MerkleRoot, nextMerkleNodes [][]byte, ...)

type MDServerMemory

+ func (md *MDServerMemory) FindNextMD(ctx context.Context, tlfID tlf.ID, rootSeqno keybase1.Seqno) (nextKbfsRoot *kbfsmd.MerkleRoot, nextMerkleNodes [][]byte, ...)

type MDServerRemote

+ func (md *MDServerRemote) FindNextMD(ctx context.Context, tlfID tlf.ID, rootSeqno keybase1.Seqno) (nextKbfsRoot *kbfsmd.MerkleRoot, nextMerkleNodes [][]byte, ...)

type RootMetadata

+ func (md *RootMetadata) MakeSuccessorWithNewHandle(ctx context.Context, newHandle *TlfHandle, latestMDVer kbfsmd.MetadataVer, ...) (*RootMetadata, error)

v1.0.44

Feb 21, 2018

Changes in this version

+ const BServerDefaultPingIntervalSeconds

+ const BServerPingTimeout

+ const CtxCROpID

+ const CtxFBMOpID

+ const CtxFBOOpID

+ const CtxJournalOpID

+ const CtxKeybaseServiceOpID

+ const CtxMDSROpID

+ const CtxRekeyOpID

+ const DefaultBlocksInMemCache

+ const ECMRID

+ const ECQUID

+ const EnvTestBServerAddr

+ const EnvTestMDServerAddr

+ const ForcedBranchSquashBytesThresholdDefault

+ const ForcedBranchSquashRevThreshold

+ const InitDefaultString

+ const InitMinimalString

+ const InitSingleOpString

+ const KeybaseServiceName

+ const LoginStatusUpdateName

+ const LogoutStatusUpdateName

+ const MDServiceName

+ const MaxBlockSizeBytesDefault

+ const MdServerBackgroundRekeyPeriod

+ const MdServerDefaultPingIntervalSeconds

+ const MdServerPingTimeout

+ const PublicUIDName

+ const RPCReconnectInterval

+ const StallableBlockGet

+ const StallableBlockPut

+ const StallableMDAfterGetRange

+ const StallableMDAfterPut

+ const StallableMDAfterPutUnmerged

+ const StallableMDGetForTLF

+ const StallableMDGetLatestHandleForTLF

+ const StallableMDGetRange

+ const StallableMDGetUnmergedForTLF

+ const StallableMDGetUnmergedRange

+ const StallableMDPruneBranch

+ const StallableMDPut

+ const StallableMDPutUnmerged

+ const StallableMDResolveBranch

+ const StatusCodeDiskBlockCacheError

+ const TempdirServerAddr

+ const Version

+ var ErrorFile = ".kbfs_error"

+ var NoCurrentSessionExpectedError = "no current session"

+ var PrereleaseBuild string

+ func AddDeviceForLocalUserOrBust(t logger.TestLogBackend, config Config, uid keybase1.UID) int

+ func AddImplicitTeamForTest(config Config, name, suffix string, teamNumber byte, ty tlf.Type) (keybase1.TeamID, error)

+ func AddImplicitTeamForTestOrBust(t logger.TestLogBackend, config Config, name, suffix string, teamNumber byte, ...) keybase1.TeamID

+ func AddNewAssertionForTest(config Config, oldAssertion, newAssertion string) error

+ func AddNewAssertionForTestOrBust(t logger.TestLogBackend, config Config, oldAssertion, newAssertion string)

+ func AddTeamKeyForTest(config Config, tid keybase1.TeamID) error

+ func AddTeamKeyForTestOrBust(t logger.TestLogBackend, config Config, tid keybase1.TeamID)

+ func AddTeamReaderForTest(config Config, tid keybase1.TeamID, uid keybase1.UID) error

+ func AddTeamReaderForTestOrBust(t logger.TestLogBackend, config Config, tid keybase1.TeamID, uid keybase1.UID)

+ func AddTeamWriterForTest(config Config, tid keybase1.TeamID, uid keybase1.UID) error

+ func AddTeamWriterForTestOrBust(t logger.TestLogBackend, config Config, tid keybase1.TeamID, uid keybase1.UID)

+ func BackgroundContextWithCancellationDelayer() context.Context

+ func BoolForString(s string) bool

+ func BuildCanonicalPath(pathType PathType, paths ...string) string

+ func ChangeTeamNameForTest(config Config, oldName, newName string) error

+ func ChangeTeamNameForTestOrBust(t logger.TestLogBackend, config Config, oldName, newName string)

+ func CheckConfigAndShutdown(ctx context.Context, t logger.TestLogBackend, config Config)

+ func CheckTlfHandleOffline(ctx context.Context, name string, t tlf.Type) error

+ func CleanupCancellationDelayer(ctx context.Context) error

+ func ConvertIdentifyError(assertion string, err error) error

+ func CtxWithRandomIDReplayable(ctx context.Context, tagKey interface{}, tagName string, log Warninger) context.Context

+ func DisableCRForTesting(config Config, folderBranch FolderBranch) error

+ func DisableUpdatesForTesting(config Config, folderBranch FolderBranch) (chan<- struct{}, error)

+ func DumpPrivateMetadata(codec kbfscodec.Codec, serializedPMDLength int, pmd PrivateMetadata) (string, error)

+ func EnableAdminFeature(ctx context.Context, runMode libkb.RunMode, config Config) bool

+ func EnableDelayedCancellationWithGracePeriod(ctx context.Context, timeout time.Duration) error

+ func EnableImplicitTeamsForTest(config Config) error

+ func ForceQuotaReclamationForTesting(config Config, folderBranch FolderBranch) error

+ func GetDefaultsUsageString(ctx Context) string

+ func GetLocalUsageString() string

+ func GetRemoteUsageString() string

+ func InitLog(params InitParams, ctx Context) (logger.Logger, error)

+ func InitLogWithPrefix(params InitParams, ctx Context, prefix string, defaultLogPath string) (logger.Logger, error)

+ func MakeLocalTLFCryptKeyOrBust(name string, keyGen kbfsmd.KeyGen) kbfscrypto.TLFCryptKey

+ func MakeLocalUserCryptPrivateKeyOrBust(name libkb.NormalizedUsername) kbfscrypto.CryptPrivateKey

+ func MakeLocalUserCryptPublicKeyOrBust(name libkb.NormalizedUsername) kbfscrypto.CryptPublicKey

+ func MakeLocalUserSigningKeyOrBust(name libkb.NormalizedUsername) kbfscrypto.SigningKey

+ func MakeLocalUserVerifyingKeyOrBust(name libkb.NormalizedUsername) kbfscrypto.VerifyingKey

+ func MakeRandomRequestID() (string, error)

+ func NewContextReplayable(ctx context.Context, change CtxReplayFunc) context.Context

+ func NewContextWithCancellationDelayer(ctx context.Context) (newCtx context.Context, err error)

+ func NewContextWithReplayFrom(ctx context.Context) (context.Context, error)

+ func NewEmptyTLFReaderKeyBundle() kbfsmd.TLFReaderKeyBundleV2

+ func NewEmptyTLFWriterKeyBundle() kbfsmd.TLFWriterKeyBundleV2

+ func NewReadAccessError(h *TlfHandle, username libkb.NormalizedUsername, filename string) error

+ func NewRekeyPermissionError(dir *TlfHandle, username libkb.NormalizedUsername) error

+ func NewSharedKeybaseConnection(kbCtx Context, config Config, handler rpc.ConnectionHandler) *rpc.Connection

+ func NewWriteAccessError(h *TlfHandle, username libkb.NormalizedUsername, filename string) error

+ func NewWriteUnsupportedError(filename string) error

+ func PutBlockCheckLimitErrs(ctx context.Context, bserv BlockServer, reporter Reporter, tlfID tlf.ID, ...) error

+ func ReadyBlock(ctx context.Context, bcache BlockCache, bops BlockOps, crypto cryptoPure, ...) (info BlockInfo, plainSize int, readyBlockData ReadyBlockData, err error)

+ func RegisterOps(codec kbfscodec.Codec)

+ func ResetRootBlock(ctx context.Context, config Config, rmd *RootMetadata) (Block, BlockInfo, ReadyBlockData, error)

+ func RestartCRForTesting(baseCtx context.Context, config Config, folderBranch FolderBranch) error

+ func RevokeDeviceForLocalUserOrBust(t logger.TestLogBackend, config Config, uid keybase1.UID, index int)

+ func Shutdown()

+ func StallBlockOp(ctx context.Context, config Config, stalledOp StallableBlockOp, maxStalls int) (onStalled <-chan struct{}, unstall chan<- struct{}, newCtx context.Context)

+ func StallMDOp(ctx context.Context, config Config, stalledOp StallableMDOp, maxStalls int) (onStalled <-chan struct{}, unstall chan<- struct{}, newCtx context.Context)

+ func SwitchDeviceForLocalUserOrBust(t logger.TestLogBackend, config Config, index int)

+ func TLFJournalEnabled(config Config, tlfID tlf.ID) bool

+ func VersionString() string

+ func WaitForTLFJournal(ctx context.Context, config Config, tlfID tlf.ID, log logger.Logger) error

+ type BadCryptoError struct

+ ID kbfsblock.ID

+ func (e BadCryptoError) Error() string

+ type BadCryptoMDError struct

+ ID tlf.ID

+ func (e BadCryptoMDError) Error() string

+ type BadDataError struct

+ ID kbfsblock.ID

+ func (e BadDataError) Error() string

+ type BadMDError struct

+ ID tlf.ID

+ func (e BadMDError) Error() string

+ type BadSplitError struct

+ func (e BadSplitError) Error() string

+ type BadTLFNameError struct

+ Name string

+ func (e BadTLFNameError) Error() string

+ type Block interface

+ GetEncodedSize func() uint32

+ NewEmpty func() Block

+ Set func(other Block)

+ SetEncodedSize func(size uint32)

+ ToCommonBlock func() *CommonBlock

+ func NewCommonBlock() Block

+ func NewDirBlock() Block

+ func NewFileBlock() Block

+ type BlockCache interface

+ CheckForKnownPtr func(tlf tlf.ID, block *FileBlock) (BlockPointer, error)

+ DeleteKnownPtr func(tlf tlf.ID, block *FileBlock) error

+ DeletePermanent func(id kbfsblock.ID) error

+ DeleteTransient func(ptr BlockPointer, tlf tlf.ID) error

+ GetCleanBytesCapacity func() (capacity uint64)

+ GetWithPrefetch func(ptr BlockPointer) (block Block, prefetchStatus PrefetchStatus, lifetime BlockCacheLifetime, ...)

+ PutWithPrefetch func(ptr BlockPointer, tlf tlf.ID, block Block, lifetime BlockCacheLifetime, ...) error

+ SetCleanBytesCapacity func(capacity uint64)

+ type BlockCacheLifetime int

+ const NoCacheEntry

+ const PermanentEntry

+ const TransientEntry

+ func (l BlockCacheLifetime) String() string

+ type BlockCacheSimple interface

+ Get func(ptr BlockPointer) (Block, error)

+ Put func(ptr BlockPointer, tlf tlf.ID, block Block, lifetime BlockCacheLifetime) error

+ type BlockCacheStandard struct

+ func NewBlockCacheStandard(transientCapacity int, cleanBytesCapacity uint64) *BlockCacheStandard

+ func (b *BlockCacheStandard) CheckForKnownPtr(tlf tlf.ID, block *FileBlock) (BlockPointer, error)

+ func (b *BlockCacheStandard) DeleteKnownPtr(tlf tlf.ID, block *FileBlock) error

+ func (b *BlockCacheStandard) DeletePermanent(id kbfsblock.ID) error

+ func (b *BlockCacheStandard) DeleteTransient(ptr BlockPointer, tlf tlf.ID) error

+ func (b *BlockCacheStandard) Get(ptr BlockPointer) (Block, error)

+ func (b *BlockCacheStandard) GetCleanBytesCapacity() (capacity uint64)

+ func (b *BlockCacheStandard) GetWithPrefetch(ptr BlockPointer) (Block, PrefetchStatus, BlockCacheLifetime, error)

+ func (b *BlockCacheStandard) Put(ptr BlockPointer, tlf tlf.ID, block Block, lifetime BlockCacheLifetime) error

+ func (b *BlockCacheStandard) PutWithPrefetch(ptr BlockPointer, tlf tlf.ID, block Block, lifetime BlockCacheLifetime, ...) (err error)

+ func (b *BlockCacheStandard) SetCleanBytesCapacity(capacity uint64)

+ type BlockChanges struct

+ Info BlockInfo

+ Ops opsList

+ func (bc *BlockChanges) AddOp(o op)

+ func (bc *BlockChanges) AddRefBlock(ptr BlockPointer)

+ func (bc *BlockChanges) AddUnrefBlock(ptr BlockPointer)

+ func (bc *BlockChanges) AddUpdate(oldPtr BlockPointer, newPtr BlockPointer)

+ func (bc *BlockChanges) SizeEstimate() uint64

+ func (bc BlockChanges) Equals(other BlockChanges) bool

+ type BlockDecodeError struct

+ func (e BlockDecodeError) Error() string

+ type BlockDirectType int

+ const DirectBlock

+ const IndirectBlock

+ const UnknownDirectType

+ func (bdt BlockDirectType) String() string

+ type BlockInfo struct

+ EncodedSize uint32

+ func (bi BlockInfo) String() string

+ type BlockOps interface

+ Archive func(ctx context.Context, tlfID tlf.ID, ptrs []BlockPointer) error

+ Delete func(ctx context.Context, tlfID tlf.ID, ptrs []BlockPointer) (liveCounts map[kbfsblock.ID]int, err error)

+ Get func(ctx context.Context, kmd KeyMetadata, blockPtr BlockPointer, block Block, ...) error

+ GetEncodedSize func(ctx context.Context, kmd KeyMetadata, blockPtr BlockPointer) (uint32, error)

+ Prefetcher func() Prefetcher

+ Ready func(ctx context.Context, kmd KeyMetadata, block Block) (id kbfsblock.ID, plainSize int, readyBlockData ReadyBlockData, err error)

+ Shutdown func()

+ TogglePrefetcher func(enable bool) <-chan struct{}

+ type BlockOpsConstrained struct

+ func NewBlockOpsConstrained(delegate BlockOps, bwKBps int) *BlockOpsConstrained

+ type BlockOpsStandard struct

+ func NewBlockOpsStandard(config blockOpsConfig, queueSize, prefetchQueueSize int) *BlockOpsStandard

+ func (b *BlockOpsStandard) Archive(ctx context.Context, tlfID tlf.ID, ptrs []BlockPointer) error

+ func (b *BlockOpsStandard) BlockRetriever() BlockRetriever

+ func (b *BlockOpsStandard) Delete(ctx context.Context, tlfID tlf.ID, ptrs []BlockPointer) (liveCounts map[kbfsblock.ID]int, err error)

+ func (b *BlockOpsStandard) Get(ctx context.Context, kmd KeyMetadata, blockPtr BlockPointer, block Block, ...) error

+ func (b *BlockOpsStandard) GetEncodedSize(ctx context.Context, kmd KeyMetadata, blockPtr BlockPointer) (uint32, error)

+ func (b *BlockOpsStandard) Prefetcher() Prefetcher

+ func (b *BlockOpsStandard) Ready(ctx context.Context, kmd KeyMetadata, block Block) (id kbfsblock.ID, plainSize int, readyBlockData ReadyBlockData, err error)

+ func (b *BlockOpsStandard) Shutdown()

+ func (b *BlockOpsStandard) TogglePrefetcher(enable bool) <-chan struct{}

+ type BlockPointer struct

+ DataVer DataVer

+ DirectType BlockDirectType

+ ID kbfsblock.ID

+ KeyGen kbfsmd.KeyGen

+ func (p BlockPointer) IsInitialized() bool

+ func (p BlockPointer) IsValid() bool

+ func (p BlockPointer) Ref() BlockRef

+ func (p BlockPointer) String() string

+ type BlockRef struct

+ ID kbfsblock.ID

+ RefNonce kbfsblock.RefNonce

+ func (r BlockRef) IsValid() bool

+ func (r BlockRef) String() string

+ type BlockRetriever interface

+ PutInCaches func(ctx context.Context, ptr BlockPointer, tlfID tlf.ID, block Block, ...) error

+ Request func(ctx context.Context, priority int, kmd KeyMetadata, ptr BlockPointer, ...) <-chan error

+ RequestNoPrefetch func(ctx context.Context, priority int, kmd KeyMetadata, ptr BlockPointer, ...) <-chan error

+ TogglePrefetcher func(enable bool, syncCh <-chan struct{}) <-chan struct{}

+ type BlockServer interface

+ AddBlockReference func(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) error

+ ArchiveBlockReferences func(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) error

+ Get func(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) ([]byte, kbfscrypto.BlockCryptKeyServerHalf, error)

+ GetTeamQuotaInfo func(ctx context.Context, tid keybase1.TeamID) (info *kbfsblock.QuotaInfo, err error)

+ GetUserQuotaInfo func(ctx context.Context) (info *kbfsblock.QuotaInfo, err error)

+ IsUnflushed func(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID) (bool, error)

+ Put func(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) error

+ PutAgain func(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) error

+ RemoveBlockReferences func(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (liveCounts map[kbfsblock.ID]int, err error)

+ Shutdown func(ctx context.Context)

+ func MakeTestBlockServerOrBust(t logger.TestLogBackend, config blockServerRemoteConfig, ...) BlockServer

+ type BlockServerDisk struct

+ func NewBlockServerDir(codec kbfscodec.Codec, log logger.Logger, dirPath string) *BlockServerDisk

+ func NewBlockServerTempDir(codec kbfscodec.Codec, log logger.Logger) (*BlockServerDisk, error)

+ func (b *BlockServerDisk) AddBlockReference(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) error

+ func (b *BlockServerDisk) ArchiveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (err error)

+ func (b *BlockServerDisk) Get(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) (data []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, err error)

+ func (b *BlockServerDisk) GetTeamQuotaInfo(ctx context.Context, _ keybase1.TeamID) (info *kbfsblock.QuotaInfo, err error)

+ func (b *BlockServerDisk) GetUserQuotaInfo(ctx context.Context) (info *kbfsblock.QuotaInfo, err error)

+ func (b *BlockServerDisk) IsUnflushed(ctx context.Context, tlfID tlf.ID, _ kbfsblock.ID) (bool, error)

+ func (b *BlockServerDisk) Put(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) (err error)

+ func (b *BlockServerDisk) PutAgain(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) (err error)

+ func (b *BlockServerDisk) RefreshAuthToken(_ context.Context)

+ func (b *BlockServerDisk) RemoveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (liveCounts map[kbfsblock.ID]int, err error)

+ func (b *BlockServerDisk) Shutdown(ctx context.Context)

+ type BlockServerMeasured struct

+ func NewBlockServerMeasured(delegate BlockServer, r metrics.Registry) BlockServerMeasured

+ func (b BlockServerMeasured) AddBlockReference(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) (err error)

+ func (b BlockServerMeasured) ArchiveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (err error)

+ func (b BlockServerMeasured) Get(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) (buf []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, err error)

+ func (b BlockServerMeasured) GetTeamQuotaInfo(ctx context.Context, tid keybase1.TeamID) (info *kbfsblock.QuotaInfo, err error)

+ func (b BlockServerMeasured) GetUserQuotaInfo(ctx context.Context) (info *kbfsblock.QuotaInfo, err error)

+ func (b BlockServerMeasured) IsUnflushed(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID) (isUnflushed bool, err error)

+ func (b BlockServerMeasured) Put(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) (err error)

+ func (b BlockServerMeasured) PutAgain(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) (err error)

+ func (b BlockServerMeasured) RefreshAuthToken(ctx context.Context)

+ func (b BlockServerMeasured) RemoveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (liveCounts map[kbfsblock.ID]int, err error)

+ func (b BlockServerMeasured) Shutdown(ctx context.Context)

+ type BlockServerMemory struct

+ func NewBlockServerMemory(log logger.Logger) *BlockServerMemory

+ func (b *BlockServerMemory) AddBlockReference(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) (err error)

+ func (b *BlockServerMemory) ArchiveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (err error)

+ func (b *BlockServerMemory) Get(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) (data []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, err error)

+ func (b *BlockServerMemory) GetTeamQuotaInfo(ctx context.Context, _ keybase1.TeamID) (info *kbfsblock.QuotaInfo, err error)

+ func (b *BlockServerMemory) GetUserQuotaInfo(ctx context.Context) (info *kbfsblock.QuotaInfo, err error)

+ func (b *BlockServerMemory) IsUnflushed(ctx context.Context, tlfID tlf.ID, _ kbfsblock.ID) (bool, error)

+ func (b *BlockServerMemory) Put(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) (err error)

+ func (b *BlockServerMemory) PutAgain(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context, ...) (err error)

+ func (b *BlockServerMemory) RefreshAuthToken(_ context.Context)

+ func (b *BlockServerMemory) RemoveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (liveCounts map[kbfsblock.ID]int, err error)

+ func (b *BlockServerMemory) Shutdown(ctx context.Context)

+ type BlockServerRemote struct

+ func NewBlockServerRemote(config blockServerRemoteConfig, blkSrvRemote rpc.Remote, ...) *BlockServerRemote

+ func (b *BlockServerRemote) AddBlockReference(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) (err error)

+ func (b *BlockServerRemote) ArchiveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (err error)

+ func (b *BlockServerRemote) Get(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, context kbfsblock.Context) (buf []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, err error)

+ func (b *BlockServerRemote) GetTeamQuotaInfo(ctx context.Context, tid keybase1.TeamID) (info *kbfsblock.QuotaInfo, err error)

+ func (b *BlockServerRemote) GetUserQuotaInfo(ctx context.Context) (info *kbfsblock.QuotaInfo, err error)

+ func (b *BlockServerRemote) IsUnflushed(_ context.Context, _ tlf.ID, _ kbfsblock.ID) (bool, error)

+ func (b *BlockServerRemote) Put(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, bContext kbfsblock.Context, ...) (err error)

+ func (b *BlockServerRemote) PutAgain(ctx context.Context, tlfID tlf.ID, id kbfsblock.ID, bContext kbfsblock.Context, ...) (err error)

+ func (b *BlockServerRemote) RefreshAuthToken(ctx context.Context)

+ func (b *BlockServerRemote) RemoteAddress() string

+ func (b *BlockServerRemote) RemoveBlockReferences(ctx context.Context, tlfID tlf.ID, contexts kbfsblock.ContextMap) (liveCounts map[kbfsblock.ID]int, err error)

+ func (b *BlockServerRemote) Shutdown(ctx context.Context)

+ type BlockSplitter interface

+ CheckSplit func(block *FileBlock) int64

+ CopyUntilSplit func(block *FileBlock, lastBlock bool, data []byte, off int64) int64

+ MaxPtrsPerBlock func() int

+ ShouldEmbedBlockChanges func(bc *BlockChanges) bool

+ type BlockSplitterSimple struct

+ func NewBlockSplitterSimple(desiredBlockSize int64, blockChangeEmbedMaxSize uint64, codec kbfscodec.Codec) (*BlockSplitterSimple, error)

+ func (b *BlockSplitterSimple) CheckSplit(block *FileBlock) int64

+ func (b *BlockSplitterSimple) CopyUntilSplit(block *FileBlock, lastBlock bool, data []byte, off int64) int64

+ func (b *BlockSplitterSimple) MaxPtrsPerBlock() int

+ func (b *BlockSplitterSimple) ShouldEmbedBlockChanges(bc *BlockChanges) bool

+ type BranchName string

+ const MasterBranch

+ type CRAbandonStagedBranchError struct

+ Bid kbfsmd.BranchID

+ Err error

+ func (e CRAbandonStagedBranchError) Error() string

+ type CRWrapError struct

+ func (e CRWrapError) Error() string

+ type Clock interface

+ Now func() time.Time

+ type CoalescingContext struct

+ func NewCoalescingContext(parent context.Context) (*CoalescingContext, context.CancelFunc)

+ func (ctx *CoalescingContext) AddContext(other context.Context) error

+ func (ctx *CoalescingContext) Deadline() (time.Time, bool)

+ func (ctx *CoalescingContext) Done() <-chan struct{}

+ func (ctx *CoalescingContext) Err() error

+ type CommonBlock struct

+ IsInd bool

+ func (cb *CommonBlock) DataVersion() DataVer

+ func (cb *CommonBlock) DeepCopy() CommonBlock

+ func (cb *CommonBlock) GetEncodedSize() uint32

+ func (cb *CommonBlock) NewEmpty() Block

+ func (cb *CommonBlock) Set(other Block)

+ func (cb *CommonBlock) SetEncodedSize(size uint32)

+ func (cb *CommonBlock) ToCommonBlock() *CommonBlock

+ type Config interface

+ AddRootNodeWrapper func(func(Node) Node)

+ BGFlushDirOpBatchSize func() int

+ BGFlushPeriod func() time.Duration

+ BlockOps func() BlockOps

+ BlockSplitter func() BlockSplitter

+ CheckStateOnShutdown func() bool

+ ConflictRenamer func() ConflictRenamer

+ DefaultBlockType func() keybase1.BlockType

+ DelayedCancellationGracePeriod func() time.Duration

+ DirtyBlockCache func() DirtyBlockCache

+ DoBackgroundFlushes func() bool

+ GetRekeyFSMLimiter func() *OngoingWorkLimiter

+ KBFSOps func() KBFSOps

+ KBPKI func() KBPKI

+ KeyBundleCache func() kbfsmd.KeyBundleCache

+ KeyCache func() KeyCache

+ KeyManager func() KeyManager

+ KeyOps func() KeyOps

+ KeyServer func() KeyServer

+ KeybaseService func() KeybaseService

+ MDCache func() MDCache

+ MDOps func() MDOps

+ MDServer func() MDServer

+ MaxDirBytes func() uint64

+ MaxNameBytes func() uint32

+ MetadataVersion func() kbfsmd.MetadataVer

+ MetricsRegistry func() metrics.Registry

+ Notifier func() Notifier

+ PrefetchStatus func(context.Context, tlf.ID, BlockPointer) PrefetchStatus

+ QuotaReclamationMinHeadAge func() time.Duration

+ QuotaReclamationMinUnrefAge func() time.Duration

+ QuotaReclamationPeriod func() time.Duration

+ RekeyQueue func() RekeyQueue

+ RekeyWithPromptWaitTime func() time.Duration

+ Reporter func() Reporter

+ ReqsBufSize func() int

+ ResetCaches func()

+ RootNodeWrappers func() []func(Node) Node

+ SetBGFlushDirOpBatchSize func(s int)

+ SetBGFlushPeriod func(p time.Duration)

+ SetBlockCache func(BlockCache)

+ SetBlockOps func(BlockOps)

+ SetBlockServer func(BlockServer)

+ SetBlockSplitter func(BlockSplitter)

+ SetClock func(Clock)

+ SetCodec func(kbfscodec.Codec)

+ SetConflictRenamer func(ConflictRenamer)

+ SetCrypto func(Crypto)

+ SetDefaultBlockType func(blockType keybase1.BlockType)

+ SetDelayedCancellationGracePeriod func(time.Duration)

+ SetDirtyBlockCache func(DirtyBlockCache)

+ SetDoBackgroundFlushes func(bool)

+ SetKBFSOps func(KBFSOps)

+ SetKBPKI func(KBPKI)

+ SetKeyBundleCache func(kbfsmd.KeyBundleCache)

+ SetKeyCache func(KeyCache)

+ SetKeyManager func(KeyManager)

+ SetKeyOps func(KeyOps)

+ SetKeyServer func(KeyServer)

+ SetKeybaseService func(KeybaseService)

+ SetMDCache func(MDCache)

+ SetMDOps func(MDOps)

+ SetMDServer func(MDServer)

+ SetMetadataVersion func(kbfsmd.MetadataVer)

+ SetMetricsRegistry func(metrics.Registry)

+ SetNotifier func(Notifier)

+ SetRekeyQueue func(RekeyQueue)

+ SetRekeyWithPromptWaitTime func(time.Duration)

+ SetReporter func(Reporter)

+ SetTLFValidDuration func(time.Duration)

+ SetTraceOptions func(enabled bool)

+ Shutdown func(context.Context) error

+ StorageRoot func() string

+ TLFValidDuration func() time.Duration

+ func Init(ctx context.Context, kbCtx Context, params InitParams, ...) (cfg Config, err error)

+ func InitWithLogPrefix(ctx context.Context, kbCtx Context, params InitParams, ...) (cfg Config, err error)

+ type ConfigLocal struct

+ func ConfigAsUser(config *ConfigLocal, loggedInUser libkb.NormalizedUsername) *ConfigLocal

+ func ConfigAsUserWithMode(config *ConfigLocal, loggedInUser libkb.NormalizedUsername, mode InitMode) *ConfigLocal

+ func MakeTestConfigOrBust(t logger.TestLogBackend, users ...libkb.NormalizedUsername) *ConfigLocal

+ func MakeTestConfigOrBustLoggedIn(t logger.TestLogBackend, loggedInIndex int, users ...libkb.NormalizedUsername) *ConfigLocal

+ func MakeTestConfigOrBustLoggedInWithMode(t logger.TestLogBackend, loggedInIndex int, mode InitMode, ...) *ConfigLocal

+ func NewConfigLocal(mode InitMode, loggerFn func(module string) logger.Logger, storageRoot string, ...) *ConfigLocal

+ func (c *ConfigLocal) AddRootNodeWrapper(f func(Node) Node)

+ func (c *ConfigLocal) BGFlushDirOpBatchSize() int

+ func (c *ConfigLocal) BGFlushPeriod() time.Duration

+ func (c *ConfigLocal) BlockCache() BlockCache

+ func (c *ConfigLocal) BlockOps() BlockOps

+ func (c *ConfigLocal) BlockServer() BlockServer

+ func (c *ConfigLocal) BlockSplitter() BlockSplitter

+ func (c *ConfigLocal) CheckStateOnShutdown() bool

+ func (c *ConfigLocal) Clock() Clock

+ func (c *ConfigLocal) Codec() kbfscodec.Codec

+ func (c *ConfigLocal) ConflictRenamer() ConflictRenamer

+ func (c *ConfigLocal) Crypto() Crypto

+ func (c *ConfigLocal) CurrentSessionGetter() CurrentSessionGetter

+ func (c *ConfigLocal) DataVersion() DataVer

+ func (c *ConfigLocal) DefaultBlockType() keybase1.BlockType

+ func (c *ConfigLocal) DelayedCancellationGracePeriod() time.Duration

+ func (c *ConfigLocal) DirtyBlockCache() DirtyBlockCache

+ func (c *ConfigLocal) DiskBlockCache() DiskBlockCache

+ func (c *ConfigLocal) DiskLimiter() DiskLimiter

+ func (c *ConfigLocal) DoBackgroundFlushes() bool

+ func (c *ConfigLocal) EnableDiskLimiter(configRoot string) error

+ func (c *ConfigLocal) EnableJournaling(ctx context.Context, journalRoot string, bws TLFJournalBackgroundWorkStatus) error

+ func (c *ConfigLocal) GetRekeyFSMLimiter() *OngoingWorkLimiter

+ func (c *ConfigLocal) IsSyncedTlf(tlfID tlf.ID) bool

+ func (c *ConfigLocal) IsTestMode() bool

+ func (c *ConfigLocal) KBFSOps() KBFSOps

+ func (c *ConfigLocal) KBPKI() KBPKI

+ func (c *ConfigLocal) KeyBundleCache() kbfsmd.KeyBundleCache

+ func (c *ConfigLocal) KeyCache() KeyCache

+ func (c *ConfigLocal) KeyManager() KeyManager

+ func (c *ConfigLocal) KeyOps() KeyOps

+ func (c *ConfigLocal) KeyServer() KeyServer

+ func (c *ConfigLocal) KeybaseService() KeybaseService

+ func (c *ConfigLocal) MDCache() MDCache

+ func (c *ConfigLocal) MDOps() MDOps

+ func (c *ConfigLocal) MDServer() MDServer

+ func (c *ConfigLocal) MakeDiskBlockCacheIfNotExists() error

+ func (c *ConfigLocal) MakeLogger(module string) logger.Logger

+ func (c *ConfigLocal) MaxDirBytes() uint64

+ func (c *ConfigLocal) MaxNameBytes() uint32

+ func (c *ConfigLocal) MaybeFinishTrace(ctx context.Context, err error)

+ func (c *ConfigLocal) MaybeStartTrace(ctx context.Context, family, title string) context.Context

+ func (c *ConfigLocal) MetadataVersion() kbfsmd.MetadataVer

+ func (c *ConfigLocal) MetricsRegistry() metrics.Registry

+ func (c *ConfigLocal) Mode() InitMode

+ func (c *ConfigLocal) Notifier() Notifier

+ func (c *ConfigLocal) PrefetchStatus(ctx context.Context, tlfID tlf.ID, ptr BlockPointer) PrefetchStatus

+ func (c *ConfigLocal) QuotaReclamationMinHeadAge() time.Duration

+ func (c *ConfigLocal) QuotaReclamationMinUnrefAge() time.Duration

+ func (c *ConfigLocal) QuotaReclamationPeriod() time.Duration

+ func (c *ConfigLocal) RekeyQueue() RekeyQueue

+ func (c *ConfigLocal) RekeyWithPromptWaitTime() time.Duration

+ func (c *ConfigLocal) Reporter() Reporter

+ func (c *ConfigLocal) ReqsBufSize() int

+ func (c *ConfigLocal) ResetCaches()

+ func (c *ConfigLocal) RootNodeWrappers() []func(Node) Node

+ func (c *ConfigLocal) SetBGFlushDirOpBatchSize(s int)

+ func (c *ConfigLocal) SetBGFlushPeriod(p time.Duration)

+ func (c *ConfigLocal) SetBlockCache(b BlockCache)

+ func (c *ConfigLocal) SetBlockOps(b BlockOps)

+ func (c *ConfigLocal) SetBlockServer(b BlockServer)

+ func (c *ConfigLocal) SetBlockSplitter(b BlockSplitter)

+ func (c *ConfigLocal) SetClock(cl Clock)

+ func (c *ConfigLocal) SetCodec(co kbfscodec.Codec)

+ func (c *ConfigLocal) SetConflictRenamer(cr ConflictRenamer)

+ func (c *ConfigLocal) SetCrypto(cr Crypto)

+ func (c *ConfigLocal) SetDefaultBlockType(blockType keybase1.BlockType)

+ func (c *ConfigLocal) SetDelayedCancellationGracePeriod(d time.Duration)

+ func (c *ConfigLocal) SetDirtyBlockCache(d DirtyBlockCache)

+ func (c *ConfigLocal) SetDoBackgroundFlushes(doBGFlush bool)

+ func (c *ConfigLocal) SetKBFSOps(k KBFSOps)

+ func (c *ConfigLocal) SetKBFSService(k *KBFSService)

+ func (c *ConfigLocal) SetKBPKI(k KBPKI)

+ func (c *ConfigLocal) SetKeyBundleCache(k kbfsmd.KeyBundleCache)

+ func (c *ConfigLocal) SetKeyCache(k KeyCache)

+ func (c *ConfigLocal) SetKeyManager(k KeyManager)

+ func (c *ConfigLocal) SetKeyOps(k KeyOps)

+ func (c *ConfigLocal) SetKeyServer(k KeyServer)

+ func (c *ConfigLocal) SetKeybaseService(k KeybaseService)

+ func (c *ConfigLocal) SetMDCache(m MDCache)

+ func (c *ConfigLocal) SetMDOps(m MDOps)

+ func (c *ConfigLocal) SetMDServer(m MDServer)

+ func (c *ConfigLocal) SetMetadataVersion(mdVer kbfsmd.MetadataVer)

+ func (c *ConfigLocal) SetMetricsRegistry(r metrics.Registry)

+ func (c *ConfigLocal) SetNotifier(n Notifier)

+ func (c *ConfigLocal) SetRekeyQueue(r RekeyQueue)

+ func (c *ConfigLocal) SetRekeyWithPromptWaitTime(d time.Duration)

+ func (c *ConfigLocal) SetReporter(r Reporter)

+ func (c *ConfigLocal) SetTLFValidDuration(r time.Duration)

+ func (c *ConfigLocal) SetTlfSyncState(tlfID tlf.ID, isSynced bool) error

+ func (c *ConfigLocal) SetTraceOptions(enabled bool)

+ func (c *ConfigLocal) Shutdown(ctx context.Context) error

+ func (c *ConfigLocal) Signer() kbfscrypto.Signer

+ func (c *ConfigLocal) StorageRoot() string

+ func (c *ConfigLocal) TLFValidDuration() time.Duration

+ type ConflictRenamer interface

+ ConflictRename func(ctx context.Context, op op, original string) (string, error)

+ type ConflictResolver struct

+ func NewConflictResolver(config Config, fbo *folderBranchOps) *ConflictResolver

+ func (cr *ConflictResolver) BeginNewBranch()

+ func (cr *ConflictResolver) ForceCancel()

+ func (cr *ConflictResolver) Pause()

+ func (cr *ConflictResolver) Resolve(ctx context.Context, unmerged kbfsmd.Revision, merged kbfsmd.Revision)

+ func (cr *ConflictResolver) Restart(baseCtx context.Context)

+ func (cr *ConflictResolver) Shutdown()

+ func (cr *ConflictResolver) Wait(ctx context.Context) error

+ type Context env.Context

+ type ContextAlreadyHasCancellationDelayerError struct

+ func (e ContextAlreadyHasCancellationDelayerError) Error() string

+ type CountMeter struct

+ func NewCountMeter() *CountMeter

+ func (m *CountMeter) Count() int64

+ func (m *CountMeter) Mark(i int64)

+ func (m *CountMeter) Rate1() float64

+ func (m *CountMeter) Rate15() float64

+ func (m *CountMeter) Rate5() float64

+ func (m *CountMeter) RateMean() float64

+ func (m *CountMeter) Shutdown() <-chan struct{}

+ func (m *CountMeter) Snapshot() metrics.Meter

+ type Crypto interface

+ DecryptTLFCryptKeyClientHalf func(ctx context.Context, publicKey kbfscrypto.TLFEphemeralPublicKey, ...) (kbfscrypto.TLFCryptKeyClientHalf, error)

+ DecryptTLFCryptKeyClientHalfAny func(ctx context.Context, keys []EncryptedTLFCryptKeyClientAndEphemeral, ...) (kbfscrypto.TLFCryptKeyClientHalf, int, error)

+ Shutdown func()

+ Sign func(context.Context, []byte) (kbfscrypto.SignatureInfo, error)

+ SignForKBFS func(context.Context, []byte) (kbfscrypto.SignatureInfo, error)

+ SignToString func(context.Context, []byte) (string, error)

+ type CryptoClient struct

+ func NewCryptoClient(codec kbfscodec.Codec, client keybase1.CryptoInterface, log logger.Logger) *CryptoClient

+ func (c *CryptoClient) DecryptTLFCryptKeyClientHalf(ctx context.Context, publicKey kbfscrypto.TLFEphemeralPublicKey, ...) (clientHalf kbfscrypto.TLFCryptKeyClientHalf, err error)

+ func (c *CryptoClient) DecryptTLFCryptKeyClientHalfAny(ctx context.Context, keys []EncryptedTLFCryptKeyClientAndEphemeral, ...) (clientHalf kbfscrypto.TLFCryptKeyClientHalf, index int, err error)

+ func (c *CryptoClient) Shutdown()

+ func (c *CryptoClient) Sign(ctx context.Context, msg []byte) (sigInfo kbfscrypto.SignatureInfo, err error)

+ func (c *CryptoClient) SignForKBFS(ctx context.Context, msg []byte) (sigInfo kbfscrypto.SignatureInfo, err error)

+ func (c *CryptoClient) SignToString(ctx context.Context, msg []byte) (signature string, err error)

+ type CryptoClientRPC struct

+ func NewCryptoClientRPC(config Config, kbCtx Context) *CryptoClientRPC

+ func (CryptoClientRPC) HandlerName() string

+ func (c *CryptoClientRPC) OnConnect(ctx context.Context, conn *rpc.Connection, _ rpc.GenericClient, ...) error

+ func (c *CryptoClientRPC) OnConnectError(err error, wait time.Duration)

+ func (c *CryptoClientRPC) OnDisconnected(_ context.Context, status rpc.DisconnectStatus)

+ func (c *CryptoClientRPC) OnDoCommandError(err error, wait time.Duration)

+ func (c *CryptoClientRPC) ShouldRetry(rpcName string, err error) bool

+ func (c *CryptoClientRPC) ShouldRetryOnConnect(err error) bool

+ type CryptoCommon struct

+ func MakeCryptoCommon(codec kbfscodec.Codec) CryptoCommon

+ func (c CryptoCommon) DecryptBlock(encryptedBlock kbfscrypto.EncryptedBlock, key kbfscrypto.BlockCryptKey, ...) error

+ func (c CryptoCommon) DecryptPrivateMetadata(encryptedPmd kbfscrypto.EncryptedPrivateMetadata, key kbfscrypto.TLFCryptKey) (PrivateMetadata, error)

+ func (c CryptoCommon) EncryptBlock(block Block, key kbfscrypto.BlockCryptKey) (plainSize int, encryptedBlock kbfscrypto.EncryptedBlock, err error)

+ func (c CryptoCommon) EncryptPrivateMetadata(pmd PrivateMetadata, key kbfscrypto.TLFCryptKey) (encryptedPmd kbfscrypto.EncryptedPrivateMetadata, err error)

+ func (c CryptoCommon) MakeBlockRefNonce() (nonce kbfsblock.RefNonce, err error)

+ func (c CryptoCommon) MakeRandomBlockCryptKeyServerHalf() (kbfscrypto.BlockCryptKeyServerHalf, error)

+ func (c CryptoCommon) MakeRandomBranchID() (kbfsmd.BranchID, error)

+ func (c CryptoCommon) MakeRandomTLFEphemeralKeys() (kbfscrypto.TLFEphemeralPublicKey, kbfscrypto.TLFEphemeralPrivateKey, error)

+ func (c CryptoCommon) MakeRandomTLFKeys() (kbfscrypto.TLFPublicKey, kbfscrypto.TLFPrivateKey, kbfscrypto.TLFCryptKey, ...)

+ func (c CryptoCommon) MakeRandomTlfID(t tlf.Type) (tlf.ID, error)

+ func (c CryptoCommon) MakeTemporaryBlockID() (kbfsblock.ID, error)

+ type CryptoLocal struct

+ func NewCryptoLocal(codec kbfscodec.Codec, signingKey kbfscrypto.SigningKey, ...) CryptoLocal

+ func (c CryptoLocal) DecryptTLFCryptKeyClientHalf(ctx context.Context, publicKey kbfscrypto.TLFEphemeralPublicKey, ...) (kbfscrypto.TLFCryptKeyClientHalf, error)

+ func (c CryptoLocal) DecryptTLFCryptKeyClientHalfAny(ctx context.Context, keys []EncryptedTLFCryptKeyClientAndEphemeral, _ bool) (clientHalf kbfscrypto.TLFCryptKeyClientHalf, index int, err error)

+ func (c CryptoLocal) Shutdown()

+ type CtxAllowNameKeyType int

+ const CtxAllowNameKey

+ type CtxAllowUnverifiedKeysType int

+ const CtxAllowUnverifiedKeys

+ type CtxBackgroundSyncKeyType int

+ const CtxBackgroundSyncKey

+ type CtxCRTagKey int

+ const CtxCRIDKey

+ type CtxCancellationDelayerKeyType int

+ const CtxCancellationDelayerKey

+ type CtxFBMTagKey int

+ const CtxFBMIDKey

+ type CtxFBOTagKey int

+ const CtxFBOIDKey

+ type CtxJournalTagKey int

+ const CtxJournalIDKey

+ type CtxKeybaseServiceTagKey int

+ const CtxKeybaseServiceIDKey

+ type CtxMDSRTagKey int

+ const CtxMDSRIDKey

+ type CtxNotReplayableError struct

+ func (e CtxNotReplayableError) Error() string

+ type CtxRekeyTagKey int

+ const CtxRekeyIDKey

+ type CtxReplayFunc func(ctx context.Context) context.Context

+ type CtxReplayKeyType int

+ const CtxReplayKey

+ type CurrentSessionGetter interface

+ GetCurrentSession func(ctx context.Context) (SessionInfo, error)

+ type DataVer int

+ const AtLeastTwoLevelsOfChildrenDataVer

+ const ChildHolesDataVer

+ const FirstValidDataVer

+ func DefaultNewBlockDataVersion(holes bool) DataVer

+ type DirBlock struct

+ Children map[string]DirEntry

+ IPtrs []IndirectDirPtr

+ func (db *DirBlock) DeepCopy() *DirBlock

+ func (db *DirBlock) NewEmpty() Block

+ func (db *DirBlock) Set(other Block)

+ func (db *DirBlock) ToCommonBlock() *CommonBlock

+ type DirEntry struct

+ func (de *DirEntry) IsInitialized() bool

+ type DirNotEmptyError struct

+ Name string

+ func (e DirNotEmptyError) Error() string

+ type DirTooBigError struct

+ func (e DirTooBigError) Error() string

+ type DirtyBlockCache interface

+ BlockSyncFinished func(tlfID tlf.ID, size int64)

+ Delete func(tlfID tlf.ID, ptr BlockPointer, branch BranchName) error

+ Get func(tlfID tlf.ID, ptr BlockPointer, branch BranchName) (Block, error)

+ IsAnyDirty func(tlfID tlf.ID) bool

+ IsDirty func(tlfID tlf.ID, ptr BlockPointer, branch BranchName) bool

+ Put func(tlfID tlf.ID, ptr BlockPointer, branch BranchName, block Block) error

+ RequestPermissionToDirty func(ctx context.Context, tlfID tlf.ID, estimatedDirtyBytes int64) (DirtyPermChan, error)

+ ShouldForceSync func(tlfID tlf.ID) bool

+ Shutdown func() error

+ SyncFinished func(tlfID tlf.ID, size int64)

+ UpdateSyncingBytes func(tlfID tlf.ID, size int64)

+ UpdateUnsyncedBytes func(tlfID tlf.ID, newUnsyncedBytes int64, wasSyncing bool)

+ type DirtyBlockCacheStandard struct

+ func NewDirtyBlockCacheStandard(clock Clock, log logger.Logger, minSyncBufCap int64, maxSyncBufCap int64, ...) *DirtyBlockCacheStandard

+ func (d *DirtyBlockCacheStandard) BlockSyncFinished(_ tlf.ID, size int64)

+ func (d *DirtyBlockCacheStandard) Delete(_ tlf.ID, ptr BlockPointer, branch BranchName) error

+ func (d *DirtyBlockCacheStandard) Get(_ tlf.ID, ptr BlockPointer, branch BranchName) (Block, error)

+ func (d *DirtyBlockCacheStandard) IsAnyDirty(_ tlf.ID) bool

+ func (d *DirtyBlockCacheStandard) IsDirty(_ tlf.ID, ptr BlockPointer, branch BranchName) (isDirty bool)

+ func (d *DirtyBlockCacheStandard) Put(_ tlf.ID, ptr BlockPointer, branch BranchName, block Block) error

+ func (d *DirtyBlockCacheStandard) RequestPermissionToDirty(ctx context.Context, _ tlf.ID, estimatedDirtyBytes int64) (DirtyPermChan, error)

+ func (d *DirtyBlockCacheStandard) ShouldForceSync(_ tlf.ID) bool

+ func (d *DirtyBlockCacheStandard) Shutdown() error

+ func (d *DirtyBlockCacheStandard) SyncFinished(_ tlf.ID, size int64)

+ func (d *DirtyBlockCacheStandard) UpdateSyncingBytes(_ tlf.ID, size int64)

+ func (d *DirtyBlockCacheStandard) UpdateUnsyncedBytes(_ tlf.ID, newUnsyncedBytes int64, wasSyncing bool)

+ type DirtyPermChan <-chan struct

+ type DisallowedPrefixError struct

+ func (e DisallowedPrefixError) Error() string

+ type DiskBlockCache interface

+ Delete func(ctx context.Context, blockIDs []kbfsblock.ID) (numRemoved int, sizeRemoved int64, err error)

+ Get func(ctx context.Context, tlfID tlf.ID, blockID kbfsblock.ID) (buf []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, ...)

+ Put func(ctx context.Context, tlfID tlf.ID, blockID kbfsblock.ID, buf []byte, ...) error

+ Shutdown func(ctx context.Context)

+ Status func(ctx context.Context) map[string]DiskBlockCacheStatus

+ UpdateMetadata func(ctx context.Context, blockID kbfsblock.ID, prefetchStatus PrefetchStatus) error

+ type DiskBlockCacheError struct

+ Msg string

+ func (e DiskBlockCacheError) Error() string

+ func (e DiskBlockCacheError) ToStatus() (s keybase1.Status)

+ type DiskBlockCacheLocal struct

+ func (cache *DiskBlockCacheLocal) Delete(ctx context.Context, blockIDs []kbfsblock.ID) (numRemoved int, sizeRemoved int64, err error)

+ func (cache *DiskBlockCacheLocal) Get(ctx context.Context, tlfID tlf.ID, blockID kbfsblock.ID) (buf []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, ...)

+ func (cache *DiskBlockCacheLocal) GetMetadata(ctx context.Context, blockID kbfsblock.ID) (DiskBlockCacheMetadata, error)

+ func (cache *DiskBlockCacheLocal) Put(ctx context.Context, tlfID tlf.ID, blockID kbfsblock.ID, buf []byte, ...) error

+ func (cache *DiskBlockCacheLocal) Shutdown(ctx context.Context)

+ func (cache *DiskBlockCacheLocal) Status(ctx context.Context) map[string]DiskBlockCacheStatus

+ func (cache *DiskBlockCacheLocal) UpdateMetadata(ctx context.Context, blockID kbfsblock.ID, prefetchStatus PrefetchStatus) (err error)

+ func (cache *DiskBlockCacheLocal) WaitUntilStarted()

+ type DiskBlockCacheMetadata struct

+ BlockSize uint32

+ FinishedPrefetch bool

+ LRUTime time.Time

+ TlfID tlf.ID

+ TriggeredPrefetch bool

+ type DiskBlockCacheRemote struct

+ func NewDiskBlockCacheRemote(kbCtx Context, config diskBlockCacheRemoteConfig) (*DiskBlockCacheRemote, error)

+ func (dbcr *DiskBlockCacheRemote) Delete(ctx context.Context, blockIDs []kbfsblock.ID) (numRemoved int, sizeRemoved int64, err error)

+ func (dbcr *DiskBlockCacheRemote) Get(ctx context.Context, tlfID tlf.ID, blockID kbfsblock.ID) (buf []byte, serverHalf kbfscrypto.BlockCryptKeyServerHalf, ...)

+ func (dbcr *DiskBlockCacheRemote) Put(ctx context.Context, tlfID tlf.ID, blockID kbfsblock.ID, buf []byte, ...) (err error)

+ func (dbcr *DiskBlockCacheRemote) Shutdown(ctx context.Context)

+ func (dbcr *DiskBlockCacheRemote) Status(ctx context.Context) map[string]DiskBlockCacheStatus

+ func (dbcr *DiskBlockCacheRemote) UpdateMetadata(ctx context.Context, blockID kbfsblock.ID, prefetchStatus PrefetchStatus) error

+ type DiskBlockCacheService struct

+ func NewDiskBlockCacheService(config diskBlockCacheServiceConfig) *DiskBlockCacheService

+ func (cache *DiskBlockCacheService) DeleteBlocks(ctx context.Context, blockIDs [][]byte) (kbgitkbfs.DeleteBlocksRes, error)

+ func (cache *DiskBlockCacheService) GetBlock(ctx context.Context, arg kbgitkbfs.GetBlockArg) (kbgitkbfs.GetBlockRes, error)

+ func (cache *DiskBlockCacheService) PutBlock(ctx context.Context, arg kbgitkbfs.PutBlockArg) error

+ func (cache *DiskBlockCacheService) UpdateBlockMetadata(ctx context.Context, arg kbgitkbfs.UpdateBlockMetadataArg) error

+ type DiskBlockCacheStatus struct

+ BlockBytes uint64

+ CurrByteLimit uint64

+ Hits MeterStatus

+ IsStarting bool

+ MetadataUpdates MeterStatus

+ Misses MeterStatus

+ NumBlocks uint64

+ NumDeleted MeterStatus

+ NumEvicted MeterStatus

+ Puts MeterStatus

+ SizeDeleted MeterStatus

+ SizeEvicted MeterStatus

+ type DiskCacheClosedError struct

+ func (e DiskCacheClosedError) Error() string

+ type DiskCacheMode int

+ const DiskCacheModeLocal

+ const DiskCacheModeOff

+ const DiskCacheModeRemote

+ func (m *DiskCacheMode) Set(s string) error

+ func (m DiskCacheMode) String() string

+ type DiskCacheStartingError struct

+ func (e DiskCacheStartingError) Error() string

+ type DiskLimiter interface

+ type ECMRCtxTagKey struct

+ type ECQUCtxTagKey struct

+ type EmptyNameError struct

+ func (e EmptyNameError) Error() string

+ type EncryptedTLFCryptKeyClientAndEphemeral struct

+ ClientHalf kbfscrypto.EncryptedTLFCryptKeyClientHalf

+ EPubKey kbfscrypto.TLFEphemeralPublicKey

+ PubKey kbfscrypto.CryptPublicKey

+ type EntryInfo struct

+ Ctime int64

+ Mtime int64

+ Size uint64

+ SymPath string

+ TeamWriter keybase1.UID

+ Type EntryType

+ type EntryType int

+ const Dir

+ const Exec

+ const File

+ const Sym

+ func (et EntryType) IsFile() bool

+ func (et EntryType) String() string

+ type ErrDiskLimitTimeout struct

+ func (e *ErrDiskLimitTimeout) Error() string

+ type ErrorFileAccessError struct

+ func (e ErrorFileAccessError) Error() string

+ type ErrorModeType int

+ const ReadMode

+ const WriteMode

+ type EventuallyConsistentMerkleRoot struct

+ func NewEventuallyConsistentMerkleRoot(config Config, getter merkleRootGetter) *EventuallyConsistentMerkleRoot

+ func (ecmr *EventuallyConsistentMerkleRoot) Get(ctx context.Context, bgTolerance, blockTolerance time.Duration) (timestamp time.Time, root keybase1.MerkleRootV2, err error)

+ type EventuallyConsistentQuotaUsage struct

+ func NewEventuallyConsistentQuotaUsage(config Config, loggerSuffix string) *EventuallyConsistentQuotaUsage

+ func NewEventuallyConsistentTeamQuotaUsage(config Config, tid keybase1.TeamID, loggerSuffix string) *EventuallyConsistentQuotaUsage

+ func (q *EventuallyConsistentQuotaUsage) Get(ctx context.Context, bgTolerance, blockTolerance time.Duration) (timestamp time.Time, usageBytes, limitBytes int64, err error)

+ func (q *EventuallyConsistentQuotaUsage) GetAllTypes(ctx context.Context, bgTolerance, blockTolerance time.Duration) (timestamp time.Time, ...)

+ type Excl bool

+ const NoExcl

+ const WithExcl

+ func (o Excl) String() string

+ type ExclOnUnmergedError struct

+ func (e ExclOnUnmergedError) Error() string

+ type ExtendedIdentifyAlreadyExists struct

+ func (e ExtendedIdentifyAlreadyExists) Error() string

+ type Favorite struct

+ Name string

+ Type tlf.Type

+ func NewFavoriteFromFolder(folder keybase1.Folder) *Favorite

+ func (f Favorite) ToKBFolder(created bool) keybase1.Folder

+ type Favorites struct

+ func NewFavorites(config Config) *Favorites

+ func (f *Favorites) Add(ctx context.Context, fav favToAdd) error

+ func (f *Favorites) AddAsync(ctx context.Context, fav favToAdd)

+ func (f *Favorites) Delete(ctx context.Context, fav Favorite) error

+ func (f *Favorites) Get(ctx context.Context) ([]Favorite, error)

+ func (f *Favorites) RefreshCache(ctx context.Context)

+ func (f *Favorites) Shutdown() error

+ type FavoritesOp int

+ const FavoritesOpAdd

+ const FavoritesOpAddNewlyCreated

+ const FavoritesOpNoChange

+ const FavoritesOpRemove

+ type FileBlock struct

+ Contents []byte

+ IPtrs []IndirectFilePtr

+ func (fb *FileBlock) DataVersion() DataVer

+ func (fb *FileBlock) DeepCopy() *FileBlock

+ func (fb *FileBlock) GetHash() kbfshash.RawDefaultHash

+ func (fb *FileBlock) NewEmpty() Block

+ func (fb *FileBlock) Set(other Block)

+ func (fb *FileBlock) ToCommonBlock() *CommonBlock

+ type FileTooBigError struct

+ func (e FileTooBigError) Error() string

+ type FileTooBigForCRError struct

+ func (e FileTooBigForCRError) Error() string

+ type FolderBranch struct

+ Branch BranchName

+ Tlf tlf.ID

+ func (fb FolderBranch) String() string

+ type FolderBranchStatus struct

+ BranchID string

+ DirtyPaths []string

+ DiskUsage uint64

+ FolderID string

+ GitLimitBytes int64

+ GitUsageBytes int64

+ HeadWriter libkb.NormalizedUsername

+ Journal *TLFJournalStatus

+ LatestKeyGeneration kbfsmd.KeyGen

+ LimitBytes int64

+ MDVersion kbfsmd.MetadataVer

+ Merged []*crChainSummary

+ PermanentErr string

+ PrefetchStatus string

+ RekeyPending bool

+ Revision kbfsmd.Revision

+ RootBlockID string

+ Staged bool

+ SyncEnabled bool

+ Unmerged []*crChainSummary

+ UsageBytes int64

+ type GCOp struct

+ LatestRev kbfsmd.Revision

+ func (gco *GCOp) SizeExceptUpdates() uint64

+ func (gco *GCOp) String() string

+ func (gco *GCOp) StringWithRefs(indent string) string

+ type ImmutableBareRootMetadata struct

+ func MakeImmutableBareRootMetadata(rmd kbfsmd.RootMetadata, extra kbfsmd.ExtraMetadata, mdID kbfsmd.ID, ...) ImmutableBareRootMetadata

+ func (ibrmd ImmutableBareRootMetadata) MakeBareTlfHandleWithExtra() (tlf.Handle, error)

+ type ImmutableRootMetadata struct

+ func MakeCopyWithDecryptedPrivateData(ctx context.Context, config Config, ...) (rmdDecrypted ImmutableRootMetadata, err error)

+ func MakeImmutableRootMetadata(rmd *RootMetadata, writerVerifyingKey kbfscrypto.VerifyingKey, mdID kbfsmd.ID, ...) ImmutableRootMetadata

+ func (irmd ImmutableRootMetadata) LastModifyingWriterVerifyingKey() kbfscrypto.VerifyingKey

+ func (irmd ImmutableRootMetadata) LocalTimestamp() time.Time

+ func (irmd ImmutableRootMetadata) MdID() kbfsmd.ID

+ type ImpatientDebugDumper struct

+ func NewImpatientDebugDumper(config Config, dumpIn time.Duration) *ImpatientDebugDumper

+ func (d *ImpatientDebugDumper) Begin(ctx context.Context) (done func())

+ func (d *ImpatientDebugDumper) Shutdown()

+ type ImplicitTeamInfo struct

+ Name libkb.NormalizedUsername

+ TID keybase1.TeamID

+ TlfID tlf.ID

+ type IncompatibleHandleError struct

+ func (e IncompatibleHandleError) Error() string

+ type InconsistentEncodedSizeError struct

+ func (e InconsistentEncodedSizeError) Error() string

+ type IndirectDirPtr struct

+ Off string

+ type IndirectFilePtr struct

+ Holes bool

+ Off int64

+ type InfiniteChannelWrapper struct

+ func NewInfiniteChannelWrapper() *InfiniteChannelWrapper

+ func (ch *InfiniteChannelWrapper) Close()

+ func (ch *InfiniteChannelWrapper) In() chan<- interface{}

+ type InitMode int

+ const InitDefault

+ const InitMinimal

+ const InitModeMask

+ const InitSingleOp

+ const InitTest

+ func (im InitMode) HasFlags(flags InitMode) bool

+ func (im InitMode) Mode() InitMode

+ func (im InitMode) String() string

+ type InitParams struct

+ BGFlushDirOpBatchSize int

+ BGFlushPeriod time.Duration

+ BServerAddr string

+ CleanBlockCacheCapacity uint64

+ CreateGitHandlerInstance func(Config) keybase1.KBFSGitInterface

+ CreateSimpleFSInstance func(Config) keybase1.SimpleFSInterface

+ Debug bool

+ DiskCacheMode DiskCacheMode

+ EnableJournal bool

+ LocalFavoriteStorage string

+ LocalUser string

+ LogFileConfig logger.LogFileConfig

+ LogToFile bool

+ MDServerAddr string

+ MetadataVersion kbfsmd.MetadataVer

+ Mode string

+ StorageRoot string

+ TLFJournalBackgroundWorkStatus TLFJournalBackgroundWorkStatus

+ TLFValidDuration time.Duration

+ func AddFlags(flags *flag.FlagSet, ctx Context) *InitParams

+ func AddFlagsWithDefaults(flags *flag.FlagSet, defaultParams InitParams, defaultLogPath string) *InitParams

+ func DefaultInitParams(ctx Context) InitParams

+ type InvalidBlockRefError struct

+ func (e InvalidBlockRefError) Error() string

+ type InvalidDataVersionError struct

+ DataVer DataVer

+ func (e InvalidDataVersionError) Error() string

+ type InvalidFavoritesOpError struct

+ func (InvalidFavoritesOpError) Error() string

+ type InvalidOpError struct

+ func (e InvalidOpError) Error() string

+ type InvalidParentPathError struct

+ func (e InvalidParentPathError) Error() string

+ type InvalidPathError struct

+ func (e InvalidPathError) Error() string

+ type InvalidVersionError struct

+ func (e InvalidVersionError) Error() string

+ type JournalServer struct

+ func GetJournalServer(config Config) (*JournalServer, error)

+ func (j *JournalServer) Disable(ctx context.Context, tlfID tlf.ID) (wasEnabled bool, err error)

+ func (j *JournalServer) DisableAuto(ctx context.Context) error

+ func (j *JournalServer) Enable(ctx context.Context, tlfID tlf.ID, h *TlfHandle, ...) (err error)

+ func (j *JournalServer) EnableAuto(ctx context.Context) error

+ func (j *JournalServer) EnableExistingJournals(ctx context.Context, currentUID keybase1.UID, ...) (err error)

+ func (j *JournalServer) FinishSingleOp(ctx context.Context, tlfID tlf.ID, lc *keybase1.LockContext, ...) (err error)

+ func (j *JournalServer) Flush(ctx context.Context, tlfID tlf.ID) (err error)

+ func (j *JournalServer) JournalStatus(tlfID tlf.ID) (TLFJournalStatus, error)

+ func (j *JournalServer) JournalStatusWithPaths(ctx context.Context, tlfID tlf.ID, cpp chainsPathPopulator) (TLFJournalStatus, error)

+ func (j *JournalServer) PauseBackgroundWork(ctx context.Context, tlfID tlf.ID)

+ func (j *JournalServer) ResumeBackgroundWork(ctx context.Context, tlfID tlf.ID)

+ func (j *JournalServer) Status(ctx context.Context) (JournalServerStatus, []tlf.ID)

+ func (j *JournalServer) Wait(ctx context.Context, tlfID tlf.ID) (err error)

+ func (j *JournalServer) WaitForCompleteFlush(ctx context.Context, tlfID tlf.ID) (err error)

+ type JournalServerStatus struct

+ CurrentUID keybase1.UID

+ CurrentVerifyingKey kbfscrypto.VerifyingKey

+ DiskLimiterStatus interface{}

+ EnableAuto bool

+ EnableAutoSetByUser bool

+ JournalCount int

+ RootDir string

+ StoredBytes int64

+ StoredFiles int64

+ UnflushedBytes int64

+ UnflushedPaths []string

+ Version int

+ type KBFSErrorUnwrapper struct

+ func (eu KBFSErrorUnwrapper) MakeArg() interface{}

+ func (eu KBFSErrorUnwrapper) UnwrapError(arg interface{}) (appError error, dispatchError error)

+ type KBFSOps interface

+ AddFavorite func(ctx context.Context, fav Favorite) error

+ ClearPrivateFolderMD func(ctx context.Context)

+ CreateDir func(ctx context.Context, dir Node, name string) (Node, EntryInfo, error)

+ CreateFile func(ctx context.Context, dir Node, name string, isExec bool, excl Excl) (Node, EntryInfo, error)

+ CreateLink func(ctx context.Context, dir Node, fromName string, toPath string) (EntryInfo, error)

+ DeleteFavorite func(ctx context.Context, fav Favorite) error

+ FolderStatus func(ctx context.Context, folderBranch FolderBranch) (FolderBranchStatus, <-chan StatusUpdate, error)

+ ForceFastForward func(ctx context.Context)

+ GetDirChildren func(ctx context.Context, dir Node) (map[string]EntryInfo, error)

+ GetEditHistory func(ctx context.Context, folderBranch FolderBranch) (edits TlfWriterEdits, err error)

+ GetFavorites func(ctx context.Context) ([]Favorite, error)

+ GetNodeMetadata func(ctx context.Context, node Node) (NodeMetadata, error)

+ GetOrCreateRootNode func(ctx context.Context, h *TlfHandle, branch BranchName) (node Node, ei EntryInfo, err error)

+ GetRootNode func(ctx context.Context, h *TlfHandle, branch BranchName) (node Node, ei EntryInfo, err error)

+ GetTLFCryptKeys func(ctx context.Context, tlfHandle *TlfHandle) (keys []kbfscrypto.TLFCryptKey, id tlf.ID, err error)

+ GetTLFHandle func(ctx context.Context, node Node) (*TlfHandle, error)

+ GetTLFID func(ctx context.Context, tlfHandle *TlfHandle) (tlf.ID, error)

+ GetUpdateHistory func(ctx context.Context, folderBranch FolderBranch) (history TLFUpdateHistory, err error)

+ KickoffAllOutstandingRekeys func() error

+ Lookup func(ctx context.Context, dir Node, name string) (Node, EntryInfo, error)

+ PushConnectionStatusChange func(service string, newStatus error)

+ PushStatusChange func()

+ Read func(ctx context.Context, file Node, dest []byte, off int64) (int64, error)

+ RefreshCachedFavorites func(ctx context.Context)

+ RemoveDir func(ctx context.Context, dir Node, dirName string) error

+ RemoveEntry func(ctx context.Context, dir Node, name string) error

+ Rename func(ctx context.Context, oldParent Node, oldName string, newParent Node, ...) error

+ RequestRekey func(ctx context.Context, id tlf.ID)

+ SetEx func(ctx context.Context, file Node, ex bool) error

+ SetMtime func(ctx context.Context, file Node, mtime *time.Time) error

+ Shutdown func(ctx context.Context) error

+ Stat func(ctx context.Context, node Node) (EntryInfo, error)

+ Status func(ctx context.Context) (KBFSStatus, <-chan StatusUpdate, error)

+ SyncAll func(ctx context.Context, folderBranch FolderBranch) error

+ SyncFromServer func(ctx context.Context, folderBranch FolderBranch, lockBeforeGet *keybase1.LockID) error

+ TeamNameChanged func(ctx context.Context, tid keybase1.TeamID)

+ Truncate func(ctx context.Context, file Node, size uint64) error

+ UnstageForTesting func(ctx context.Context, folderBranch FolderBranch) error

+ Write func(ctx context.Context, file Node, data []byte, off int64) error

+ type KBFSOpsStandard struct

+ func NewKBFSOpsStandard(config Config) *KBFSOpsStandard

+ func (fs *KBFSOpsStandard) AddFavorite(ctx context.Context, fav Favorite) error

+ func (fs *KBFSOpsStandard) ClearPrivateFolderMD(ctx context.Context)

+ func (fs *KBFSOpsStandard) CreateDir(ctx context.Context, dir Node, name string) (Node, EntryInfo, error)

+ func (fs *KBFSOpsStandard) CreateFile(ctx context.Context, dir Node, name string, isExec bool, excl Excl) (Node, EntryInfo, error)

+ func (fs *KBFSOpsStandard) CreateLink(ctx context.Context, dir Node, fromName string, toPath string) (EntryInfo, error)

+ func (fs *KBFSOpsStandard) DeleteFavorite(ctx context.Context, fav Favorite) error

+ func (fs *KBFSOpsStandard) FolderStatus(ctx context.Context, folderBranch FolderBranch) (FolderBranchStatus, <-chan StatusUpdate, error)

+ func (fs *KBFSOpsStandard) ForceFastForward(ctx context.Context)

+ func (fs *KBFSOpsStandard) GetDirChildren(ctx context.Context, dir Node) (map[string]EntryInfo, error)

+ func (fs *KBFSOpsStandard) GetEditHistory(ctx context.Context, folderBranch FolderBranch) (edits TlfWriterEdits, err error)

+ func (fs *KBFSOpsStandard) GetFavorites(ctx context.Context) ([]Favorite, error)

+ func (fs *KBFSOpsStandard) GetNodeMetadata(ctx context.Context, node Node) (NodeMetadata, error)

+ func (fs *KBFSOpsStandard) GetOrCreateRootNode(ctx context.Context, h *TlfHandle, branch BranchName) (node Node, ei EntryInfo, err error)

+ func (fs *KBFSOpsStandard) GetRootNode(ctx context.Context, h *TlfHandle, branch BranchName) (node Node, ei EntryInfo, err error)

+ func (fs *KBFSOpsStandard) GetTLFCryptKeys(ctx context.Context, tlfHandle *TlfHandle) (keys []kbfscrypto.TLFCryptKey, id tlf.ID, err error)

+ func (fs *KBFSOpsStandard) GetTLFHandle(ctx context.Context, node Node) (*TlfHandle, error)

+ func (fs *KBFSOpsStandard) GetTLFID(ctx context.Context, tlfHandle *TlfHandle) (id tlf.ID, err error)

+ func (fs *KBFSOpsStandard) GetUpdateHistory(ctx context.Context, folderBranch FolderBranch) (history TLFUpdateHistory, err error)

+ func (fs *KBFSOpsStandard) KickoffAllOutstandingRekeys() error

+ func (fs *KBFSOpsStandard) Lookup(ctx context.Context, dir Node, name string) (Node, EntryInfo, error)

+ func (fs *KBFSOpsStandard) PushConnectionStatusChange(service string, newStatus error)

+ func (fs *KBFSOpsStandard) PushStatusChange()

+ func (fs *KBFSOpsStandard) Read(ctx context.Context, file Node, dest []byte, off int64) (numRead int64, err error)

+ func (fs *KBFSOpsStandard) RefreshCachedFavorites(ctx context.Context)

+ func (fs *KBFSOpsStandard) RegisterForChanges(folderBranches []FolderBranch, obs Observer) error

+ func (fs *KBFSOpsStandard) RemoveDir(ctx context.Context, dir Node, name string) error

+ func (fs *KBFSOpsStandard) RemoveEntry(ctx context.Context, dir Node, name string) error

+ func (fs *KBFSOpsStandard) Rename(ctx context.Context, oldParent Node, oldName string, newParent Node, ...) error

+ func (fs *KBFSOpsStandard) RequestRekey(ctx context.Context, id tlf.ID)

+ func (fs *KBFSOpsStandard) SetEx(ctx context.Context, file Node, ex bool) error

+ func (fs *KBFSOpsStandard) SetMtime(ctx context.Context, file Node, mtime *time.Time) error

+ func (fs *KBFSOpsStandard) Shutdown(ctx context.Context) error

+ func (fs *KBFSOpsStandard) Stat(ctx context.Context, node Node) (EntryInfo, error)

+ func (fs *KBFSOpsStandard) Status(ctx context.Context) (KBFSStatus, <-chan StatusUpdate, error)

+ func (fs *KBFSOpsStandard) SyncAll(ctx context.Context, folderBranch FolderBranch) error

+ func (fs *KBFSOpsStandard) SyncFromServer(ctx context.Context, folderBranch FolderBranch, lockBeforeGet *keybase1.LockID) error

+ func (fs *KBFSOpsStandard) TeamNameChanged(ctx context.Context, tid keybase1.TeamID)

+ func (fs *KBFSOpsStandard) Truncate(ctx context.Context, file Node, size uint64) error

+ func (fs *KBFSOpsStandard) UnregisterFromChanges(folderBranches []FolderBranch, obs Observer) error

+ func (fs *KBFSOpsStandard) UnstageForTesting(ctx context.Context, folderBranch FolderBranch) error

+ func (fs *KBFSOpsStandard) Write(ctx context.Context, file Node, data []byte, off int64) error

+ type KBFSService struct

+ func NewKBFSService(kbCtx Context, config kbfsServiceConfig) (*KBFSService, error)

+ func (k *KBFSService) Run(l net.Listener)

+ func (k *KBFSService) Shutdown()

+ type KBFSStatus struct

+ CurrentUser string

+ DiskCacheStatus map[string]DiskBlockCacheStatus

+ FailingServices map[string]error

+ GitLimitBytes int64

+ GitUsageBytes int64

+ IsConnected bool

+ JournalServer *JournalServerStatus

+ LimitBytes int64

+ UsageBytes int64

+ type KBPKI interface

+ CreateTeamTLF func(ctx context.Context, teamID keybase1.TeamID, tlfID tlf.ID) error

+ FavoriteAdd func(ctx context.Context, folder keybase1.Folder) error

+ FavoriteDelete func(ctx context.Context, folder keybase1.Folder) error

+ FavoriteList func(ctx context.Context) ([]keybase1.Folder, error)

+ GetCryptPublicKeys func(ctx context.Context, uid keybase1.UID) ([]kbfscrypto.CryptPublicKey, error)

+ HasUnverifiedVerifyingKey func(ctx context.Context, uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey) error

+ HasVerifyingKey func(ctx context.Context, uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey, ...) error

+ Notify func(ctx context.Context, notification *keybase1.FSNotification) error

+ type KBPKIClient struct

+ func NewKBPKIClient(serviceOwner keybaseServiceOwner, log logger.Logger) *KBPKIClient

+ func (k *KBPKIClient) CreateTeamTLF(ctx context.Context, teamID keybase1.TeamID, tlfID tlf.ID) error

+ func (k *KBPKIClient) FavoriteAdd(ctx context.Context, folder keybase1.Folder) error

+ func (k *KBPKIClient) FavoriteDelete(ctx context.Context, folder keybase1.Folder) error

+ func (k *KBPKIClient) FavoriteList(ctx context.Context) ([]keybase1.Folder, error)

+ func (k *KBPKIClient) GetCryptPublicKeys(ctx context.Context, uid keybase1.UID) (keys []kbfscrypto.CryptPublicKey, err error)

+ func (k *KBPKIClient) GetCurrentMerkleRoot(ctx context.Context) (keybase1.MerkleRootV2, error)

+ func (k *KBPKIClient) GetCurrentSession(ctx context.Context) (SessionInfo, error)

+ func (k *KBPKIClient) GetNormalizedUsername(ctx context.Context, id keybase1.UserOrTeamID) (libkb.NormalizedUsername, error)

+ func (k *KBPKIClient) GetTeamRootID(ctx context.Context, tid keybase1.TeamID) (keybase1.TeamID, error)

+ func (k *KBPKIClient) GetTeamTLFCryptKeys(ctx context.Context, tid keybase1.TeamID, desiredKeyGen kbfsmd.KeyGen) (map[kbfsmd.KeyGen]kbfscrypto.TLFCryptKey, kbfsmd.KeyGen, error)

+ func (k *KBPKIClient) HasUnverifiedVerifyingKey(ctx context.Context, uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey) error

+ func (k *KBPKIClient) HasVerifyingKey(ctx context.Context, uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey, ...) error

+ func (k *KBPKIClient) Identify(ctx context.Context, assertion, reason string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ func (k *KBPKIClient) IdentifyImplicitTeam(ctx context.Context, assertions, suffix string, tlfType tlf.Type, ...) (ImplicitTeamInfo, error)

+ func (k *KBPKIClient) IsTeamReader(ctx context.Context, tid keybase1.TeamID, uid keybase1.UID) (bool, error)

+ func (k *KBPKIClient) IsTeamWriter(ctx context.Context, tid keybase1.TeamID, uid keybase1.UID, ...) (bool, error)

+ func (k *KBPKIClient) Notify(ctx context.Context, notification *keybase1.FSNotification) error

+ func (k *KBPKIClient) PutGitMetadata(ctx context.Context, folder keybase1.Folder, repoID keybase1.RepoID, ...) error

+ func (k *KBPKIClient) Resolve(ctx context.Context, assertion string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ func (k *KBPKIClient) ResolveImplicitTeam(ctx context.Context, assertions, suffix string, tlfType tlf.Type) (ImplicitTeamInfo, error)

+ func (k *KBPKIClient) ResolveImplicitTeamByID(ctx context.Context, teamID keybase1.TeamID, tlfType tlf.Type) (ImplicitTeamInfo, error)

+ func (k *KBPKIClient) ResolveTeamTLFID(ctx context.Context, teamID keybase1.TeamID) (tlf.ID, error)

+ type KeyBundleCacheMeasured struct

+ func NewKeyBundleCacheMeasured(delegate kbfsmd.KeyBundleCache, r metrics.Registry) KeyBundleCacheMeasured

+ func (b KeyBundleCacheMeasured) GetTLFReaderKeyBundle(bundleID kbfsmd.TLFReaderKeyBundleID) (rkb *kbfsmd.TLFReaderKeyBundleV3, err error)

+ func (b KeyBundleCacheMeasured) GetTLFWriterKeyBundle(bundleID kbfsmd.TLFWriterKeyBundleID) (wkb *kbfsmd.TLFWriterKeyBundleV3, err error)

+ func (b KeyBundleCacheMeasured) PutTLFReaderKeyBundle(bundleID kbfsmd.TLFReaderKeyBundleID, rkb kbfsmd.TLFReaderKeyBundleV3)

+ func (b KeyBundleCacheMeasured) PutTLFWriterKeyBundle(bundleID kbfsmd.TLFWriterKeyBundleID, wkb kbfsmd.TLFWriterKeyBundleV3)

+ type KeyCache interface

+ GetTLFCryptKey func(tlf.ID, kbfsmd.KeyGen) (kbfscrypto.TLFCryptKey, error)

+ PutTLFCryptKey func(tlf.ID, kbfsmd.KeyGen, kbfscrypto.TLFCryptKey) error

+ type KeyCacheHitError struct

+ func (e KeyCacheHitError) Error() string

+ type KeyCacheMeasured struct

+ func NewKeyCacheMeasured(delegate KeyCache, r metrics.Registry) KeyCacheMeasured

+ func (b KeyCacheMeasured) GetTLFCryptKey(tlfID tlf.ID, keyGen kbfsmd.KeyGen) (key kbfscrypto.TLFCryptKey, err error)

+ func (b KeyCacheMeasured) PutTLFCryptKey(tlfID tlf.ID, keyGen kbfsmd.KeyGen, key kbfscrypto.TLFCryptKey) (err error)

+ type KeyCacheMissError struct

+ func (e KeyCacheMissError) Error() string

+ type KeyCacheStandard struct

+ func NewKeyCacheStandard(capacity int) *KeyCacheStandard

+ func (k *KeyCacheStandard) GetTLFCryptKey(tlf tlf.ID, keyGen kbfsmd.KeyGen) (kbfscrypto.TLFCryptKey, error)

+ func (k *KeyCacheStandard) PutTLFCryptKey(tlf tlf.ID, keyGen kbfsmd.KeyGen, key kbfscrypto.TLFCryptKey) error

+ type KeyHalfMismatchError struct

+ Actual kbfscrypto.TLFCryptKeyServerHalfID

+ Expected kbfscrypto.TLFCryptKeyServerHalfID

+ func (e KeyHalfMismatchError) Error() string

+ type KeyManager interface

+ GetTLFCryptKeyOfAllGenerations func(ctx context.Context, kmd KeyMetadata) (keys []kbfscrypto.TLFCryptKey, err error)

+ Rekey func(ctx context.Context, md *RootMetadata, promptPaper bool) (bool, *kbfscrypto.TLFCryptKey, error)

+ type KeyManagerStandard struct

+ func NewKeyManagerStandard(config Config) *KeyManagerStandard

+ func (km *KeyManagerStandard) GetTLFCryptKeyForBlockDecryption(ctx context.Context, kmd KeyMetadata, blockPtr BlockPointer) (tlfCryptKey kbfscrypto.TLFCryptKey, err error)

+ func (km *KeyManagerStandard) GetTLFCryptKeyForEncryption(ctx context.Context, kmd KeyMetadata) (tlfCryptKey kbfscrypto.TLFCryptKey, err error)

+ func (km *KeyManagerStandard) GetTLFCryptKeyForMDDecryption(ctx context.Context, kmdToDecrypt, kmdWithKeys KeyMetadata) (tlfCryptKey kbfscrypto.TLFCryptKey, err error)

+ func (km *KeyManagerStandard) GetTLFCryptKeyOfAllGenerations(ctx context.Context, kmd KeyMetadata) (keys []kbfscrypto.TLFCryptKey, err error)

+ func (km *KeyManagerStandard) Rekey(ctx context.Context, md *RootMetadata, promptPaper bool) (mdChanged bool, cryptKey *kbfscrypto.TLFCryptKey, err error)

+ type KeyMetadata interface

+ GetHistoricTLFCryptKey func(codec kbfscodec.Codec, keyGen kbfsmd.KeyGen, currentKey kbfscrypto.TLFCryptKey) (kbfscrypto.TLFCryptKey, error)

+ GetTLFCryptKeyParams func(keyGen kbfsmd.KeyGen, user keybase1.UID, key kbfscrypto.CryptPublicKey) (kbfscrypto.TLFEphemeralPublicKey, kbfscrypto.EncryptedTLFCryptKeyClientHalf, ...)

+ GetTlfHandle func() *TlfHandle

+ HasKeyForUser func(user keybase1.UID) (bool, error)

+ IsWriter func(ctx context.Context, checker kbfsmd.TeamMembershipChecker, uid keybase1.UID, ...) (bool, error)

+ LatestKeyGeneration func() kbfsmd.KeyGen

+ StoresHistoricTLFCryptKeys func() bool

+ TlfID func() tlf.ID

+ TypeForKeying func() tlf.KeyingType

+ type KeyOps interface

+ DeleteTLFCryptKeyServerHalf func(ctx context.Context, uid keybase1.UID, key kbfscrypto.CryptPublicKey, ...) error

+ GetTLFCryptKeyServerHalf func(ctx context.Context, serverHalfID kbfscrypto.TLFCryptKeyServerHalfID, ...) (kbfscrypto.TLFCryptKeyServerHalf, error)

+ PutTLFCryptKeyServerHalves func(ctx context.Context, keyServerHalves kbfsmd.UserDeviceKeyServerHalves) error

+ type KeyOpsStandard struct

+ func (k *KeyOpsStandard) DeleteTLFCryptKeyServerHalf(ctx context.Context, uid keybase1.UID, key kbfscrypto.CryptPublicKey, ...) error

+ func (k *KeyOpsStandard) GetTLFCryptKeyServerHalf(ctx context.Context, serverHalfID kbfscrypto.TLFCryptKeyServerHalfID, ...) (kbfscrypto.TLFCryptKeyServerHalf, error)

+ func (k *KeyOpsStandard) PutTLFCryptKeyServerHalves(ctx context.Context, keyServerHalves kbfsmd.UserDeviceKeyServerHalves) error

+ type KeyServer interface

+ DeleteTLFCryptKeyServerHalf func(ctx context.Context, uid keybase1.UID, key kbfscrypto.CryptPublicKey, ...) error

+ GetTLFCryptKeyServerHalf func(ctx context.Context, serverHalfID kbfscrypto.TLFCryptKeyServerHalfID, ...) (kbfscrypto.TLFCryptKeyServerHalf, error)

+ PutTLFCryptKeyServerHalves func(ctx context.Context, keyServerHalves kbfsmd.UserDeviceKeyServerHalves) error

+ Shutdown func()

+ type KeyServerLocal struct

+ func NewKeyServerDir(config Config, dirPath string) (*KeyServerLocal, error)

+ func NewKeyServerMemory(config Config) (*KeyServerLocal, error)

+ func NewKeyServerTempDir(config Config) (*KeyServerLocal, error)

+ func (ks *KeyServerLocal) DeleteTLFCryptKeyServerHalf(ctx context.Context, _ keybase1.UID, _ kbfscrypto.CryptPublicKey, ...) error

+ func (ks *KeyServerLocal) GetTLFCryptKeyServerHalf(ctx context.Context, serverHalfID kbfscrypto.TLFCryptKeyServerHalfID, ...) (serverHalf kbfscrypto.TLFCryptKeyServerHalf, err error)

+ func (ks *KeyServerLocal) PutTLFCryptKeyServerHalves(ctx context.Context, keyServerHalves kbfsmd.UserDeviceKeyServerHalves) error

+ func (ks *KeyServerLocal) Shutdown()

+ type KeyServerMeasured struct

+ func NewKeyServerMeasured(delegate KeyServer, r metrics.Registry) KeyServerMeasured

+ func (b KeyServerMeasured) DeleteTLFCryptKeyServerHalf(ctx context.Context, uid keybase1.UID, key kbfscrypto.CryptPublicKey, ...) (err error)

+ func (b KeyServerMeasured) GetTLFCryptKeyServerHalf(ctx context.Context, serverHalfID kbfscrypto.TLFCryptKeyServerHalfID, ...) (serverHalf kbfscrypto.TLFCryptKeyServerHalf, err error)

+ func (b KeyServerMeasured) PutTLFCryptKeyServerHalves(ctx context.Context, keyServerHalves kbfsmd.UserDeviceKeyServerHalves) (err error)

+ func (b KeyServerMeasured) Shutdown()

+ type KeybaseDaemonLocal struct

+ func NewKeybaseDaemonDisk(currentUID keybase1.UID, users []LocalUser, teams []TeamInfo, favDBFile string, ...) (*KeybaseDaemonLocal, error)

+ func NewKeybaseDaemonMemory(currentUID keybase1.UID, users []LocalUser, teams []TeamInfo, ...) *KeybaseDaemonLocal

+ func (k *KeybaseDaemonLocal) CreateTeamTLF(ctx context.Context, teamID keybase1.TeamID, tlfID tlf.ID) (err error)

+ func (k *KeybaseDaemonLocal) CurrentSession(ctx context.Context, sessionID int) (SessionInfo, error)

+ func (k *KeybaseDaemonLocal) EstablishMountDir(ctx context.Context) (string, error)

+ func (k *KeybaseDaemonLocal) FavoriteAdd(ctx context.Context, folder keybase1.Folder) error

+ func (k *KeybaseDaemonLocal) FavoriteDelete(ctx context.Context, folder keybase1.Folder) error

+ func (k *KeybaseDaemonLocal) FavoriteList(ctx context.Context, sessionID int) ([]keybase1.Folder, error)

+ func (k *KeybaseDaemonLocal) FlushUserFromLocalCache(ctx context.Context, uid keybase1.UID)

+ func (k *KeybaseDaemonLocal) FlushUserUnverifiedKeysFromLocalCache(ctx context.Context, uid keybase1.UID)

+ func (k *KeybaseDaemonLocal) GetCurrentMerkleRoot(ctx context.Context) (keybase1.MerkleRootV2, error)

+ func (k *KeybaseDaemonLocal) GetTeamSettings(ctx context.Context, teamID keybase1.TeamID) (settings keybase1.KBFSTeamSettings, err error)

+ func (k *KeybaseDaemonLocal) Identify(ctx context.Context, assertion, _ string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ func (k *KeybaseDaemonLocal) LoadTeamPlusKeys(ctx context.Context, tid keybase1.TeamID, _ kbfsmd.KeyGen, ...) (TeamInfo, error)

+ func (k *KeybaseDaemonLocal) LoadUnverifiedKeys(ctx context.Context, uid keybase1.UID) ([]keybase1.PublicKey, error)

+ func (k *KeybaseDaemonLocal) LoadUserPlusKeys(ctx context.Context, uid keybase1.UID, _ keybase1.KID) (UserInfo, error)

+ func (k *KeybaseDaemonLocal) Notify(ctx context.Context, notification *keybase1.FSNotification) error

+ func (k *KeybaseDaemonLocal) NotifySyncStatus(ctx context.Context, _ *keybase1.FSPathSyncStatus) error

+ func (k *KeybaseDaemonLocal) PutGitMetadata(ctx context.Context, folder keybase1.Folder, repoID keybase1.RepoID, ...) error

+ func (k *KeybaseDaemonLocal) Resolve(ctx context.Context, assertion string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ func (k *KeybaseDaemonLocal) ResolveIdentifyImplicitTeam(ctx context.Context, assertions, suffix string, tlfType tlf.Type, ...) (ImplicitTeamInfo, error)

+ func (k *KeybaseDaemonLocal) ResolveImplicitTeamByID(ctx context.Context, teamID keybase1.TeamID) (name string, err error)

+ func (k *KeybaseDaemonLocal) Shutdown()

+ type KeybaseDaemonRPC struct

+ func NewKeybaseDaemonRPC(config Config, kbCtx Context, log logger.Logger, debug bool, ...) *KeybaseDaemonRPC

+ func (*KeybaseDaemonRPC) HandlerName() string

+ func (k *KeybaseDaemonRPC) AddProtocols(protocols []rpc.Protocol)

+ func (k *KeybaseDaemonRPC) OnConnect(ctx context.Context, conn *rpc.Connection, rawClient rpc.GenericClient, ...) error

+ func (k *KeybaseDaemonRPC) OnConnectError(err error, wait time.Duration)

+ func (k *KeybaseDaemonRPC) OnDisconnected(_ context.Context, status rpc.DisconnectStatus)

+ func (k *KeybaseDaemonRPC) OnDoCommandError(err error, wait time.Duration)

+ func (k *KeybaseDaemonRPC) ShouldRetry(rpcName string, err error) bool

+ func (k *KeybaseDaemonRPC) ShouldRetryOnConnect(err error) bool

+ func (k *KeybaseDaemonRPC) Shutdown()

+ func (k *KeybaseDaemonRPC) TeamAbandoned(context.Context, keybase1.TeamID) error

+ func (k *KeybaseDaemonRPC) TeamExit(context.Context, keybase1.TeamID) error

+ type KeybaseService interface

+ CreateTeamTLF func(ctx context.Context, teamID keybase1.TeamID, tlfID tlf.ID) error

+ CurrentSession func(ctx context.Context, sessionID int) (SessionInfo, error)

+ EstablishMountDir func(ctx context.Context) (string, error)

+ FavoriteAdd func(ctx context.Context, folder keybase1.Folder) error

+ FavoriteDelete func(ctx context.Context, folder keybase1.Folder) error

+ FavoriteList func(ctx context.Context, sessionID int) ([]keybase1.Folder, error)

+ FlushUserFromLocalCache func(ctx context.Context, uid keybase1.UID)

+ FlushUserUnverifiedKeysFromLocalCache func(ctx context.Context, uid keybase1.UID)

+ GetTeamSettings func(ctx context.Context, teamID keybase1.TeamID) (keybase1.KBFSTeamSettings, error)

+ Identify func(ctx context.Context, assertion, reason string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ LoadTeamPlusKeys func(ctx context.Context, tid keybase1.TeamID, desiredKeyGen kbfsmd.KeyGen, ...) (TeamInfo, error)

+ LoadUnverifiedKeys func(ctx context.Context, uid keybase1.UID) ([]keybase1.PublicKey, error)

+ LoadUserPlusKeys func(ctx context.Context, uid keybase1.UID, pollForKID keybase1.KID) (UserInfo, error)

+ Notify func(ctx context.Context, notification *keybase1.FSNotification) error

+ NotifySyncStatus func(ctx context.Context, status *keybase1.FSPathSyncStatus) error

+ Resolve func(ctx context.Context, assertion string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ ResolveIdentifyImplicitTeam func(ctx context.Context, assertions, suffix string, tlfType tlf.Type, ...) (ImplicitTeamInfo, error)

+ ResolveImplicitTeamByID func(ctx context.Context, teamID keybase1.TeamID) (string, error)

+ Shutdown func()

+ type KeybaseServiceBase struct

+ func NewKeybaseServiceBase(config Config, kbCtx Context, log logger.Logger) *KeybaseServiceBase

+ func (k *KeybaseServiceBase) CheckReachability(ctx context.Context) (res keybase1.Reachability, err error)

+ func (k *KeybaseServiceBase) ClientOutOfDate(ctx context.Context, arg keybase1.ClientOutOfDateArg) error

+ func (k *KeybaseServiceBase) CreateTeamTLF(ctx context.Context, teamID keybase1.TeamID, tlfID tlf.ID) (err error)

+ func (k *KeybaseServiceBase) CurrentSession(ctx context.Context, sessionID int) (SessionInfo, error)

+ func (k *KeybaseServiceBase) EstablishMountDir(ctx context.Context) (string, error)

+ func (k *KeybaseServiceBase) FSEditListRequest(ctx context.Context, req keybase1.FSEditListRequest) (err error)

+ func (k *KeybaseServiceBase) FSSyncStatusRequest(ctx context.Context, req keybase1.FSSyncStatusRequest) (err error)

+ func (k *KeybaseServiceBase) FavoriteAdd(ctx context.Context, folder keybase1.Folder) error

+ func (k *KeybaseServiceBase) FavoriteDelete(ctx context.Context, folder keybase1.Folder) error

+ func (k *KeybaseServiceBase) FavoriteList(ctx context.Context, sessionID int) ([]keybase1.Folder, error)

+ func (k *KeybaseServiceBase) FillClients(identifyClient keybase1.IdentifyInterface, userClient keybase1.UserInterface, ...)

+ func (k *KeybaseServiceBase) FlushUserFromLocalCache(ctx context.Context, uid keybase1.UID)

+ func (k *KeybaseServiceBase) FlushUserUnverifiedKeysFromLocalCache(ctx context.Context, uid keybase1.UID)

+ func (k *KeybaseServiceBase) GetCurrentMerkleRoot(ctx context.Context) (keybase1.MerkleRootV2, error)

+ func (k *KeybaseServiceBase) GetPublicCanonicalTLFNameAndID(ctx context.Context, query keybase1.TLFQuery) (res keybase1.CanonicalTLFNameAndIDWithBreaks, err error)

+ func (k *KeybaseServiceBase) GetTLFCryptKeys(ctx context.Context, query keybase1.TLFQuery) (res keybase1.GetTLFCryptKeysRes, err error)

+ func (k *KeybaseServiceBase) GetTeamSettings(ctx context.Context, teamID keybase1.TeamID) (keybase1.KBFSTeamSettings, error)

+ func (k *KeybaseServiceBase) Identify(ctx context.Context, assertion, reason string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ func (k *KeybaseServiceBase) KeyfamilyChanged(ctx context.Context, uid keybase1.UID) error

+ func (k *KeybaseServiceBase) LoadTeamPlusKeys(ctx context.Context, tid keybase1.TeamID, desiredKeyGen kbfsmd.KeyGen, ...) (TeamInfo, error)

+ func (k *KeybaseServiceBase) LoadUnverifiedKeys(ctx context.Context, uid keybase1.UID) ([]keybase1.PublicKey, error)

+ func (k *KeybaseServiceBase) LoadUserPlusKeys(ctx context.Context, uid keybase1.UID, pollForKID keybase1.KID) (UserInfo, error)

+ func (k *KeybaseServiceBase) LoggedIn(ctx context.Context, name string) error

+ func (k *KeybaseServiceBase) LoggedOut(ctx context.Context) error

+ func (k *KeybaseServiceBase) Notify(ctx context.Context, notification *keybase1.FSNotification) error

+ func (k *KeybaseServiceBase) NotifySyncStatus(ctx context.Context, status *keybase1.FSPathSyncStatus) error

+ func (k *KeybaseServiceBase) PaperKeyCached(ctx context.Context, arg keybase1.PaperKeyCachedArg) error

+ func (k *KeybaseServiceBase) PutGitMetadata(ctx context.Context, folder keybase1.Folder, repoID keybase1.RepoID, ...) error

+ func (k *KeybaseServiceBase) ReachabilityChanged(ctx context.Context, reachability keybase1.Reachability) error

+ func (k *KeybaseServiceBase) Resolve(ctx context.Context, assertion string) (libkb.NormalizedUsername, keybase1.UserOrTeamID, error)

+ func (k *KeybaseServiceBase) ResolveIdentifyImplicitTeam(ctx context.Context, assertions, suffix string, tlfType tlf.Type, ...) (ImplicitTeamInfo, error)

+ func (k *KeybaseServiceBase) ResolveImplicitTeamByID(ctx context.Context, teamID keybase1.TeamID) (name string, err error)

+ func (k *KeybaseServiceBase) StartMigration(ctx context.Context, folder keybase1.Folder) (err error)

+ func (k *KeybaseServiceBase) StartReachability(ctx context.Context) (res keybase1.Reachability, err error)

+ func (k *KeybaseServiceBase) TeamChangedByID(ctx context.Context, arg keybase1.TeamChangedByIDArg) error

+ func (k *KeybaseServiceBase) TeamChangedByName(ctx context.Context, arg keybase1.TeamChangedByNameArg) error

+ func (k *KeybaseServiceBase) TeamDeleted(ctx context.Context, teamID keybase1.TeamID) error

+ type KeybaseServiceCn interface

+ NewCrypto func(config Config, params InitParams, ctx Context, log logger.Logger) (Crypto, error)

+ NewKeybaseService func(config Config, params InitParams, ctx Context, log logger.Logger) (KeybaseService, error)

+ type KeybaseServiceMeasured struct

+ func NewKeybaseServiceMeasured(delegate KeybaseService, r metrics.Registry) KeybaseServiceMeasured

+ func (k KeybaseServiceMeasured) CreateTeamTLF(ctx context.Context, teamID keybase1.TeamID, tlfID tlf.ID) (err error)

+ func (k KeybaseServiceMeasured) CurrentSession(ctx context.Context, sessionID int) (sessionInfo SessionInfo, err error)

+ func (k KeybaseServiceMeasured) EstablishMountDir(ctx context.Context) (string, error)

+ func (k KeybaseServiceMeasured) FavoriteAdd(ctx context.Context, folder keybase1.Folder) (err error)

+ func (k KeybaseServiceMeasured) FavoriteDelete(ctx context.Context, folder keybase1.Folder) (err error)

+ func (k KeybaseServiceMeasured) FavoriteList(ctx context.Context, sessionID int) (favorites []keybase1.Folder, err error)

+ func (k KeybaseServiceMeasured) FlushUserFromLocalCache(ctx context.Context, uid keybase1.UID)

+ func (k KeybaseServiceMeasured) FlushUserUnverifiedKeysFromLocalCache(ctx context.Context, uid keybase1.UID)

+ func (k KeybaseServiceMeasured) GetCurrentMerkleRoot(ctx context.Context) (root keybase1.MerkleRootV2, err error)

+ func (k KeybaseServiceMeasured) GetTeamSettings(ctx context.Context, teamID keybase1.TeamID) (settings keybase1.KBFSTeamSettings, err error)

+ func (k KeybaseServiceMeasured) Identify(ctx context.Context, assertion, reason string) (name libkb.NormalizedUsername, id keybase1.UserOrTeamID, err error)

+ func (k KeybaseServiceMeasured) LoadTeamPlusKeys(ctx context.Context, tid keybase1.TeamID, desiredKeyGen kbfsmd.KeyGen, ...) (teamInfo TeamInfo, err error)

+ func (k KeybaseServiceMeasured) LoadUnverifiedKeys(ctx context.Context, uid keybase1.UID) (keys []keybase1.PublicKey, err error)

+ func (k KeybaseServiceMeasured) LoadUserPlusKeys(ctx context.Context, uid keybase1.UID, pollForKID keybase1.KID) (userInfo UserInfo, err error)

+ func (k KeybaseServiceMeasured) Notify(ctx context.Context, notification *keybase1.FSNotification) (err error)

+ func (k KeybaseServiceMeasured) NotifySyncStatus(ctx context.Context, status *keybase1.FSPathSyncStatus) (err error)

+ func (k KeybaseServiceMeasured) PutGitMetadata(ctx context.Context, folder keybase1.Folder, repoID keybase1.RepoID, ...) (err error)

+ func (k KeybaseServiceMeasured) Resolve(ctx context.Context, assertion string) (name libkb.NormalizedUsername, uid keybase1.UserOrTeamID, err error)

+ func (k KeybaseServiceMeasured) ResolveIdentifyImplicitTeam(ctx context.Context, assertions, suffix string, tlfType tlf.Type, ...) (info ImplicitTeamInfo, err error)

+ func (k KeybaseServiceMeasured) ResolveImplicitTeamByID(ctx context.Context, teamID keybase1.TeamID) (name string, err error)

+ func (k KeybaseServiceMeasured) Shutdown()

+ type LocalUser struct

+ Asserts []string

+ CurrentCryptPublicKeyIndex int

+ CurrentVerifyingKeyIndex int

+ UnverifiedKeys []keybase1.PublicKey

+ func MakeLocalUsers(users []libkb.NormalizedUsername) []LocalUser

+ func (lu *LocalUser) GetCurrentCryptPublicKey() kbfscrypto.CryptPublicKey

+ func (lu *LocalUser) GetCurrentVerifyingKey() kbfscrypto.VerifyingKey

+ func (lu *LocalUser) GetPublicKeys() []keybase1.PublicKey

+ type MDCache interface

+ ChangeHandleForID func(oldHandle *TlfHandle, newHandle *TlfHandle)

+ Delete func(tlf tlf.ID, rev kbfsmd.Revision, bid kbfsmd.BranchID)

+ Get func(tlf tlf.ID, rev kbfsmd.Revision, bid kbfsmd.BranchID) (ImmutableRootMetadata, error)

+ GetIDForHandle func(handle *TlfHandle) (tlf.ID, error)

+ MarkPutToServer func(tlf tlf.ID, rev kbfsmd.Revision, bid kbfsmd.BranchID)

+ Put func(md ImmutableRootMetadata) error

+ PutIDForHandle func(handle *TlfHandle, id tlf.ID) error

+ Replace func(newRmd ImmutableRootMetadata, oldBID kbfsmd.BranchID) error

+ type MDCacheStandard struct

+ func NewMDCacheStandard(capacity int) *MDCacheStandard

+ func (md *MDCacheStandard) ChangeHandleForID(oldHandle *TlfHandle, newHandle *TlfHandle)

+ func (md *MDCacheStandard) Delete(tlf tlf.ID, rev kbfsmd.Revision, bid kbfsmd.BranchID)

+ func (md *MDCacheStandard) Get(tlf tlf.ID, rev kbfsmd.Revision, bid kbfsmd.BranchID) (ImmutableRootMetadata, error)

+ func (md *MDCacheStandard) GetIDForHandle(handle *TlfHandle) (tlf.ID, error)

+ func (md *MDCacheStandard) MarkPutToServer(tlf tlf.ID, rev kbfsmd.Revision, bid kbfsmd.BranchID)

+ func (md *MDCacheStandard) Put(rmd ImmutableRootMetadata) error

+ func (md *MDCacheStandard) PutIDForHandle(handle *TlfHandle, id tlf.ID) error

+ func (md *MDCacheStandard) Replace(newRmd ImmutableRootMetadata, oldBID kbfsmd.BranchID) error

+ type MDJournalConflictError struct

+ func (e MDJournalConflictError) Error() string

+ type MDMismatchError struct

+ Dir string

+ Err error

+ Revision kbfsmd.Revision

+ TlfID tlf.ID

+ func (e MDMismatchError) Error() string

+ type MDOps interface

+ GetForTLF func(ctx context.Context, id tlf.ID, lockBeforeGet *keybase1.LockID) (ImmutableRootMetadata, error)

+ GetLatestHandleForTLF func(ctx context.Context, id tlf.ID) (tlf.Handle, error)

+ GetRange func(ctx context.Context, id tlf.ID, start, stop kbfsmd.Revision, ...) ([]ImmutableRootMetadata, error)

+ GetUnmergedForTLF func(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) (ImmutableRootMetadata, error)

+ GetUnmergedRange func(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) ([]ImmutableRootMetadata, error)

+ PruneBranch func(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) error

+ Put func(ctx context.Context, rmd *RootMetadata, verifyingKey kbfscrypto.VerifyingKey, ...) (ImmutableRootMetadata, error)

+ PutUnmerged func(ctx context.Context, rmd *RootMetadata, verifyingKey kbfscrypto.VerifyingKey) (ImmutableRootMetadata, error)

+ ResolveBranch func(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) (ImmutableRootMetadata, error)

+ type MDOpsStandard struct

+ func NewMDOpsStandard(config Config) *MDOpsStandard

+ func (md *MDOpsStandard) GetForTLF(ctx context.Context, id tlf.ID, lockBeforeGet *keybase1.LockID) (ImmutableRootMetadata, error)

+ func (md *MDOpsStandard) GetIDForHandle(ctx context.Context, handle *TlfHandle) (id tlf.ID, err error)

+ func (md *MDOpsStandard) GetLatestHandleForTLF(ctx context.Context, id tlf.ID) (tlf.Handle, error)

+ func (md *MDOpsStandard) GetRange(ctx context.Context, id tlf.ID, start, stop kbfsmd.Revision, ...) ([]ImmutableRootMetadata, error)

+ func (md *MDOpsStandard) GetUnmergedForTLF(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) (ImmutableRootMetadata, error)

+ func (md *MDOpsStandard) GetUnmergedRange(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) ([]ImmutableRootMetadata, error)

+ func (md *MDOpsStandard) PruneBranch(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) error

+ func (md *MDOpsStandard) Put(ctx context.Context, rmd *RootMetadata, verifyingKey kbfscrypto.VerifyingKey, ...) (ImmutableRootMetadata, error)

+ func (md *MDOpsStandard) PutUnmerged(ctx context.Context, rmd *RootMetadata, verifyingKey kbfscrypto.VerifyingKey) (ImmutableRootMetadata, error)

+ func (md *MDOpsStandard) ResolveBranch(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, _ []kbfsblock.ID, ...) (ImmutableRootMetadata, error)

+ type MDServer interface

+ CancelRegistration func(ctx context.Context, id tlf.ID)

+ CheckForRekeys func(ctx context.Context) <-chan error

+ CheckReachability func(ctx context.Context)

+ DisableRekeyUpdatesForTesting func()

+ FastForwardBackoff func()

+ GetForHandle func(ctx context.Context, handle tlf.Handle, mStatus kbfsmd.MergeStatus, ...) (tlf.ID, *RootMetadataSigned, error)

+ GetForTLF func(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) (*RootMetadataSigned, error)

+ GetKeyBundles func(ctx context.Context, tlfID tlf.ID, wkbID kbfsmd.TLFWriterKeyBundleID, ...) (*kbfsmd.TLFWriterKeyBundleV3, *kbfsmd.TLFReaderKeyBundleV3, error)

+ GetLatestHandleForTLF func(ctx context.Context, id tlf.ID) (tlf.Handle, error)

+ GetRange func(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) ([]*RootMetadataSigned, error)

+ IsConnected func() bool

+ Lock func(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ OffsetFromServerTime func() (time.Duration, bool)

+ PruneBranch func(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) error

+ Put func(ctx context.Context, rmds *RootMetadataSigned, extra kbfsmd.ExtraMetadata, ...) error

+ RegisterForUpdate func(ctx context.Context, id tlf.ID, currHead kbfsmd.Revision) (<-chan error, error)

+ ReleaseLock func(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ Shutdown func()

+ StartImplicitTeamMigration func(ctx context.Context, id tlf.ID) (err error)

+ TruncateLock func(ctx context.Context, id tlf.ID) (bool, error)

+ TruncateUnlock func(ctx context.Context, id tlf.ID) (bool, error)

+ type MDServerDisconnected struct

+ func (e MDServerDisconnected) Error() string

+ type MDServerDisk struct

+ func NewMDServerDir(config mdServerLocalConfig, dirPath string) (*MDServerDisk, error)

+ func NewMDServerTempDir(config mdServerLocalConfig) (*MDServerDisk, error)

+ func (*MDServerDisk) Lock(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ func (*MDServerDisk) ReleaseLock(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ func (md *MDServerDisk) CancelRegistration(_ context.Context, id tlf.ID)

+ func (md *MDServerDisk) CheckForRekeys(ctx context.Context) <-chan error

+ func (md *MDServerDisk) CheckReachability(ctx context.Context)

+ func (md *MDServerDisk) DisableRekeyUpdatesForTesting()

+ func (md *MDServerDisk) FastForwardBackoff()

+ func (md *MDServerDisk) GetForHandle(ctx context.Context, handle tlf.Handle, mStatus kbfsmd.MergeStatus, ...) (tlf.ID, *RootMetadataSigned, error)

+ func (md *MDServerDisk) GetForTLF(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) (*RootMetadataSigned, error)

+ func (md *MDServerDisk) GetKeyBundles(ctx context.Context, tlfID tlf.ID, wkbID kbfsmd.TLFWriterKeyBundleID, ...) (*kbfsmd.TLFWriterKeyBundleV3, *kbfsmd.TLFReaderKeyBundleV3, error)

+ func (md *MDServerDisk) GetLatestHandleForTLF(ctx context.Context, id tlf.ID) (tlf.Handle, error)

+ func (md *MDServerDisk) GetRange(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) ([]*RootMetadataSigned, error)

+ func (md *MDServerDisk) IsConnected() bool

+ func (md *MDServerDisk) OffsetFromServerTime() (time.Duration, bool)

+ func (md *MDServerDisk) PruneBranch(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) error

+ func (md *MDServerDisk) Put(ctx context.Context, rmds *RootMetadataSigned, extra kbfsmd.ExtraMetadata, ...) error

+ func (md *MDServerDisk) RefreshAuthToken(ctx context.Context)

+ func (md *MDServerDisk) RegisterForUpdate(ctx context.Context, id tlf.ID, currHead kbfsmd.Revision) (<-chan error, error)

+ func (md *MDServerDisk) Shutdown()

+ func (md *MDServerDisk) StartImplicitTeamMigration(ctx context.Context, id tlf.ID) (err error)

+ func (md *MDServerDisk) TruncateLock(ctx context.Context, id tlf.ID) (bool, error)

+ func (md *MDServerDisk) TruncateUnlock(ctx context.Context, id tlf.ID) (bool, error)

+ type MDServerMemory struct

+ func NewMDServerMemory(config mdServerLocalConfig) (*MDServerMemory, error)

+ func (md *MDServerMemory) CancelRegistration(_ context.Context, id tlf.ID)

+ func (md *MDServerMemory) CheckForRekeys(ctx context.Context) <-chan error

+ func (md *MDServerMemory) CheckReachability(ctx context.Context)

+ func (md *MDServerMemory) DisableRekeyUpdatesForTesting()

+ func (md *MDServerMemory) FastForwardBackoff()

+ func (md *MDServerMemory) GetForHandle(ctx context.Context, handle tlf.Handle, mStatus kbfsmd.MergeStatus, ...) (tlf.ID, *RootMetadataSigned, error)

+ func (md *MDServerMemory) GetForTLF(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) (*RootMetadataSigned, error)

+ func (md *MDServerMemory) GetKeyBundles(ctx context.Context, tlfID tlf.ID, wkbID kbfsmd.TLFWriterKeyBundleID, ...) (*kbfsmd.TLFWriterKeyBundleV3, *kbfsmd.TLFReaderKeyBundleV3, error)

+ func (md *MDServerMemory) GetLatestHandleForTLF(ctx context.Context, id tlf.ID) (tlf.Handle, error)

+ func (md *MDServerMemory) GetRange(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) ([]*RootMetadataSigned, error)

+ func (md *MDServerMemory) IsConnected() bool

+ func (md *MDServerMemory) Lock(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ func (md *MDServerMemory) OffsetFromServerTime() (time.Duration, bool)

+ func (md *MDServerMemory) PruneBranch(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) error

+ func (md *MDServerMemory) Put(ctx context.Context, rmds *RootMetadataSigned, extra kbfsmd.ExtraMetadata, ...) error

+ func (md *MDServerMemory) RefreshAuthToken(ctx context.Context)

+ func (md *MDServerMemory) RegisterForUpdate(ctx context.Context, id tlf.ID, currHead kbfsmd.Revision) (<-chan error, error)

+ func (md *MDServerMemory) ReleaseLock(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ func (md *MDServerMemory) Shutdown()

+ func (md *MDServerMemory) StartImplicitTeamMigration(ctx context.Context, id tlf.ID) (err error)

+ func (md *MDServerMemory) TruncateLock(ctx context.Context, id tlf.ID) (bool, error)

+ func (md *MDServerMemory) TruncateUnlock(ctx context.Context, id tlf.ID) (bool, error)

+ type MDServerRemote struct

+ func NewMDServerRemote(config Config, srvRemote rpc.Remote, rpcLogFactory rpc.LogFactory) *MDServerRemote

+ func (*MDServerRemote) HandlerName() string

+ func (md *MDServerRemote) CancelRegistration(ctx context.Context, id tlf.ID)

+ func (md *MDServerRemote) CheckForRekeys(ctx context.Context) <-chan error

+ func (md *MDServerRemote) CheckReachability(ctx context.Context)

+ func (md *MDServerRemote) DeleteTLFCryptKeyServerHalf(ctx context.Context, uid keybase1.UID, key kbfscrypto.CryptPublicKey, ...) (err error)

+ func (md *MDServerRemote) DisableRekeyUpdatesForTesting()

+ func (md *MDServerRemote) FastForwardBackoff()

+ func (md *MDServerRemote) FolderNeedsRekey(ctx context.Context, arg keybase1.FolderNeedsRekeyArg) error

+ func (md *MDServerRemote) FoldersNeedRekey(ctx context.Context, requests []keybase1.RekeyRequest) error

+ func (md *MDServerRemote) GetForHandle(ctx context.Context, handle tlf.Handle, mStatus kbfsmd.MergeStatus, ...) (tlfID tlf.ID, rmds *RootMetadataSigned, err error)

+ func (md *MDServerRemote) GetForTLF(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) (rmds *RootMetadataSigned, err error)

+ func (md *MDServerRemote) GetKeyBundles(ctx context.Context, tlf tlf.ID, wkbID kbfsmd.TLFWriterKeyBundleID, ...) (wkb *kbfsmd.TLFWriterKeyBundleV3, rkb *kbfsmd.TLFReaderKeyBundleV3, err error)

+ func (md *MDServerRemote) GetLatestHandleForTLF(ctx context.Context, id tlf.ID) (handle tlf.Handle, err error)

+ func (md *MDServerRemote) GetRange(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID, ...) (rmdses []*RootMetadataSigned, err error)

+ func (md *MDServerRemote) GetTLFCryptKeyServerHalf(ctx context.Context, serverHalfID kbfscrypto.TLFCryptKeyServerHalfID, ...) (serverHalf kbfscrypto.TLFCryptKeyServerHalf, err error)

+ func (md *MDServerRemote) IsConnected() bool

+ func (md *MDServerRemote) Lock(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ func (md *MDServerRemote) MetadataUpdate(_ context.Context, arg keybase1.MetadataUpdateArg) error

+ func (md *MDServerRemote) OffsetFromServerTime() (time.Duration, bool)

+ func (md *MDServerRemote) OnConnect(ctx context.Context, conn *rpc.Connection, client rpc.GenericClient, ...) (err error)

+ func (md *MDServerRemote) OnConnectError(err error, wait time.Duration)

+ func (md *MDServerRemote) OnDisconnected(ctx context.Context, status rpc.DisconnectStatus)

+ func (md *MDServerRemote) OnDoCommandError(err error, wait time.Duration)

+ func (md *MDServerRemote) PruneBranch(ctx context.Context, id tlf.ID, bid kbfsmd.BranchID) (err error)

+ func (md *MDServerRemote) Put(ctx context.Context, rmds *RootMetadataSigned, extra kbfsmd.ExtraMetadata, ...) (err error)

+ func (md *MDServerRemote) PutTLFCryptKeyServerHalves(ctx context.Context, keyServerHalves kbfsmd.UserDeviceKeyServerHalves) (err error)

+ func (md *MDServerRemote) RefreshAuthToken(ctx context.Context)

+ func (md *MDServerRemote) RegisterForUpdate(ctx context.Context, id tlf.ID, currHead kbfsmd.Revision) (<-chan error, error)

+ func (md *MDServerRemote) ReleaseLock(ctx context.Context, tlfID tlf.ID, lockID keybase1.LockID) error

+ func (md *MDServerRemote) RemoteAddress() string

+ func (md *MDServerRemote) ShouldRetry(name string, err error) bool

+ func (md *MDServerRemote) ShouldRetryOnConnect(err error) bool

+ func (md *MDServerRemote) Shutdown()

+ func (md *MDServerRemote) StartImplicitTeamMigration(ctx context.Context, id tlf.ID) (err error)

+ func (md *MDServerRemote) TruncateLock(ctx context.Context, id tlf.ID) (locked bool, err error)

+ func (md *MDServerRemote) TruncateUnlock(ctx context.Context, id tlf.ID) (unlocked bool, err error)

+ type MDUpdateInvertError struct

+ func (e MDUpdateInvertError) Error() string

+ type MDWriteNeededInRequest struct

+ func (e MDWriteNeededInRequest) Error() string

+ type MeterSnapshot struct

+ func (*MeterSnapshot) Mark(n int64)

+ func (m *MeterSnapshot) Count() int64

+ func (m *MeterSnapshot) Rate1() float64

+ func (m *MeterSnapshot) Rate15() float64

+ func (m *MeterSnapshot) Rate5() float64

+ func (m *MeterSnapshot) RateMean() float64

+ func (m *MeterSnapshot) Snapshot() metrics.Meter

+ type MeterStatus struct

+ Count int64

+ Minutes1 float64

+ Minutes15 float64

+ Minutes5 float64

+ type NameExistsError struct

+ Name string

+ func (e NameExistsError) Error() string

+ type NameTooLongError struct

+ func (e NameTooLongError) Error() string

+ type NaïveStaller struct

+ func NewNaïveStaller(config Config) *NaïveStaller

+ func (s *NaïveStaller) StallBlockOp(stalledOp StallableBlockOp, maxStalls int)

+ func (s *NaïveStaller) StallMDOp(stalledOp StallableMDOp, maxStalls int, stallDelegate bool)

+ func (s *NaïveStaller) UndoStallBlockOp(stalledOp StallableBlockOp)

+ func (s *NaïveStaller) UndoStallMDOp(stalledOp StallableMDOp)

+ func (s *NaïveStaller) UnstallOneBlockOp(stalledOp StallableBlockOp)

+ func (s *NaïveStaller) UnstallOneMDOp(stalledOp StallableMDOp)

+ func (s *NaïveStaller) WaitForStallBlockOp(stalledOp StallableBlockOp)

+ func (s *NaïveStaller) WaitForStallMDOp(stalledOp StallableMDOp)

+ type NeedOtherRekeyError struct

+ Err error

+ Tlf tlf.CanonicalName

+ func (e NeedOtherRekeyError) Error() string

+ func (e NeedOtherRekeyError) ToStatus() keybase1.Status

+ type NeedSelfRekeyError struct

+ Err error

+ Tlf tlf.CanonicalName

+ func (e NeedSelfRekeyError) Error() string

+ func (e NeedSelfRekeyError) ToStatus() keybase1.Status

+ type NewDataVersionError struct

+ DataVer DataVer

+ func (e NewDataVersionError) Error() string

+ type NoCancellationDelayerError struct

+ func (e NoCancellationDelayerError) Error() string

+ type NoChainFoundError struct

+ func (e NoChainFoundError) Error() string

+ type NoCurrentSessionError struct

+ func (e NoCurrentSessionError) Error() string

+ type NoKeysError struct

+ func (e NoKeysError) Error() string

+ type NoMergedMDError struct

+ func (e NoMergedMDError) Error() string

+ type NoSigChainError struct

+ User libkb.NormalizedUsername

+ func (e NoSigChainError) Error() string

+ type NoSuchBlockError struct

+ ID kbfsblock.ID

+ func (e NoSuchBlockError) Error() string

+ type NoSuchFolderListError struct

+ Name string

+ PrivName string

+ PubName string

+ func (e NoSuchFolderListError) Error() string

+ type NoSuchMDError struct

+ BID kbfsmd.BranchID

+ Rev kbfsmd.Revision

+ Tlf tlf.ID

+ func (e NoSuchMDError) Error() string

+ type NoSuchNameError struct

+ Name string

+ func (e NoSuchNameError) Error() string

+ type NoSuchTeamError struct

+ Input string

+ func (e NoSuchTeamError) Error() string

+ type NoSuchTlfHandleError struct

+ ID tlf.ID

+ func (e NoSuchTlfHandleError) Error() string

+ type NoSuchTlfIDError struct

+ func (e NoSuchTlfIDError) Error() string

+ type NoSuchUserError struct

+ Input string

+ func (e NoSuchUserError) Error() string

+ func (e NoSuchUserError) ToStatus() keybase1.Status

+ type NoUpdatesWhileDirtyError struct

+ func (e NoUpdatesWhileDirtyError) Error() string

+ type Node interface

+ GetBasename func() string

+ GetFolderBranch func() FolderBranch

+ GetID func() NodeID

+ Readonly func(ctx context.Context) bool

+ RemoveDir func(ctx context.Context, dirName string) (removeHandled bool, err error)

+ ShouldCreateMissedLookup func(ctx context.Context, name string) (shouldCreate bool, newCtx context.Context, et EntryType, sympath string)

+ ShouldRetryOnDirRead func(ctx context.Context) bool

+ Unwrap func() Node

+ WrapChild func(child Node) Node

+ func GetRootNodeForTest(ctx context.Context, config Config, name string, t tlf.Type) (Node, error)

+ func GetRootNodeOrBust(ctx context.Context, t logger.TestLogBackend, config Config, name string, ...) Node

+ type NodeCache interface

+ AddRootWrapper func(func(Node) Node)

+ AllNodes func() []Node

+ Get func(ref BlockRef) Node

+ GetOrCreate func(ptr BlockPointer, name string, parent Node) (Node, error)

+ IsUnlinked func(node Node) bool

+ Move func(ref BlockRef, newParent Node, newName string) (undoFn func(), err error)

+ PathFromNode func(node Node) path

+ Unlink func(ref BlockRef, oldPath path, oldDe DirEntry) (undoFn func())

+ UnlinkedDirEntry func(node Node) DirEntry

+ UpdatePointer func(oldRef BlockRef, newPtr BlockPointer) NodeID

+ type NodeChange struct

+ DirUpdated []string

+ FileUpdated []WriteRange

+ Node Node

+ type NodeID interface

+ ParentID func() NodeID

+ type NodeMetadata struct

+ BlockInfo BlockInfo

+ LastWriterUnverified libkb.NormalizedUsername

+ PrefetchStatus string

+ type NodeNotFoundError struct

+ func (e NodeNotFoundError) Error() string

+ type NotDirBlockError struct

+ func (e NotDirBlockError) Error() string

+ type NotDirError struct

+ func (e NotDirError) Error() string

+ type NotDirectFileBlockError struct

+ func (e NotDirectFileBlockError) Error() string

+ type NotFileBlockError struct

+ func (e NotFileBlockError) Error() string

+ type NotFileError struct

+ func (e NotFileError) Error() string

+ type NotPermittedWhileDirtyError struct

+ func (e NotPermittedWhileDirtyError) Error() string

+ type Notifier interface

+ RegisterForChanges func(folderBranches []FolderBranch, obs Observer) error

+ UnregisterFromChanges func(folderBranches []FolderBranch, obs Observer) error

+ type Observer interface

+ BatchChanges func(ctx context.Context, changes []NodeChange, allAffectedNodeIDs []NodeID)

+ LocalChange func(ctx context.Context, node Node, write WriteRange)

+ TlfHandleChange func(ctx context.Context, newHandle *TlfHandle)

+ type OngoingWorkLimiter struct

+ func NewOngoingWorkLimiter(maxNumOngoingWorks int) *OngoingWorkLimiter

+ func (owl *OngoingWorkLimiter) Done()

+ func (owl *OngoingWorkLimiter) WaitToStart(ctx context.Context) error

+ type OpCommon struct

+ RefBlocks []BlockPointer

+ UnrefBlocks []BlockPointer

+ Updates []blockUpdate

+ func (oc *OpCommon) AddRefBlock(ptr BlockPointer)

+ func (oc *OpCommon) AddSelfUpdate(ptr BlockPointer)

+ func (oc *OpCommon) AddUnrefBlock(ptr BlockPointer)

+ func (oc *OpCommon) AddUpdate(oldPtr BlockPointer, newPtr BlockPointer)

+ func (oc *OpCommon) DelRefBlock(ptr BlockPointer)

+ func (oc *OpCommon) DelUnrefBlock(ptr BlockPointer)

+ func (oc *OpCommon) Refs() []BlockPointer

+ func (oc *OpCommon) Unrefs() []BlockPointer

+ type OpSummary struct

+ Op string

+ Refs []string

+ Unrefs []string

+ Updates map[string]string

+ type OpsCantHandleFavorite struct

+ Msg string

+ func (e OpsCantHandleFavorite) Error() string

+ type OutdatedVersionError struct

+ func (e OutdatedVersionError) Error() string

+ type OverQuotaWarning struct

+ LimitBytes int64

+ UsageBytes int64

+ func (w OverQuotaWarning) Error() string

+ type PaddedBlockReadError struct

+ ActualLen int

+ ExpectedLen int

+ func (e PaddedBlockReadError) Error() string

+ type ParentNodeNotFoundError struct

+ func (e ParentNodeNotFoundError) Error() string

+ type PathType string

+ const KeybasePathType

+ const PrivatePathType

+ const PublicPathType

+ const SingleTeamPathType

+ type PrefetchStatus int

+ const FinishedPrefetch

+ const NoPrefetch

+ const TriggeredPrefetch

+ func PrefetchStatusFromProtocol(protocolPrefetchStatus kbgitkbfs.PrefetchStatus) PrefetchStatus

+ func (s PrefetchStatus) String() string

+ func (s PrefetchStatus) ToProtocol() kbgitkbfs.PrefetchStatus

+ type Prefetcher interface

+ CancelPrefetch func(kbfsblock.ID)

+ ProcessBlockForPrefetch func(ctx context.Context, ptr BlockPointer, block Block, kmd KeyMetadata, ...)

+ Shutdown func() <-chan struct{}

+ type PrivateMetadata struct

+ Changes BlockChanges

+ Dir DirEntry

+ LastGCRevision kbfsmd.Revision

+ TLFPrivateKey kbfscrypto.TLFPrivateKey

+ func (p PrivateMetadata) ChangesBlockInfo() BlockInfo

+ type ReadAccessError struct

+ Filename string

+ Tlf tlf.CanonicalName

+ Type tlf.Type

+ User libkb.NormalizedUsername

+ func (e ReadAccessError) Error() string

+ type ReadOnlyRootMetadata struct

+ func (md ReadOnlyRootMetadata) CheckValidSuccessor(currID kbfsmd.ID, nextMd ReadOnlyRootMetadata) error

+ type ReadyBlockData struct

+ func (r ReadyBlockData) GetEncodedSize() int

+ type RekeyConflictError struct

+ Err error

+ func (e RekeyConflictError) Error() string

+ type RekeyEvent struct

+ func NewRekeyNotNeededEvent() RekeyEvent

+ func NewRekeyRequestEvent() RekeyEvent

+ func NewRekeyRequestWithPaperPromptEvent() RekeyEvent

+ func (e RekeyEvent) String() string

+ type RekeyFSM interface

+ Event func(event RekeyEvent)

+ Shutdown func()

+ func NewRekeyFSM(fbo *folderBranchOps) RekeyFSM

+ type RekeyIncompleteError struct

+ func (e RekeyIncompleteError) Error() string

+ type RekeyPermissionError struct

+ Dir string

+ User libkb.NormalizedUsername

+ func (e RekeyPermissionError) Error() string

+ type RekeyQueue interface

+ Enqueue func(tlf.ID)

+ IsRekeyPending func(tlf.ID) bool

+ Shutdown func()

+ type RekeyQueueStandard struct

+ func NewRekeyQueueStandard(config Config) (rkq *RekeyQueueStandard)

+ func (rkq *RekeyQueueStandard) Enqueue(id tlf.ID)

+ func (rkq *RekeyQueueStandard) IsRekeyPending(id tlf.ID) bool

+ func (rkq *RekeyQueueStandard) Shutdown()

+ type RekeyResult struct

+ DidRekey bool

+ NeedsPaperKey bool

+ func RequestRekeyAndWaitForOneFinishEvent(ctx context.Context, ops KBFSOps, tlfID tlf.ID) (res RekeyResult, err error)

+ type RenameAcrossDirsError struct

+ ApplicationExecPath string

+ func (e RenameAcrossDirsError) Error() string

+ type ReportedError struct

+ Error error

+ Stack []uintptr

+ Time time.Time

+ type Reporter interface

+ AllKnownErrors func() []ReportedError

+ Notify func(ctx context.Context, notification *keybase1.FSNotification)

+ NotifySyncStatus func(ctx context.Context, status *keybase1.FSPathSyncStatus)

+ ReportErr func(ctx context.Context, tlfName tlf.CanonicalName, t tlf.Type, mode ErrorModeType, ...)

+ Shutdown func()

+ type ReporterKBPKI struct

+ func NewReporterKBPKI(config Config, maxErrors, bufSize int) *ReporterKBPKI

+ func (r *ReporterKBPKI) Notify(ctx context.Context, notification *keybase1.FSNotification)

+ func (r *ReporterKBPKI) NotifySyncStatus(ctx context.Context, status *keybase1.FSPathSyncStatus)

+ func (r *ReporterKBPKI) ReportErr(ctx context.Context, tlfName tlf.CanonicalName, t tlf.Type, mode ErrorModeType, ...)

+ func (r *ReporterKBPKI) Shutdown()

+ type ReporterSimple struct

+ func NewReporterSimple(clock Clock, maxErrors int) *ReporterSimple

+ func (r *ReporterSimple) AllKnownErrors() []ReportedError

+ func (r *ReporterSimple) Notify(_ context.Context, _ *keybase1.FSNotification)

+ func (r *ReporterSimple) NotifySyncStatus(_ context.Context, _ *keybase1.FSPathSyncStatus)

+ func (r *ReporterSimple) ReportErr(ctx context.Context, _ tlf.CanonicalName, _ tlf.Type, _ ErrorModeType, ...)

+ func (r *ReporterSimple) Shutdown()

+ type RootMetadata struct

+ func (md *RootMetadata) AddDiskUsage(diskUsage uint64)

+ func (md *RootMetadata) AddKeyGeneration(codec kbfscodec.Codec, wKeys, rKeys kbfsmd.UserDevicePublicKeys, ...) (serverHalves kbfsmd.UserDeviceKeyServerHalves, err error)

+ func (md *RootMetadata) AddMDDiskUsage(mdDiskUsage uint64)

+ func (md *RootMetadata) AddMDRefBytes(mdRefBytes uint64)

+ func (md *RootMetadata) AddOp(o op)

+ func (md *RootMetadata) AddRefBlock(info BlockInfo)

+ func (md *RootMetadata) AddRefBytes(refBytes uint64)

+ func (md *RootMetadata) AddUnrefBlock(info BlockInfo)

+ func (md *RootMetadata) AddUnrefBytes(unrefBytes uint64)

+ func (md *RootMetadata) AddUpdate(oldInfo BlockInfo, newInfo BlockInfo)

+ func (md *RootMetadata) BID() kbfsmd.BranchID

+ func (md *RootMetadata) ClearBlockChanges()

+ func (md *RootMetadata) Data() *PrivateMetadata

+ func (md *RootMetadata) DiskUsage() uint64

+ func (md *RootMetadata) Extra() kbfsmd.ExtraMetadata

+ func (md *RootMetadata) GetBareRootMetadata() kbfsmd.RootMetadata

+ func (md *RootMetadata) GetHistoricTLFCryptKey(codec kbfscodec.Codec, keyGen kbfsmd.KeyGen, currentKey kbfscrypto.TLFCryptKey) (kbfscrypto.TLFCryptKey, error)

+ func (md *RootMetadata) GetSerializedPrivateMetadata() []byte

+ func (md *RootMetadata) GetSerializedWriterMetadata(codec kbfscodec.Codec) ([]byte, error)

+ func (md *RootMetadata) GetTLFCryptKeyParams(keyGen kbfsmd.KeyGen, user keybase1.UID, key kbfscrypto.CryptPublicKey) (kbfscrypto.TLFEphemeralPublicKey, kbfscrypto.EncryptedTLFCryptKeyClientHalf, ...)

+ func (md *RootMetadata) GetTLFReaderKeyBundleID() kbfsmd.TLFReaderKeyBundleID

+ func (md *RootMetadata) GetTLFWriterKeyBundleID() kbfsmd.TLFWriterKeyBundleID

+ func (md *RootMetadata) GetTlfHandle() *TlfHandle

+ func (md *RootMetadata) HasKeyForUser(user keybase1.UID) (bool, error)

+ func (md *RootMetadata) IsFinal() bool

+ func (md *RootMetadata) IsInitialized() bool

+ func (md *RootMetadata) IsReadable() bool

+ func (md *RootMetadata) IsReader(ctx context.Context, checker kbfsmd.TeamMembershipChecker, uid keybase1.UID) (bool, error)

+ func (md *RootMetadata) IsRekeySet() bool

+ func (md *RootMetadata) IsUnmergedSet() bool

+ func (md *RootMetadata) IsWriter(ctx context.Context, checker kbfsmd.TeamMembershipChecker, uid keybase1.UID, ...) (bool, error)

+ func (md *RootMetadata) IsWriterMetadataCopiedSet() bool

+ func (md *RootMetadata) KeyGenerationsToUpdate() (kbfsmd.KeyGen, kbfsmd.KeyGen)

+ func (md *RootMetadata) LastModifyingUser() keybase1.UID

+ func (md *RootMetadata) LastModifyingWriter() keybase1.UID

+ func (md *RootMetadata) LatestKeyGeneration() kbfsmd.KeyGen

+ func (md *RootMetadata) MDDiskUsage() uint64

+ func (md *RootMetadata) MDRefBytes() uint64

+ func (md *RootMetadata) MakeBareTlfHandle() (tlf.Handle, error)

+ func (md *RootMetadata) MakeSuccessor(ctx context.Context, latestMDVer kbfsmd.MetadataVer, codec kbfscodec.Codec, ...) (*RootMetadata, error)

+ func (md *RootMetadata) MergedStatus() kbfsmd.MergeStatus

+ func (md *RootMetadata) MerkleRoot() keybase1.MerkleRootV2

+ func (md *RootMetadata) PrevRoot() kbfsmd.ID

+ func (md *RootMetadata) ReadOnly() ReadOnlyRootMetadata

+ func (md *RootMetadata) RefBytes() uint64

+ func (md *RootMetadata) Revision() kbfsmd.Revision

+ func (md *RootMetadata) SetBranchID(bid kbfsmd.BranchID)

+ func (md *RootMetadata) SetConflictInfo(ci *tlf.HandleExtension)

+ func (md *RootMetadata) SetDiskUsage(diskUsage uint64)

+ func (md *RootMetadata) SetFinalBit()

+ func (md *RootMetadata) SetFinalizedInfo(fi *tlf.HandleExtension)

+ func (md *RootMetadata) SetLastGCRevision(rev kbfsmd.Revision)

+ func (md *RootMetadata) SetLastModifyingUser(user keybase1.UID)

+ func (md *RootMetadata) SetLastModifyingWriter(user keybase1.UID)

+ func (md *RootMetadata) SetMDDiskUsage(mdDiskUsage uint64)

+ func (md *RootMetadata) SetMDRefBytes(mdRefBytes uint64)

+ func (md *RootMetadata) SetMerkleRoot(root keybase1.MerkleRootV2)

+ func (md *RootMetadata) SetPrevRoot(mdID kbfsmd.ID)

+ func (md *RootMetadata) SetRefBytes(refBytes uint64)

+ func (md *RootMetadata) SetRekeyBit()

+ func (md *RootMetadata) SetRevision(revision kbfsmd.Revision)

+ func (md *RootMetadata) SetSerializedPrivateMetadata(spmd []byte)

+ func (md *RootMetadata) SetTlfID(tlf tlf.ID)

+ func (md *RootMetadata) SetUnmerged()

+ func (md *RootMetadata) SetUnrefBytes(unrefBytes uint64)

+ func (md *RootMetadata) SetUnresolvedReaders(readers []keybase1.SocialAssertion)

+ func (md *RootMetadata) SetUnresolvedWriters(writers []keybase1.SocialAssertion)

+ func (md *RootMetadata) SetWriterMetadataCopiedBit()

+ func (md *RootMetadata) SetWriters(writers []keybase1.UserOrTeamID)

+ func (md *RootMetadata) StoresHistoricTLFCryptKeys() bool

+ func (md *RootMetadata) TlfID() tlf.ID

+ func (md *RootMetadata) TypeForKeying() tlf.KeyingType

+ func (md *RootMetadata) UnrefBytes() uint64

+ func (md *RootMetadata) Version() kbfsmd.MetadataVer

+ type RootMetadataSigned struct

+ func DecodeRootMetadataSigned(codec kbfscodec.Codec, tlf tlf.ID, ver, max kbfsmd.MetadataVer, buf []byte, ...) (*RootMetadataSigned, error)

+ func SignBareRootMetadata(ctx context.Context, codec kbfscodec.Codec, ...) (*RootMetadataSigned, error)

+ func (rmds *RootMetadataSigned) MakeFinalCopy(codec kbfscodec.Codec, now time.Time, finalizedInfo *tlf.HandleExtension) (*RootMetadataSigned, error)

+ type SessionInfo struct

+ CryptPublicKey kbfscrypto.CryptPublicKey

+ Name libkb.NormalizedUsername

+ UID keybase1.UID

+ VerifyingKey kbfscrypto.VerifyingKey

+ func GetCurrentSessionIfPossible(ctx context.Context, kbpki KBPKI, sessionNotRequired bool) (SessionInfo, error)

+ func SessionInfoFromProtocol(session keybase1.Session) (SessionInfo, error)

+ type SharedKeybaseTransport struct

+ func (kt *SharedKeybaseTransport) Close()

+ func (kt *SharedKeybaseTransport) Dial(ctx context.Context) (rpc.Transporter, error)

+ func (kt *SharedKeybaseTransport) Finalize()

+ func (kt *SharedKeybaseTransport) IsConnected() bool

+ type ShutdownHappenedError struct

+ func (e ShutdownHappenedError) Error() string

+ type SizeFlag struct

+ func (sf SizeFlag) Get() interface{}

+ func (sf SizeFlag) Set(raw string) error

+ func (sf SizeFlag) String() string

+ type StallableBlockOp stallableOp

+ type StallableMDOp stallableOp

+ type StateChecker struct

+ func NewStateChecker(config Config) *StateChecker

+ func (sc *StateChecker) CheckMergedState(ctx context.Context, tlfID tlf.ID) error

+ type StatusUpdate struct

+ type TLFJournalBackgroundWorkStatus int

+ const TLFJournalBackgroundWorkEnabled

+ const TLFJournalBackgroundWorkPaused

+ const TLFJournalSingleOpBackgroundWorkEnabled

+ func (bws TLFJournalBackgroundWorkStatus) String() string

+ type TLFJournalStatus struct

+ BlockOpCount uint64

+ BranchID string

+ Dir string

+ LastFlushErr string

+ QuotaLimitBytes int64

+ QuotaUsedBytes int64

+ RevisionEnd kbfsmd.Revision

+ RevisionStart kbfsmd.Revision

+ StoredBytes int64

+ StoredFiles int64

+ UnflushedBytes int64

+ UnflushedPaths []string

+ type TLFUpdateHistory struct

+ ID string

+ Name string

+ Updates []UpdateSummary

+ type TeamInfo struct

+ CryptKeys map[kbfsmd.KeyGen]kbfscrypto.TLFCryptKey

+ LatestKeyGen kbfsmd.KeyGen

+ Name libkb.NormalizedUsername

+ Readers map[keybase1.UID]bool

+ RootID keybase1.TeamID

+ TID keybase1.TeamID

+ Writers map[keybase1.UID]bool

+ func AddEmptyTeamsForTest(config Config, teams ...libkb.NormalizedUsername) ([]TeamInfo, error)

+ func AddEmptyTeamsForTestOrBust(t logger.TestLogBackend, config Config, teams ...libkb.NormalizedUsername) []TeamInfo

+ func MakeLocalTeams(teams []libkb.NormalizedUsername) []TeamInfo

+ type TestClock struct

+ func (tc *TestClock) Add(d time.Duration)

+ func (tc *TestClock) Now() time.Time

+ func (tc *TestClock) Set(t time.Time)

+ type TimeoutError struct

+ func (e TimeoutError) Error() string

+ type TlfAccessError struct

+ ID tlf.ID

+ func (e TlfAccessError) Error() string

+ type TlfEdit struct

+ Filepath string

+ LocalTime time.Time

+ Type TlfEditNotificationType

+ type TlfEditHistory struct

+ func NewTlfEditHistory(config Config, fbo *folderBranchOps, log logger.Logger) *TlfEditHistory

+ func (teh *TlfEditHistory) GetComplete(ctx context.Context, head ImmutableRootMetadata) (TlfWriterEdits, error)

+ func (teh *TlfEditHistory) Shutdown()

+ func (teh *TlfEditHistory) UpdateHistory(ctx context.Context, rmds []ImmutableRootMetadata) error

+ func (teh *TlfEditHistory) Wait(ctx context.Context) error

+ type TlfEditList []TlfEdit

+ func (tel TlfEditList) Len() int

+ func (tel TlfEditList) Less(i, j int) bool

+ func (tel TlfEditList) Swap(i, j int)

+ type TlfEditNotificationType int

+ const FileCreated

+ const FileModified

+ type TlfHandle struct

+ func GetHandleFromFolderNameAndType(ctx context.Context, kbpki KBPKI, idGetter tlfIDGetter, tlfName string, ...) (*TlfHandle, error)

+ func MakeTlfHandle(ctx context.Context, bareHandle tlf.Handle, t tlf.Type, resolver resolver, ...) (*TlfHandle, error)

+ func ParseTlfHandle(ctx context.Context, kbpki KBPKI, idGetter tlfIDGetter, name string, ...) (*TlfHandle, error)

+ func ParseTlfHandlePreferred(ctx context.Context, kbpki KBPKI, idGetter tlfIDGetter, name string, ...) (*TlfHandle, error)

+ func (h *TlfHandle) GetCanonicalName() tlf.CanonicalName

+ func (h *TlfHandle) GetCanonicalPath() string

+ func (h *TlfHandle) ResolveAgain(ctx context.Context, resolver resolver, idGetter tlfIDGetter) (*TlfHandle, error)

+ func (h *TlfHandle) ResolveAgainForUser(ctx context.Context, resolver resolver, idGetter tlfIDGetter, uid keybase1.UID) (*TlfHandle, error)

+ func (h *TlfHandle) SetFinalizedInfo(info *tlf.HandleExtension)

+ func (h *TlfHandle) ToFavorite() Favorite

+ func (h TlfHandle) ConflictInfo() *tlf.HandleExtension

+ func (h TlfHandle) Equals(codec kbfscodec.Codec, other TlfHandle) (bool, error)

+ func (h TlfHandle) EqualsIgnoreName(codec kbfscodec.Codec, other TlfHandle) (bool, error)

+ func (h TlfHandle) Extensions() (extensions []tlf.HandleExtension)

+ func (h TlfHandle) FinalizedInfo() *tlf.HandleExtension

+ func (h TlfHandle) FirstResolvedWriter() keybase1.UserOrTeamID

+ func (h TlfHandle) GetPreferredFormat(username libkb.NormalizedUsername) tlf.PreferredName

+ func (h TlfHandle) IsBackedByTeam() bool

+ func (h TlfHandle) IsConflict() bool

+ func (h TlfHandle) IsFinal() bool

+ func (h TlfHandle) IsReader(user keybase1.UID) bool

+ func (h TlfHandle) IsWriter(user keybase1.UID) bool

+ func (h TlfHandle) MutuallyResolvesTo(ctx context.Context, codec kbfscodec.Codec, resolver resolver, ...) error

+ func (h TlfHandle) ResolvedReaders() []keybase1.UserOrTeamID

+ func (h TlfHandle) ResolvedUsersMap() map[keybase1.UserOrTeamID]libkb.NormalizedUsername

+ func (h TlfHandle) ResolvedWriters() []keybase1.UserOrTeamID

+ func (h TlfHandle) ResolvesTo(ctx context.Context, codec kbfscodec.Codec, resolver resolver, ...) (resolvesTo bool, partialResolvedH *TlfHandle, err error)

+ func (h TlfHandle) TlfID() tlf.ID

+ func (h TlfHandle) ToBareHandle() (tlf.Handle, error)

+ func (h TlfHandle) ToBareHandleOrBust() tlf.Handle

+ func (h TlfHandle) Type() tlf.Type

+ func (h TlfHandle) TypeForKeying() tlf.KeyingType

+ func (h TlfHandle) UnresolvedReaders() []keybase1.SocialAssertion

+ func (h TlfHandle) UnresolvedWriters() []keybase1.SocialAssertion

+ func (h TlfHandle) WithUpdatedConflictInfo(codec kbfscodec.Codec, info *tlf.HandleExtension) (*TlfHandle, error)

+ type TlfHandleFinalizedError struct

+ func (e TlfHandleFinalizedError) Error() string

+ type TlfNameNotCanonical struct

+ Name string

+ NameToTry string

+ func (e TlfNameNotCanonical) Error() string

+ type TlfWriterEdits map[keybase1.UID]TlfEditList

+ type TooLowByteCountError struct

+ ByteCount int

+ ExpectedMinByteCount int

+ func (e TooLowByteCountError) Error() string

+ type Tracer interface

+ MaybeFinishTrace func(ctx context.Context, err error)

+ MaybeStartTrace func(ctx context.Context, family, title string) context.Context

+ type UnexpectedUnmergedPutError struct

+ func (e UnexpectedUnmergedPutError) Error() string

+ type UnmergedError struct

+ func (e UnmergedError) Error() string

+ type UnmergedSelfConflictError struct

+ Err error

+ func (e UnmergedSelfConflictError) Error() string

+ type UnsupportedOpInUnlinkedDirError struct

+ Dirpath string

+ func (e UnsupportedOpInUnlinkedDirError) Error() string

+ type UnverifiableTlfUpdateError struct

+ Err error

+ Tlf string

+ User libkb.NormalizedUsername

+ func (e UnverifiableTlfUpdateError) Error() string

+ type UpdateSummary struct

+ Date time.Time

+ LiveBytes uint64

+ Ops []OpSummary

+ Revision kbfsmd.Revision

+ Writer string

+ type UserInfo struct

+ CryptPublicKeys []kbfscrypto.CryptPublicKey

+ EldestSeqno keybase1.Seqno

+ KIDNames map[keybase1.KID]string

+ Name libkb.NormalizedUsername

+ RevokedCryptPublicKeys map[kbfscrypto.CryptPublicKey]keybase1.KeybaseTime

+ RevokedVerifyingKeys map[kbfscrypto.VerifyingKey]keybase1.KeybaseTime

+ UID keybase1.UID

+ VerifyingKeys []kbfscrypto.VerifyingKey

+ func UserInfoFromProtocol(upk keybase1.UserPlusKeys) (UserInfo, error)

+ type VerifyingKeyNotFoundError struct

+ func (e VerifyingKeyNotFoundError) Error() string

+ type Warninger interface

+ Warning func(format string, args ...interface{})

+ type WrapError struct

+ Err error

+ func (e WrapError) String() string

+ type WriteAccessError struct

+ Filename string

+ Tlf tlf.CanonicalName

+ Type tlf.Type

+ User libkb.NormalizedUsername

+ func (e WriteAccessError) Error() string

+ type WriteRange struct

+ Len uint64

+ Off uint64

+ func (w WriteRange) Affects(other WriteRange) bool

+ func (w WriteRange) End() uint64

+ type WriteToReadonlyNodeError struct

+ Filename string

+ func (e WriteToReadonlyNodeError) Error() string

+ type WriteUnsupportedError struct

+ Filename string

+ func (e WriteUnsupportedError) Error() string

+ type WriterDeviceDateConflictRenamer struct

+ func (WriterDeviceDateConflictRenamer) ConflictRenameHelper(t time.Time, user, device, original string) string

+ func (cr WriterDeviceDateConflictRenamer) ConflictRename(ctx context.Context, op op, original string) (string, error)

+ type WrongOpsError struct

+ func (e WrongOpsError) Error() string

Incompatible versions in this module

v2.11.0+incompatible

Nov 30, 2018

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL