storage

package

Go to main page

Versions in this module

v0

v0.3.13

Apr 12, 2019

v0.3.12

Apr 9, 2019

Changes in this version

type ChunkStore

+ Has func(rctx context.Context, ref Address) bool

type FakeChunkStore

+ func (f *FakeChunkStore) Has(_ context.Context, ref Address) bool

type FileStore

+ func (f *FileStore) GetAllReferences(ctx context.Context, data io.Reader, toEncrypt bool) (addrs AddressCollection, err error)

type LDBStore

+ func (s *LDBStore) Has(_ context.Context, addr Address) bool

type LocalStore

+ func (ls *LocalStore) Has(ctx context.Context, addr Address) bool

type MemStore

+ func (m *MemStore) Has(_ context.Context, addr Address) bool

type NetStore

+ func (n *NetStore) Has(ctx context.Context, ref Address) bool

v0.3.12-test2

Mar 26, 2019

v0.3.12-test

Mar 25, 2019

v0.3.12-compat

Mar 27, 2019

v0.3.12-beta2

Apr 8, 2019

v0.3.12-beta

Apr 4, 2019

v0.3.12-appveyor

Mar 26, 2019

v0.3.11

Feb 1, 2019

v0.3.10

Dec 13, 2018

v0.3.9

Nov 29, 2018

v0.3.8

Nov 14, 2018

Changes in this version

+ const DbSchemaHalloween

+ const DbSchemaNone

type LDBStore

+ func (s *LDBStore) CleanGCIndex() error

+ func (s *LDBStore) MarkAccessed(addr Address)

v0.3.7

Nov 5, 2018

Changes in this version

+ const AddressLength

+ const CurrentDbSchema

+ const DbSchemaPurity

+ const DefaultHash

+ const ErrCnt

+ const ErrCorruptData

+ const ErrDataOverflow

+ const ErrIO

+ const ErrInit

+ const ErrInvalidSignature

+ const ErrInvalidValue

+ const ErrNotFound

+ const ErrNotSynced

+ const ErrNothingToReturn

+ const ErrPeriodDepth

+ const ErrUnauthorized

+ const MaxPO

+ var ErrChunkForward = errors.New("cannot forward")

+ var ErrChunkInvalid = errors.New("invalid chunk")

+ var ErrChunkNotFound = errors.New("chunk not found")

+ var ErrChunkTimeout = errors.New("timeout")

+ var ErrChunkUnavailable = errors.New("chunk unavailable")

+ var ErrDBClosed = errors.New("LDBStore closed")

+ var ErrFetching = errors.New("chunk still fetching")

+ var ZeroAddr = Address(common.Hash{}.Bytes())

+ func GenerateRandomData(l int) (r io.Reader, slice []byte)

+ func IsZeroAddr(addr Address) bool

+ func NewHasherStore(store ChunkStore, hashFunc SwarmHasher, toEncrypt bool) *hasherStore

+ func Proximity(one, other []byte) (ret int)

+ type Address []byte

+ func PyramidAppend(ctx context.Context, addr Address, reader io.Reader, putter Putter, ...) (Address, func(context.Context) error, error)

+ func PyramidSplit(ctx context.Context, reader io.Reader, putter Putter, getter Getter) (Address, func(context.Context) error, error)

+ func TreeSplit(ctx context.Context, data io.Reader, size int64, putter Putter) (k Address, wait func(context.Context) error, err error)

+ func (a *Address) UnmarshalJSON(value []byte) error

+ func (a Address) Hex() string

+ func (a Address) Log() string

+ func (a Address) MarshalJSON() (out []byte, err error)

+ func (a Address) Size() uint

+ func (a Address) String() string

+ type AddressCollection []Address

+ func NewAddressCollection(l int) AddressCollection

+ func (c AddressCollection) Len() int

+ func (c AddressCollection) Less(i, j int) bool

+ func (c AddressCollection) Swap(i, j int)

type Chunk

+ func GenerateRandomChunk(dataSize int64) Chunk

+ func GenerateRandomChunks(dataSize int64, count int) (chunks []Chunk)

+ Address func() Address

+ Data func() []byte

+ Payload func() []byte

+ Span func() int64

+ SpanBytes func() []byte

+ type ChunkData []byte

+ func (c ChunkData) Data() []byte

+ func (c ChunkData) Size() uint64

