blockstore

package
v0.0.0-...-484cccf Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 16, 2023 License: Apache-2.0, MIT Imports: 33 Imported by: 0

Documentation

Overview

Package blockstore and subpackages contain most of the blockstore implementations used by Lotus.

Blockstores not ultimately constructed out of the building blocks in this package may not work properly.

This package re-exports parts of the go-ipfs-blockstore package such that no other package needs to import it directly, for ergonomics and traceability.

Index

Constants

This section is empty.

Variables

View Source 
var CacheMeasures = struct {
	HitRatio       *stats.Float64Measure
	Hits           *stats.Int64Measure
	Misses         *stats.Int64Measure
	Entries        *stats.Int64Measure
	QueriesServed  *stats.Int64Measure
	Adds           *stats.Int64Measure
	Updates        *stats.Int64Measure
	Evictions      *stats.Int64Measure
	CostAdded      *stats.Int64Measure
	CostEvicted    *stats.Int64Measure
	SetsDropped    *stats.Int64Measure
	SetsRejected   *stats.Int64Measure
	QueriesDropped *stats.Int64Measure
}{
	HitRatio:       stats.Float64("blockstore/cache/hit_ratio", "Hit ratio of blockstore cache", stats.UnitDimensionless),
	Hits:           stats.Int64("blockstore/cache/hits", "Total number of hits at blockstore cache", stats.UnitDimensionless),
	Misses:         stats.Int64("blockstore/cache/misses", "Total number of misses at blockstore cache", stats.UnitDimensionless),
	Entries:        stats.Int64("blockstore/cache/entry_count", "Total number of entries currently in the blockstore cache", stats.UnitDimensionless),
	QueriesServed:  stats.Int64("blockstore/cache/queries_served", "Total number of queries served by the blockstore cache", stats.UnitDimensionless),
	Adds:           stats.Int64("blockstore/cache/adds", "Total number of adds to blockstore cache", stats.UnitDimensionless),
	Updates:        stats.Int64("blockstore/cache/updates", "Total number of updates in blockstore cache", stats.UnitDimensionless),
	Evictions:      stats.Int64("blockstore/cache/evictions", "Total number of evictions from blockstore cache", stats.UnitDimensionless),
	CostAdded:      stats.Int64("blockstore/cache/cost_added", "Total cost (byte size) of entries added into blockstore cache", stats.UnitBytes),
	CostEvicted:    stats.Int64("blockstore/cache/cost_evicted", "Total cost (byte size) of entries evicted by blockstore cache", stats.UnitBytes),
	SetsDropped:    stats.Int64("blockstore/cache/sets_dropped", "Total number of sets dropped by blockstore cache", stats.UnitDimensionless),
	SetsRejected:   stats.Int64("blockstore/cache/sets_rejected", "Total number of sets rejected by blockstore cache", stats.UnitDimensionless),
	QueriesDropped: stats.Int64("blockstore/cache/queries_dropped", "Total number of queries dropped by blockstore cache", stats.UnitDimensionless),
}

CacheMeasures groups all metrics emitted by the blockstore caches.

View Source 
var CacheMetricsEmitInterval = 5 * time.Second

CacheMetricsEmitInterval is the interval at which metrics are emitted onto OpenCensus.

