mock

Documentation

Overview

Package mock defines types that are used by different implementations of mock storages.

Implementations of mock storages are located in directories under this package:

• db - LevelDB backend
• mem - in memory map backend
• rpc - RPC client that can connect to other backends

Mock storages can implement Importer and Exporter interfaces for importing and exporting all chunk data that they contain. The exported file is a tar archive with all files named by hexadecimal representations of chunk keys and with content with JSON-encoded ExportedChunk structure. Exported format should be preserved across all mock store implementations.

Index

• Variables
• type ExportedChunk
• type Exporter
• type GlobalStorer
• type ImportExporter
• type Importer
• type NodeStore
  • func NewNodeStore(addr common.Address, store GlobalStorer) *NodeStore
  • func (n *NodeStore) Delete(key []byte) error
  • func (n *NodeStore) Get(key []byte) (data []byte, err error)
  • func (n *NodeStore) Put(key []byte, data []byte) error

Variables

var ErrNotFound = errors.New("not found")

ErrNotFound indicates that the chunk is not found.

Types

type ExportedChunk

type ExportedChunk struct {
	Data  []byte           `json:"d"`
	Addrs []common.Address `json:"a"`
}

ExportedChunk is the structure that is saved in tar archive for each chunk as JSON-encoded bytes.

type Exporter

type Exporter interface {
	Export(w io.Writer) (n int, err error)
}

Exporter defines method for exporting mock store data to a tar archive.

type GlobalStorer

type GlobalStorer interface {
	Get(addr common.Address, key []byte) (data []byte, err error)
	Put(addr common.Address, key []byte, data []byte) error
	Delete(addr common.Address, key []byte) error
	HasKey(addr common.Address, key []byte) bool
	// NewNodeStore creates an instance of NodeStore
	// to be used by a single swarm node with
	// address addr.
	NewNodeStore(addr common.Address) *NodeStore
}

GlobalStorer defines methods for mock db store that stores chunk data for all swarm nodes. It is used in tests to construct mock NodeStores for swarm nodes and to track and validate chunks.

type ImportExporter

type ImportExporter interface {
	Importer
	Exporter
}

ImportExporter is an interface for importing and exporting mock store data to and from a tar archive.

type Importer

type Importer interface {
	Import(r io.Reader) (n int, err error)
}

Importer defines method for importing mock store data from an exported tar archive.

type NodeStore

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

NodeStore holds the node address and a reference to the GlobalStore in order to access and store chunk data only for one node.

func NewNodeStore

func NewNodeStore(addr common.Address, store GlobalStorer) *NodeStore

NewNodeStore creates a new instance of NodeStore that keeps chunk data using GlobalStorer with a provided address.

func (*NodeStore) Delete

func (n *NodeStore) Delete(key []byte) error

Delete removes chunk data for a key for a node that has the address provided on NodeStore initialization.

func (*NodeStore) Get

func (n *NodeStore) Get(key []byte) (data []byte, err error)

Get returns chunk data for a key for a node that has the address provided on NodeStore initialization.

func (*NodeStore) Put

func (n *NodeStore) Put(key []byte, data []byte) error

Put saves chunk data for a key for a node that has the address provided on NodeStore initialization.