+ type ChunkValidator interface

+ Validate func(addr Address, data []byte) bool

+ type ContentAddressValidator struct

+ Hasher SwarmHasher

+ func NewContentAddressValidator(hasher SwarmHasher) *ContentAddressValidator

+ func (v *ContentAddressValidator) Validate(addr Address, data []byte) bool

+ type FakeChunkStore struct

+ func (f *FakeChunkStore) Close()

+ func (f *FakeChunkStore) Get(_ context.Context, ref Address) (Chunk, error)

+ func (f *FakeChunkStore) Put(_ context.Context, ch Chunk) error

+ type FileStore struct

+ func NewFileStore(store ChunkStore, params *FileStoreParams) *FileStore

+ func NewLocalFileStore(datadir string, basekey []byte) (*FileStore, error)

+ func (f *FileStore) HashSize() int

+ func (f *FileStore) Retrieve(ctx context.Context, addr Address) (reader *LazyChunkReader, isEncrypted bool)

+ func (f *FileStore) Store(ctx context.Context, data io.Reader, size int64, toEncrypt bool) (addr Address, wait func(context.Context) error, err error)

+ type FileStoreParams struct

+ Hash string

+ func NewFileStoreParams() *FileStoreParams

+ type Getter interface

+ Get func(context.Context, Reference) (ChunkData, error)

+ type JoinerParams struct

+ type LDBStore struct

+ func NewLDBStore(params *LDBStoreParams) (s *LDBStore, err error)

+ func NewMockDbStore(params *LDBStoreParams, mockStore *mock.NodeStore) (s *LDBStore, err error)

+ func (s *LDBStore) BinIndex(po uint8) uint64

+ func (s *LDBStore) Cleanup(f func(*chunk) bool)

+ func (s *LDBStore) Close()

+ func (s *LDBStore) CurrentStorageIndex() uint64

+ func (s *LDBStore) Delete(addr Address)

+ func (s *LDBStore) Export(out io.Writer) (int64, error)

+ func (s *LDBStore) Get(_ context.Context, addr Address) (chunk Chunk, err error)

+ func (s *LDBStore) GetSchema() (string, error)

+ func (s *LDBStore) Import(in io.Reader) (int64, error)

+ func (s *LDBStore) Put(ctx context.Context, chunk Chunk) error

+ func (s *LDBStore) PutSchema(schema string) error

+ func (s *LDBStore) ReIndex()

+ func (s *LDBStore) Size() uint64

+ func (s *LDBStore) SyncIterator(since uint64, until uint64, po uint8, f func(Address, uint64) bool) error

+ type LDBStoreParams struct

+ Path string

+ Po func(Address) uint8

+ func NewLDBStoreParams(storeparams *StoreParams, path string) *LDBStoreParams

type LazyChunkReader

+ func TreeJoin(ctx context.Context, addr Address, getter Getter, depth int) *LazyChunkReader

+ func (r *LazyChunkReader) Context() context.Context

type LazySectionReader

+ Context func() context.Context

type LazyTestSectionReader

+ func (r *LazyTestSectionReader) Context() context.Context

type LocalStore

+ Validators []ChunkValidator

+ func NewTestLocalStoreForAddr(params *LocalStoreParams) (*LocalStore, error)

+ func (ls *LocalStore) BinIndex(po uint8) uint64

+ func (ls *LocalStore) FetchFunc(ctx context.Context, addr Address) func(context.Context) error

+ func (ls *LocalStore) Iterator(from uint64, to uint64, po uint8, f func(Address, uint64) bool) error

+ func (ls *LocalStore) Migrate() error

+ type LocalStoreParams struct

+ ChunkDbPath string

+ Validators []ChunkValidator

+ func NewDefaultLocalStoreParams() *LocalStoreParams

+ func (p *LocalStoreParams) Init(path string)

+ type NetFetcher interface

+ Offer func(ctx context.Context, source *enode.ID)

+ Request func(ctx context.Context, hopCount uint8)

type NetStore

+ NewNetFetcherFunc NewNetFetcherFunc

+ func (n *NetStore) BinIndex(po uint8) uint64

+ func (n *NetStore) FetchFunc(ctx context.Context, ref Address) func(context.Context) error

+ func (n *NetStore) Iterator(from uint64, to uint64, po uint8, f func(Address, uint64) bool) error

