storage

package

Go to main page

Versions in this module

v1

v1.8.16

Jul 29, 2018

v1.8.15

Jul 11, 2018

Changes in this version

+ const DefaultChunkSize

+ 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 KeyLength

+ 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 ErrFetching = errors.New("chunk still fetching")

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

+ func IsZeroAddr(addr Address) bool

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

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

+ func PutChunks(store *LocalStore, chunks ...*Chunk)

+ type Address []byte

+ func PyramidAppend(addr Address, reader io.Reader, putter Putter, getter Getter) (Address, func(), error)

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

+ func TreeSplit(data io.Reader, size int64, putter Putter) (k Address, wait func(), 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

+ Addr Address

+ ReqC chan bool

+ func GenerateRandomChunk(dataSize int64) *Chunk

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

+ func (c *Chunk) GetErrored() error

+ func (c *Chunk) SetErrored(err error)

+ func (c *Chunk) WaitToStore() error

+ type ChunkData []byte

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

+ func (c ChunkData) Size() int64

+ 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 DBAPI struct

+ func NewDBAPI(loc *LocalStore) *DBAPI

+ func (d *DBAPI) CurrentBucketStorageIndex(po uint8) uint64

+ func (d *DBAPI) Get(addr Address) (*Chunk, error)

+ func (d *DBAPI) GetOrCreateRequest(addr Address) (*Chunk, bool)

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

+ func (d *DBAPI) Put(chunk *Chunk)

+ 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(addr Address) (reader *LazyChunkReader, isEncrypted bool)

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

+ type FileStoreParams struct

+ Hash string

+ func NewFileStoreParams() *FileStoreParams

+ type Getter interface

+ Get func(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) Cleanup()

+ func (s *LDBStore) Close()

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

+ func (s *LDBStore) CurrentStorageIndex() uint64

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

+ func (s *LDBStore) Get(addr Address) (chunk *Chunk, err error)

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

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

+ 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(addr Address, getter Getter, depth int) *LazyChunkReader

type LocalStore

+ Validators []ChunkValidator

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

+ func (ls *LocalStore) GetOrCreateRequest(addr Address) (chunk *Chunk, created bool)

+ func (ls *LocalStore) RequestsCacheLen() int

+ type LocalStoreParams struct

+ ChunkDbPath string

+ Validators []ChunkValidator

+ func NewDefaultLocalStoreParams() *LocalStoreParams

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

+ type MapChunkStore struct

+ func NewMapChunkStore() *MapChunkStore

+ func (m *MapChunkStore) Close()

+ func (m *MapChunkStore) Get(addr Address) (*Chunk, error)

+ func (m *MapChunkStore) Put(chunk *Chunk)

type NetStore

+ func (ns *NetStore) GetWithTimeout(addr Address, timeout time.Duration) (chunk *Chunk, err error)

+ type Putter interface

+ Close func()

+ Put func(ChunkData) (Reference, error)

+ RefSize func() int64

+ Wait func()

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

+ ChunkRequestsCacheCapacity uint

+ Hash SwarmHasher

+ func NewStoreParams(ldbCap uint64, cacheCap uint, requestsCap uint, hash SwarmHasher, ...) *StoreParams

type TreeChunker

+ func NewTreeJoiner(params *JoinerParams) *TreeChunker

+ func NewTreeSplitter(params *TreeSplitterParams) *TreeChunker

+ type TreeSplitterParams struct

v1.8.14

Jul 1, 2018

v1.8.13

Jun 18, 2018

v1.8.12

Jun 10, 2018

v1.8.11

Jun 7, 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

Incompatible versions in this module

v2.1.3+incompatible

Sep 10, 2018

v2.1.2+incompatible

Aug 30, 2018

v2.1.1+incompatible

Aug 22, 2018

v2.1.0+incompatible

Aug 9, 2018

v2.0.0+incompatible

Aug 1, 2018

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