View Source 
var (
	CacheName, _ = tag.NewKey("cache_name")
)
View Source 
var CacheViews = struct {
	HitRatio       *view.View
	Hits           *view.View
	Misses         *view.View
	Entries        *view.View
	QueriesServed  *view.View
	Adds           *view.View
	Updates        *view.View
	Evictions      *view.View
	CostAdded      *view.View
	CostEvicted    *view.View
	SetsDropped    *view.View
	SetsRejected   *view.View
	QueriesDropped *view.View
}{
	HitRatio: &view.View{
		Measure:     CacheMeasures.HitRatio,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	Hits: &view.View{
		Measure:     CacheMeasures.Hits,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	Misses: &view.View{
		Measure:     CacheMeasures.Misses,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	Entries: &view.View{
		Measure:     CacheMeasures.Entries,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	QueriesServed: &view.View{
		Measure:     CacheMeasures.QueriesServed,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	Adds: &view.View{
		Measure:     CacheMeasures.Adds,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	Updates: &view.View{
		Measure:     CacheMeasures.Updates,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	Evictions: &view.View{
		Measure:     CacheMeasures.Evictions,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	CostAdded: &view.View{
		Measure:     CacheMeasures.CostAdded,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	CostEvicted: &view.View{
		Measure:     CacheMeasures.CostEvicted,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	SetsDropped: &view.View{
		Measure:     CacheMeasures.SetsDropped,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	SetsRejected: &view.View{
		Measure:     CacheMeasures.SetsRejected,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
	QueriesDropped: &view.View{
		Measure:     CacheMeasures.QueriesDropped,
		Aggregation: view.LastValue(),
		TagKeys:     []tag.Key{CacheName},
	},
}

CacheViews groups all cache-related default views.

View Source 
var DefaultViews = []*view.View{
	CacheViews.HitRatio,
	CacheViews.Hits,
	CacheViews.Misses,
	CacheViews.Entries,
	CacheViews.QueriesServed,
	CacheViews.Adds,
	CacheViews.Updates,
	CacheViews.Evictions,
	CacheViews.CostAdded,
	CacheViews.CostEvicted,
	CacheViews.SetsDropped,
	CacheViews.SetsRejected,
	CacheViews.QueriesDropped,
}

DefaultViews exports all default views for this package.

Functions

func IsHotView 

func IsHotView(ctx context.Context) bool

IsHotView returns true if the hot view option is set in the context

func WithHotView 

func WithHotView(ctx context.Context) context.Context

WithHotView constructs a new context with an option that provides a hint to the blockstore (e.g. the splitstore) that the object (and its ipld references) should be kept hot.

Types

type AutobatchBlockstore 

type AutobatchBlockstore struct {
	// contains filtered or unexported fields
}

func NewAutobatch 

func NewAutobatch(ctx context.Context, backingBs Blockstore, bufferCapacity int) *AutobatchBlockstore

func (*AutobatchBlockstore) AllKeysChan 

func (bs *AutobatchBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)

func (*AutobatchBlockstore) DeleteBlock 

func (bs *AutobatchBlockstore) DeleteBlock(context.Context, cid.Cid) error

func (*AutobatchBlockstore) DeleteMany 

func (bs *AutobatchBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) error

func (*AutobatchBlockstore) Flush 

func (bs *AutobatchBlockstore) Flush(ctx context.Context) error

caller must NOT hold stateLock

func (*AutobatchBlockstore) Get 

func (bs *AutobatchBlockstore) Get(ctx context.Context, c cid.Cid) (block.Block, error)

func (*AutobatchBlockstore) GetSize 

func (bs *AutobatchBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error)

func (*AutobatchBlockstore) Has 

func (bs *AutobatchBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error)

func (*AutobatchBlockstore) HashOnRead 

func (bs *AutobatchBlockstore) HashOnRead(enabled bool)

func (*AutobatchBlockstore) Put 

func (bs *AutobatchBlockstore) Put(ctx context.Context, blk block.Block) error

func (*AutobatchBlockstore) PutMany 

func (bs *AutobatchBlockstore) PutMany(ctx context.Context, blks []block.Block) error

func (*AutobatchBlockstore) Shutdown 

func (bs *AutobatchBlockstore) Shutdown(ctx context.Context) error

func (*AutobatchBlockstore) View 

func (bs *AutobatchBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) error

type BasicBlockstore 

type BasicBlockstore = blockstore.Blockstore

BasicBlockstore is an alias to the original IPFS Blockstore.

type BatchDeleter 

type BatchDeleter interface {
	DeleteMany(ctx context.Context, cids []cid.Cid) error
}

type Blockstore 

type Blockstore interface {
	blockstore.Blockstore
	blockstore.Viewer
	BatchDeleter
	Flusher
}

Blockstore is the blockstore interface used by Lotus. It is the union of the basic go-ipfs blockstore, with other capabilities required by Lotus, e.g. View or Sync.

func Adapt 

func Adapt(bs blockstore.Blockstore) Blockstore

Adapt adapts a standard blockstore to a Lotus blockstore by enriching it with the extra methods that Lotus requires (e.g. View, Sync).

View proxies over to Get and calls the callback with the value supplied by Get. Sync noops.

func FromDatastore 

func FromDatastore(dstore ds.Batching) Blockstore

FromDatastore creates a new blockstore backed by the given datastore.

func NewAPIBlockstore 

func NewAPIBlockstore(cio ChainIO) Blockstore

func NewDiscardStore 

func NewDiscardStore(bs Blockstore) Blockstore

func NewIDStore 

func NewIDStore(bs Blockstore) Blockstore

func NewLocalIPFSBlockstore 

func NewLocalIPFSBlockstore(ctx context.Context, onlineMode bool) (Blockstore, error)

func NewRemoteIPFSBlockstore 

func NewRemoteIPFSBlockstore(ctx context.Context, maddr multiaddr.Multiaddr, onlineMode bool) (Blockstore, error)

func Union 

func Union(stores ...Blockstore) Blockstore

Union returns an unioned blockstore.

  • Reads return from the first blockstore that has the value, querying in the supplied order.
  • Writes (puts and deletes) are broadcast to all stores.

func UnwrapFallbackStore 

func UnwrapFallbackStore(bs Blockstore) (Blockstore, bool)

UnwrapFallbackStore takes a blockstore, and returns the underlying blockstore if it was a FallbackStore. Otherwise, it just returns the supplied store unmodified.

func WrapIDStore 

func WrapIDStore(bstore blockstore.Blockstore) Blockstore

WrapIDStore wraps the underlying blockstore in an "identity" blockstore. The ID store filters out all puts for blocks with CIDs using the "identity" hash function. It also extracts inlined blocks from CIDs using the identity hash function and returns them on get/has, ignoring the contents of the blockstore.

type BlockstoreGC 

type BlockstoreGC interface {
	CollectGarbage(ctx context.Context, options ...BlockstoreGCOption) error
}

BlockstoreGC is a trait for blockstores that support online garbage collection

type BlockstoreGCOnce 

type BlockstoreGCOnce interface {
	GCOnce(ctx context.Context, options ...BlockstoreGCOption) error
}

BlockstoreGCOnce is a trait for a blockstore that supports incremental online garbage collection

type BlockstoreGCOption 

type BlockstoreGCOption = func(*BlockstoreGCOptions) error

BlockstoreGCOption is a functional interface for controlling blockstore GC options

func WithFullGC 

func WithFullGC(fullgc bool) BlockstoreGCOption

func WithThreshold 

func WithThreshold(threshold float64) BlockstoreGCOption

type BlockstoreGCOptions 

type BlockstoreGCOptions struct {
	FullGC bool
	// fraction of garbage in badger vlog before its worth processing in online GC
	Threshold float64
}

BlockstoreGCOptions is a struct with GC options

type BlockstoreIterator 

type BlockstoreIterator interface {
	ForEachKey(func(cid.Cid) error) error
}

BlockstoreIterator is a trait for efficient iteration

type BlockstoreSize 

type BlockstoreSize interface {
	Size() (int64, error)
}

BlockstoreSize is a trait for on-disk blockstores that can report their size

type BufferedBlockstore 

type BufferedBlockstore struct {
	// contains filtered or unexported fields
}

func NewBuffered 

func NewBuffered(base Blockstore) *BufferedBlockstore

func NewTieredBstore 

func NewTieredBstore(r Blockstore, w Blockstore) *BufferedBlockstore

func (*BufferedBlockstore) AllKeysChan 

func (bs *BufferedBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)

func (*BufferedBlockstore) DeleteBlock 

func (bs *BufferedBlockstore) DeleteBlock(ctx context.Context, c cid.Cid) error

func (*BufferedBlockstore) DeleteMany 

func (bs *BufferedBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) error

func (*BufferedBlockstore) Flush 

func (bs *BufferedBlockstore) Flush(ctx context.Context) error

func (*BufferedBlockstore) Get 

func (bs *BufferedBlockstore) Get(ctx context.Context, c cid.Cid) (block.Block, error)

func (*BufferedBlockstore) GetSize 

func (bs *BufferedBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error)

func (*BufferedBlockstore) Has 

func (bs *BufferedBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error)

func (*BufferedBlockstore) HashOnRead 

func (bs *BufferedBlockstore) HashOnRead(hor bool)

func (*BufferedBlockstore) Put 

func (bs *BufferedBlockstore) Put(ctx context.Context, blk block.Block) error

func (*BufferedBlockstore) PutMany 

func (bs *BufferedBlockstore) PutMany(ctx context.Context, blks []block.Block) error

func (*BufferedBlockstore) Read 

func (bs *BufferedBlockstore) Read() Blockstore

func (*BufferedBlockstore) View 

func (bs *BufferedBlockstore) View(ctx context.Context, c cid.Cid, callback func([]byte) error) error

type ChainIO 

type ChainIO interface {
	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
	ChainHasObj(context.Context, cid.Cid) (bool, error)
	ChainPutObj(context.Context, blocks.Block) error
}

type FallbackStore 

type FallbackStore struct {
	Blockstore
	// contains filtered or unexported fields
}

FallbackStore is a read-through store that queries another (potentially remote) source if the block is not found locally. If the block is found during the fallback, it stores it in the local store.

func (*FallbackStore) Get 

func (fbs *FallbackStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error)

func (*FallbackStore) GetSize 

func (fbs *FallbackStore) GetSize(ctx context.Context, c cid.Cid) (int, error)

func (*FallbackStore) SetFallback 

func (fbs *FallbackStore) SetFallback(missFn func(context.Context, cid.Cid) (blocks.Block, error))

type Flusher 

type Flusher interface {
	Flush(context.Context) error
}

type IPFSBlockstore 

type IPFSBlockstore struct {
	// contains filtered or unexported fields
}

func (*IPFSBlockstore) AllKeysChan 

func (i *IPFSBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)

func (*IPFSBlockstore) DeleteBlock 

func (i *IPFSBlockstore) DeleteBlock(ctx context.Context, cid cid.Cid) error

func (*IPFSBlockstore) Get 

func (i *IPFSBlockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error)

func (*IPFSBlockstore) GetSize 

func (i *IPFSBlockstore) GetSize(ctx context.Context, cid cid.Cid) (int, error)

func (*IPFSBlockstore) Has 

func (i *IPFSBlockstore) Has(ctx context.Context, cid cid.Cid) (bool, error)

func (*IPFSBlockstore) HashOnRead 

func (i *IPFSBlockstore) HashOnRead(enabled bool)

func (*IPFSBlockstore) Put 

func (i *IPFSBlockstore) Put(ctx context.Context, block blocks.Block) error

func (*IPFSBlockstore) PutMany 

func (i *IPFSBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error

type MemBlockstore 

type MemBlockstore map[string]blocks.Block

MemBlockstore is a terminal blockstore that keeps blocks in memory. To match behavior of badger blockstore we index by multihash only.

func NewMemory 

func NewMemory() MemBlockstore

NewMemory returns a temporary memory-backed blockstore.

func (MemBlockstore) AllKeysChan 

func (m MemBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)

AllKeysChan returns a channel from which the CIDs in the Blockstore can be read. It should respect the given context, closing the channel if it becomes Done.

func (MemBlockstore) DeleteBlock 

func (m MemBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error

func (MemBlockstore) DeleteMany 

func (m MemBlockstore) DeleteMany(ctx context.Context, ks []cid.Cid) error

func (MemBlockstore) Flush 

func (MemBlockstore) Flush(context.Context) error

func (MemBlockstore) Get 

func (m MemBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block, error)

func (MemBlockstore) GetSize 

func (m MemBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error)

GetSize returns the CIDs mapped BlockSize

func (MemBlockstore) Has 

func (m MemBlockstore) Has(ctx context.Context, k cid.Cid) (bool, error)

func (MemBlockstore) HashOnRead 

func (m MemBlockstore) HashOnRead(enabled bool)

HashOnRead specifies if every read block should be rehashed to make sure it matches its CID.

func (MemBlockstore) Put 

func (m MemBlockstore) Put(ctx context.Context, b blocks.Block) error

Put puts a given block to the underlying datastore

func (MemBlockstore) PutMany 

func (m MemBlockstore) PutMany(ctx context.Context, bs []blocks.Block) error

PutMany puts a slice of blocks at the same time using batching capabilities of the underlying datastore whenever possible.

func (MemBlockstore) View 

func (m MemBlockstore) View(ctx context.Context, k cid.Cid, callback func([]byte) error) error

type NetRPCErrType 

type NetRPCErrType byte
const (
	NRpcErrGeneric NetRPCErrType = iota
	NRpcErrNotFound
)

type NetRPCReqType 

type NetRPCReqType byte
const (
	NRpcHas NetRPCReqType = iota
	NRpcGet
	NRpcGetSize
	NRpcPut
	NRpcDelete
)

type NetRPCRespType 

type NetRPCRespType byte
const (
	NRpcOK NetRPCRespType = iota
	NRpcErr
	NRpcMore
)

type NetRpcErr 

type NetRpcErr struct {
	Type NetRPCErrType

	Msg string

	// in case of NRpcErrNotFound
	Cid *cid.Cid
}

func (*NetRpcErr) MarshalCBOR 

func (t *NetRpcErr) MarshalCBOR(w io.Writer) error

func (*NetRpcErr) UnmarshalCBOR 

func (t *NetRpcErr) UnmarshalCBOR(r io.Reader) (err error)

type NetRpcReq 

type NetRpcReq struct {
	Type NetRPCReqType
	ID   uint64

	Cid  []cid.Cid // todo maxsize?
	Data [][]byte  // todo maxsize?
}

func (*NetRpcReq) MarshalCBOR 

func (t *NetRpcReq) MarshalCBOR(w io.Writer) error

func (*NetRpcReq) UnmarshalCBOR 

func (t *NetRpcReq) UnmarshalCBOR(r io.Reader) (err error)

type NetRpcResp 

type NetRpcResp struct {
	Type NetRPCRespType
	ID   uint64

	// error or cids in allkeys
	Data []byte // todo maxsize?
	// contains filtered or unexported fields
}

func (*NetRpcResp) MarshalCBOR 

func (t *NetRpcResp) MarshalCBOR(w io.Writer) error

func (*NetRpcResp) UnmarshalCBOR 

func (t *NetRpcResp) UnmarshalCBOR(r io.Reader) (err error)

type NetworkStore 

type NetworkStore struct {
	// contains filtered or unexported fields
}

func NewNetworkStore 

func NewNetworkStore(mss msgio.ReadWriteCloser) *NetworkStore

func NewNetworkStoreWS 

func NewNetworkStoreWS(wc *websocket.Conn) *NetworkStore

func (*NetworkStore) AllKeysChan 

func (n *NetworkStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)

func (*NetworkStore) DeleteBlock 

func (n *NetworkStore) DeleteBlock(ctx context.Context, c cid.Cid) error

func (*NetworkStore) DeleteMany 

func (n *NetworkStore) DeleteMany(ctx context.Context, cids []cid.Cid) error

func (*NetworkStore) Flush 

func (*NetworkStore) Flush(context.Context) error

func (*NetworkStore) Get 

func (n *NetworkStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error)

func (*NetworkStore) GetSize 

func (n *NetworkStore) GetSize(ctx context.Context, c cid.Cid) (int, error)

func (*NetworkStore) Has 

func (n *NetworkStore) Has(ctx context.Context, c cid.Cid) (bool, error)

func (*NetworkStore) HashOnRead 

func (n *NetworkStore) HashOnRead(enabled bool)

func (*NetworkStore) OnClose 

func (n *NetworkStore) OnClose(cb func())

func (*NetworkStore) Put 

func (n *NetworkStore) Put(ctx context.Context, block blocks.Block) error

func (*NetworkStore) PutMany 

func (n *NetworkStore) PutMany(ctx context.Context, blocks []blocks.Block) error

func (*NetworkStore) Stop 

func (n *NetworkStore) Stop(ctx context.Context) error

func (*NetworkStore) View 

func (n *NetworkStore) View(ctx context.Context, c cid.Cid, callback func([]byte) error) error

type NetworkStoreHandler 

type NetworkStoreHandler struct {
	// contains filtered or unexported fields
}

func HandleNetBstoreStream 

func HandleNetBstoreStream(ctx context.Context, bs Blockstore, mss msgio.ReadWriteCloser) *NetworkStoreHandler

NOTE: This code isn't yet hardened to accept untrusted input. See TODOs here and in net.go

func HandleNetBstoreWS 

func HandleNetBstoreWS(ctx context.Context, bs Blockstore, wc *websocket.Conn) *NetworkStoreHandler

type SyncBlockstore 

type SyncBlockstore struct {
	// contains filtered or unexported fields
}

SyncBlockstore is a terminal blockstore that is a synchronized version of MemBlockstore.

func NewMemorySync 

func NewMemorySync() *SyncBlockstore

NewMemorySync returns a thread-safe in-memory blockstore.

func (*SyncBlockstore) AllKeysChan 

func (m *SyncBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)

func (*SyncBlockstore) DeleteBlock 

func (m *SyncBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error

func (*SyncBlockstore) DeleteMany 

func (m *SyncBlockstore) DeleteMany(ctx context.Context, ks []cid.Cid) error

func (*SyncBlockstore) Flush 

func (*SyncBlockstore) Flush(context.Context) error

func (*SyncBlockstore) Get 

func (m *SyncBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block, error)

func (*SyncBlockstore) GetSize 

func (m *SyncBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error)

func (*SyncBlockstore) Has 

func (m *SyncBlockstore) Has(ctx context.Context, k cid.Cid) (bool, error)

func (*SyncBlockstore) HashOnRead 

func (m *SyncBlockstore) HashOnRead(enabled bool)

func (*SyncBlockstore) Put 

func (m *SyncBlockstore) Put(ctx context.Context, b blocks.Block) error

func (*SyncBlockstore) PutMany 

func (m *SyncBlockstore) PutMany(ctx context.Context, bs []blocks.Block) error

func (*SyncBlockstore) View 

func (m *SyncBlockstore) View(ctx context.Context, k cid.Cid, callback func([]byte) error) error

type TimedCacheBlockstore 

type TimedCacheBlockstore struct {
	// contains filtered or unexported fields
}

TimedCacheBlockstore is a blockstore that keeps blocks for at least the specified caching interval before discarding them. Garbage collection must be started and stopped by calling Start/Stop.

Under the covers, it's implemented with an active and an inactive blockstore that are rotated every cache time interval. This means all blocks will be stored at most 2x the cache interval.

Create a new instance by calling the NewTimedCacheBlockstore constructor.

func NewTimedCacheBlockstore 

func NewTimedCacheBlockstore(interval time.Duration) *TimedCacheBlockstore

func (*TimedCacheBlockstore) AllKeysChan 

func (t *TimedCacheBlockstore) AllKeysChan(_ context.Context) (<-chan cid.Cid, error)

func (*TimedCacheBlockstore) DeleteBlock 

func (t *TimedCacheBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error

func (*TimedCacheBlockstore) DeleteMany 

func (t *TimedCacheBlockstore) DeleteMany(ctx context.Context, ks []cid.Cid) error

func (*TimedCacheBlockstore) Flush 

func (t *TimedCacheBlockstore) Flush(ctx context.Context) error

func (*TimedCacheBlockstore) Get 

func (t *TimedCacheBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block, error)

func (*TimedCacheBlockstore) GetSize 

func (t *TimedCacheBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error)

func (*TimedCacheBlockstore) Has 

func (t *TimedCacheBlockstore) Has(ctx context.Context, k cid.Cid) (bool, error)

func (*TimedCacheBlockstore) HashOnRead 

func (t *TimedCacheBlockstore) HashOnRead(_ bool)

func (*TimedCacheBlockstore) Put 

func (t *TimedCacheBlockstore) Put(ctx context.Context, b blocks.Block) error

func (*TimedCacheBlockstore) PutMany 

func (t *TimedCacheBlockstore) PutMany(ctx context.Context, bs []blocks.Block) error

func (*TimedCacheBlockstore) Start 

func (t *TimedCacheBlockstore) Start(_ context.Context) error

func (*TimedCacheBlockstore) Stop 

func (t *TimedCacheBlockstore) Stop(_ context.Context) error

func (*TimedCacheBlockstore) View 

func (t *TimedCacheBlockstore) View(ctx context.Context, k cid.Cid, callback func([]byte) error) error

type Viewer 

type Viewer = blockstore.Viewer

Source Files

View all Source files

Directories

Path Synopsis
stm: #unit
 stm: #unit

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.