+ func (n *NetStore) RequestsCacheLen() int

+ type NewNetFetcherFunc func(ctx context.Context, addr Address, peers *sync.Map) NetFetcher

+ type Putter interface

+ Close func()

+ Put func(context.Context, ChunkData) (Reference, error)

+ RefSize func() int64

+ Wait func(context.Context) error

type PyramidChunker

+ func NewPyramidSplitter(params *PyramidSplitterParams) (pc *PyramidChunker)

+ type PyramidSplitterParams struct

+ func NewPyramidSplitterParams(addr Address, reader io.Reader, putter Putter, getter Getter, chunkSize int64) *PyramidSplitterParams

+ type Reference []byte

+ type SplitterParams struct

type StoreParams

+ BaseKey []byte

+ Hash SwarmHasher

+ func NewStoreParams(ldbCap uint64, cacheCap uint, hash SwarmHasher, basekey []byte) *StoreParams

+ type SyncChunkStore interface

+ BinIndex func(po uint8) uint64

+ FetchFunc func(ctx context.Context, ref Address) func(context.Context) error

+ Iterator func(from uint64, to uint64, po uint8, f func(Address, uint64) bool) error

type TreeChunker

+ func NewTreeJoiner(params *JoinerParams) *TreeChunker

+ func NewTreeSplitter(params *TreeSplitterParams) *TreeChunker

+ type TreeSplitterParams struct

v0.3.2

Oct 17, 2018

Changes in this version

+ const BMTHash

+ const ChunkProcessors

+ const DataChunk

+ const DefaultBranches

+ const SHA3Hash

+ const TreeChunk

+ var ZeroKey = Key(common.Hash{}.Bytes())

+ func BytesToU64(data []byte) uint64

+ func IsZeroKey(key Key) bool

+ func NewDpaChunkStore(localStore, netStore ChunkStore) *dpaChunkStore

+ func U64ToBytes(val uint64) []byte

+ type Chunk struct

+ C chan bool

+ Key Key

+ Req *RequestStatus

+ SData []byte

+ Size int64

+ Source Peer

+ func NewChunk(key Key, rs *RequestStatus) *Chunk

+ func (self *Chunk) String() string

+ type ChunkStore interface

+ Close func()

+ Get func(Key) (*Chunk, error)

+ Put func(*Chunk)

+ type Chunker interface

+ type ChunkerParams struct

+ Branches int64

+ Hash string

+ func NewChunkerParams() *ChunkerParams

+ type CloudStore interface

+ Deliver func(*Chunk)

+ Retrieve func(*Chunk)

+ Store func(*Chunk)

+ type DPA struct

+ Chunker Chunker

+ func NewDPA(store ChunkStore, params *ChunkerParams) *DPA

+ func NewLocalDPA(datadir string) (*DPA, error)

+ func (self *DPA) Retrieve(key Key) LazySectionReader

+ func (self *DPA) Start()

+ func (self *DPA) Stop()

+ func (self *DPA) Store(data io.Reader, size int64, swg *sync.WaitGroup, wwg *sync.WaitGroup) (key Key, err error)

+ type DbStore struct

+ func NewDbStore(path string, hash SwarmHasher, capacity uint64, radius int) (s *DbStore, err error)

+ func (s *DbStore) Cleanup()

+ func (s *DbStore) Close()

+ func (s *DbStore) Counter() uint64

+ func (s *DbStore) Export(out io.Writer) (int64, error)

+ func (s *DbStore) Get(key Key) (chunk *Chunk, err error)

+ func (s *DbStore) Import(in io.Reader) (int64, error)

+ func (s *DbStore) Put(chunk *Chunk)

+ func (self *DbStore) NewSyncIterator(state DbSyncState) (si *dbSyncIterator, err error)

+ type DbSyncState struct

+ First uint64

+ Last uint64

+ Start Key

+ Stop Key

+ type HashWithLength struct

+ func (self *HashWithLength) ResetWithLength(length []byte)

+ type Hasher func() hash.Hash

+ type Joiner interface

+ Join func(key Key, chunkC chan *Chunk) LazySectionReader

+ type Key []byte

+ func (key *Key) UnmarshalJSON(value []byte) error

+ func (key Key) Hex() string

+ func (key Key) Log() string

+ func (key Key) MarshalJSON() (out []byte, err error)

