node

type ChanData struct {
	Res        codes.Code        `json:"res,omitempty"`
	FunctionId string            `json:"functionId,omitempty"`
	RequestId  string            `json:"requestId,omitempty"`
	Topic      string            `json:"topic,omitempty"`
	Data       execute.ResultMap `json:"data,omitempty"`
}

type Config struct {
	Role                    blockless.NodeRole // Node role.
	Topics                  []string           // Topics to subscribe to.
	Execute                 blockless.Executor // Executor to use for running functions.
	HealthInterval          time.Duration      // How often should we emit the health ping.
	RollCallTimeout         time.Duration      // How long do we wait for roll call responses.
	Concurrency             uint               // How many requests should the node process in parallel.
	ExecutionTimeout        time.Duration      // How long does the head node wait for worker nodes to send their execution results.
	ClusterFormationTimeout time.Duration      // How long do we wait for the nodes to form a cluster for an execution.
	Workspace               string             // Directory where we can store files needed for execution.
	DefaultConsensus        consensus.Type     // Default consensus algorithm to use.
	LoadAttributes          bool               // Node should try to load its attributes from IPFS.
}

type FStore interface {
	// Install will install a function based on the address and CID.
	Install(address string, cid string) error

	// Installed returns info if the function is installed or not.
	Installed(cid string) (bool, error)

	// InstalledFunction returns the list of CIDs of installed functions.
	InstalledFunctions() ([]string, error)

	// Sync will recheck if function installation is found in local storage, and redownload it if it isn't.
	Sync(cid string) error
}

type HandlerFunc func(context.Context, peer.ID, []byte) error

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

type Option func(*Config)

type PeerStore interface {
	Store(peer.ID, multiaddr.Multiaddr, peer.AddrInfo) error
}

type Store interface {
	GetRecord(string, interface{}) error
	SetRecord(string, interface{}) error
}