node

type Config struct {
	Role                      blockless.NodeRole // Node role.
	Topic                     string             // Topic to subscribe to.
	Execute                   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.
	ConsensusHeartbeatTimeout time.Duration      // How often a consensus cluster leader should ping its followers.
	ConsensusElectionTimeout  time.Duration      // How long does a consensus cluster node wait for a leader before it triggers an election.
	ConsensusLeaderLease      time.Duration      // How long does a leader remain a leader if it cannot contact a quorum of cluster nodes.
}

type Executor interface {
	ExecuteFunction(requestID string, req execute.Request) (execute.Result, error)
}

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
}