+ func (key Key) String() string

+ func (x Key) Size() uint

+ type LDBDatabase struct

+ func NewLDBDatabase(file string) (*LDBDatabase, error)

+ func (self *LDBDatabase) Close()

+ func (self *LDBDatabase) Delete(key []byte) error

+ func (self *LDBDatabase) Get(key []byte) ([]byte, error)

+ func (self *LDBDatabase) LastKnownTD() []byte

+ func (self *LDBDatabase) NewIterator() iterator.Iterator

+ func (self *LDBDatabase) Put(key []byte, value []byte)

+ func (self *LDBDatabase) Write(batch *leveldb.Batch) error

+ type LazyChunkReader struct

+ func (s *LazyChunkReader) Seek(offset int64, whence int) (int64, error)

+ func (self *LazyChunkReader) Read(b []byte) (read int, err error)

+ func (self *LazyChunkReader) ReadAt(b []byte, off int64) (read int, err error)

+ func (self *LazyChunkReader) Size(quitC chan bool) (n int64, err error)

+ type LazySectionReader interface

+ Size func(chan bool) (int64, error)

+ type LazyTestSectionReader struct

+ func (self *LazyTestSectionReader) Size(chan bool) (int64, error)

+ type LocalStore struct

+ DbStore ChunkStore

+ func NewLocalStore(hash SwarmHasher, params *StoreParams) (*LocalStore, error)

+ func (self *LocalStore) CacheCounter() uint64

+ func (self *LocalStore) Close()

+ func (self *LocalStore) DbCounter() uint64

+ func (self *LocalStore) Get(key Key) (chunk *Chunk, err error)

+ func (self *LocalStore) Put(chunk *Chunk)

+ type MemStore struct

+ func NewMemStore(d *DbStore, capacity uint) (m *MemStore)

+ func (s *MemStore) Close()

+ func (s *MemStore) Counter() uint

+ func (s *MemStore) Get(hash Key) (chunk *Chunk, err error)

+ func (s *MemStore) Put(entry *Chunk)

+ type NetStore struct

+ func NewNetStore(hash SwarmHasher, lstore *LocalStore, cloud CloudStore, params *StoreParams) *NetStore

+ func (self *NetStore) Close()

+ func (self *NetStore) Get(key Key) (*Chunk, error)

+ func (self *NetStore) Put(entry *Chunk)

+ type Peer interface

+ type PyramidChunker struct

+ func NewPyramidChunker(params *ChunkerParams) (self *PyramidChunker)

+ func (self *PyramidChunker) Append(key Key, data io.Reader, chunkC chan *Chunk, ...) (Key, error)

+ func (self *PyramidChunker) Join(key Key, chunkC chan *Chunk) LazySectionReader

+ func (self *PyramidChunker) Split(data io.Reader, size int64, chunkC chan *Chunk, ...) (Key, error)

+ type RequestStatus struct

+ C chan bool

+ Key Key

+ Requesters map[uint64][]interface{}

+ Source Peer

+ type Splitter interface

+ Append func(Key, io.Reader, chan *Chunk, *sync.WaitGroup, *sync.WaitGroup) (Key, error)

+ Split func(io.Reader, int64, chan *Chunk, *sync.WaitGroup, *sync.WaitGroup) (Key, error)

+ type StoreParams struct

+ CacheCapacity uint

+ ChunkDbPath string

+ DbCapacity uint64

+ Radius int

+ func NewDefaultStoreParams() (self *StoreParams)

+ func (self *StoreParams) Init(path string)

+ type SwarmHash interface

+ ResetWithLength func([]byte)

+ type SwarmHasher func() SwarmHash

+ func MakeHashFunc(hash string) SwarmHasher

+ type TreeChunker struct

+ func NewTreeChunker(params *ChunkerParams) (self *TreeChunker)

+ func (self *TreeChunker) Append(key Key, data io.Reader, chunkC chan *Chunk, swg, wwg *sync.WaitGroup) (Key, error)

+ func (self *TreeChunker) Join(key Key, chunkC chan *Chunk) LazySectionReader

+ func (self *TreeChunker) Split(data io.Reader, size int64, chunkC chan *Chunk, swg, wwg *sync.WaitGroup) (Key, error)

+ type TreeEntry struct

+ func NewTreeEntry(pyramid *PyramidChunker) *TreeEntry

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL