ipfscluster

package module
v0.10.0-rc1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 4, 2019 License: Apache-2.0, MIT Imports: 35 Imported by: 0

README

IPFS Cluster

Made by Main project IRC channel standard-readme compliant GoDoc Go Report Card Build Status codecov

Pinset orchestration for IPFS.

logo

IPFS Cluster is a stand-alone application and a CLI client that allocates, replicates, and tracks pins across a cluster of IPFS daemons.

It provides:

  • A cluster peer application: ipfs-cluster-service, to be run along with go-ipfs.
  • A client CLI application: ipfs-cluster-ctl, which allows easily interacting with the peer's HTTP API.
Are you using IPFS Cluster?

Please participate in the IPFS Cluster user registry.

Table of Contents

Documentation

Please visit https://cluster.ipfs.io/documentation/ to access user documentation, guides and any other resources, including detailed download and usage instructions.

News & Roadmap

We regularly post project updates to https://cluster.ipfs.io/news/ .

The most up-to-date Roadmap is available at https://cluster.ipfs.io/roadmap/ .

Install

Instructions for different installation methods (including from source) are available at https://cluster.ipfs.io/documentation/download .

Usage

Extensive usage information is provided at https://cluster.ipfs.io/documentation/ , including:

Contribute

PRs accepted. As part of the IPFS project, we have some contribution guidelines.

Small note: If editing the README, please conform to the standard-readme specification.

License

This library is dual-licensed under Apache 2.0 and MIT terms.

© 2019. Protocol Labs, Inc.

Documentation

Overview

Package ipfscluster implements a wrapper for the IPFS deamon which allows to orchestrate pinning operations among several IPFS nodes.

IPFS Cluster uses a go-libp2p-raft to keep a shared state between the different cluster peers. It also uses LibP2P to enable communication between its different components, which perform different tasks like managing the underlying IPFS daemons, or providing APIs for external control.

Index

Constants

View Source 
const (
	DefaultConfigCrypto        = crypto.RSA
	DefaultConfigKeyLength     = 2048
	DefaultListenAddr          = "/ip4/0.0.0.0/tcp/9096"
	DefaultStateSyncInterval   = 600 * time.Second
	DefaultIPFSSyncInterval    = 130 * time.Second
	DefaultMonitorPingInterval = 15 * time.Second
	DefaultPeerWatchInterval   = 5 * time.Second
	DefaultReplicationFactor   = -1
	DefaultLeaveOnShutdown     = false
	DefaultDisableRepinning    = false
	DefaultPeerstoreFile       = "peerstore"
)

Configuration defaults

Variables

View Source 
var LoggingFacilities = map[string]string{
	"cluster":      "INFO",
	"restapi":      "INFO",
	"ipfsproxy":    "INFO",
	"ipfshttp":     "INFO",
	"monitor":      "INFO",
	"mapstate":     "INFO",
	"dsstate":      "INFO",
	"consensus":    "INFO",
	"pintracker":   "INFO",
	"ascendalloc":  "INFO",
	"diskinfo":     "INFO",
	"apitypes":     "INFO",
	"config":       "INFO",
	"shardingdags": "INFO",
	"localdags":    "INFO",
	"adder":        "INFO",
	"optracker":    "INFO",
}

LoggingFacilities provides a list of logging identifiers used by cluster and their default logging level.

View Source 
var LoggingFacilitiesExtra = map[string]string{
	"p2p-gorpc":   "CRITICAL",
	"swarm2":      "ERROR",
	"libp2p-raft": "CRITICAL",
	"raft":        "ERROR",
}

LoggingFacilitiesExtra provides logging identifiers used in ipfs-cluster dependencies, which may be useful to display. Along with their default value.

View Source 
var ReadyTimeout = 30 * time.Second

ReadyTimeout specifies the time before giving up during startup (waiting for consensus to be ready) It may need adjustment according to timeouts in the consensus layer.

Functions

func DecodeClusterSecret added in v0.1.0 

func DecodeClusterSecret(hexSecret string) ([]byte, error)

DecodeClusterSecret parses a hex-encoded string, checks that it is exactly 32 bytes long and returns its value as a byte-slice.x

func EncodeProtectorKey added in v0.3.5 

func EncodeProtectorKey(secretBytes []byte) string

EncodeProtectorKey converts a byte slice to its hex string representation.

func NewClusterHost added in v0.3.5 

func NewClusterHost(ctx context.Context, cfg *Config) (host.Host, error)

NewClusterHost creates a libp2p Host with the options from the provided cluster configuration.

func PeersFromMultiaddrs added in v0.3.2 

func PeersFromMultiaddrs(addrs []ma.Multiaddr) []peer.ID

PeersFromMultiaddrs returns all the different peers in the given addresses. each peer only will appear once in the result, even if several multiaddresses for it are provided.

func SetFacilityLogLevel added in v0.0.3 

func SetFacilityLogLevel(f, l string)

SetFacilityLogLevel sets the log level for a given module

Types

type API 

type API interface {
	Component
}

API is a component which offers an API for Cluster. This is a base component.

type Cluster 

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

Cluster is the main IPFS cluster component. It provides the go-API for it and orchestrates the components that make up the system.

func NewCluster 

func NewCluster(
	host host.Host,
	cfg *Config,
	consensus Consensus,
	apis []API,
	ipfs IPFSConnector,
	st state.State,
	tracker PinTracker,
	monitor PeerMonitor,
	allocator PinAllocator,
	informer Informer,
	tracer Tracer,
) (*Cluster, error)

NewCluster builds a new IPFS Cluster peer. It initializes a LibP2P host, creates and RPC Server and client and sets up all components.

The new cluster peer may still be performing initialization tasks when this call returns (consensus may still be bootstrapping). Use Cluster.Ready() if you need to wait until the peer is fully up.

func (*Cluster) AddFile added in v0.5.0 

func (c *Cluster) AddFile(reader *multipart.Reader, params *api.AddParams) (cid.Cid, error)

AddFile adds a file to the ipfs daemons of the cluster. The ipfs importer pipeline is used to DAGify the file. Depending on input parameters this DAG can be added locally to the calling cluster peer's ipfs repo, or sharded across the entire cluster.

func (*Cluster) ConnectGraph added in v0.3.3 

func (c *Cluster) ConnectGraph() (api.ConnectGraph, error)

ConnectGraph returns a description of which cluster peers and ipfs daemons are connected to each other

func (*Cluster) Done added in v0.0.3 

func (c *Cluster) Done() <-chan struct{}

Done provides a way to learn if the Peer has been shutdown (for example, because it has been removed from the Cluster)

func (*Cluster) ID 

func (c *Cluster) ID(ctx context.Context) *api.ID

ID returns information about the Cluster peer

func (*Cluster) Join added in v0.0.3 

func (c *Cluster) Join(ctx context.Context, addr ma.Multiaddr) error

Join adds this peer to an existing cluster by bootstrapping to a given multiaddress. It works by calling PeerAdd on the destination cluster and making sure that the new peer is ready to discover and contact the rest.

func (*Cluster) PeerAdd added in v0.0.3 

func (c *Cluster) PeerAdd(ctx context.Context, pid peer.ID) (*api.ID, error)

PeerAdd adds a new peer to this Cluster.

For it to work well, the new peer should be discoverable (part of our peerstore or connected to one of the existing peers) and reachable. Since PeerAdd allows to add peers which are not running, or reachable, it is recommended to call Join() from the new peer instead.

The new peer ID will be passed to the consensus component to be added to the peerset.

func (*Cluster) PeerRemove added in v0.0.3 

func (c *Cluster) PeerRemove(ctx context.Context, pid peer.ID) error

PeerRemove removes a peer from this Cluster.

The peer will be removed from the consensus peerset. This may first trigger repinnings for all content if not disabled.

func (*Cluster) Peers added in v0.0.3 

func (c *Cluster) Peers(ctx context.Context) []*api.ID

Peers returns the IDs of the members of this Cluster.

func (*Cluster) Pin 

func (c *Cluster) Pin(ctx context.Context, pin *api.Pin) error

Pin makes the cluster Pin a Cid. This implies adding the Cid to the IPFS Cluster peers shared-state. Depending on the cluster pinning strategy, the PinTracker may then request the IPFS daemon to pin the Cid.

Pin returns an error if the operation could not be persisted to the global state. Pin does not reflect the success or failure of underlying IPFS daemon pinning operations.

If the argument's allocations are non-empty then these peers are pinned with priority over other peers in the cluster. If the max repl factor is less than the size of the specified peerset then peers are chosen from this set in allocation order. If the min repl factor is greater than the size of this set then the remaining peers are allocated in order from the rest of the cluster. Priority allocations are best effort. If any priority peers are unavailable then Pin will simply allocate from the rest of the cluster.

func (*Cluster) PinGet added in v0.1.0 

func (c *Cluster) PinGet(ctx context.Context, h cid.Cid) (*api.Pin, error)

PinGet returns information for a single Cid managed by Cluster. The information is obtained from the current global state. The returned api.Pin provides information about the allocations assigned for the requested Cid, but does not indicate if the item is successfully pinned. For that, use Status(). PinGet returns an error if the given Cid is not part of the global state.

func (*Cluster) PinPath added in v0.10.0 

func (c *Cluster) PinPath(ctx context.Context, path *api.PinPath) (*api.Pin, error)

PinPath pins an CID resolved from its IPFS Path. It returns the resolved Pin object.

func (*Cluster) Pins 

func (c *Cluster) Pins(ctx context.Context) []*api.Pin

Pins returns the list of Cids managed by Cluster and which are part of the current global state. This is the source of truth as to which pins are managed and their allocation, but does not indicate if the item is successfully pinned. For that, use StatusAll().

func (*Cluster) Ready added in v0.0.3 

func (c *Cluster) Ready() <-chan struct{}

Ready returns a channel which signals when this peer is fully initialized (including consensus).

func (*Cluster) Recover added in v0.0.3 

func (c *Cluster) Recover(ctx context.Context, h cid.Cid) (*api.GlobalPinInfo, error)

Recover triggers a recover operation for a given Cid in all cluster peers.

func (*Cluster) RecoverAllLocal added in v0.3.1 

func (c *Cluster) RecoverAllLocal(ctx context.Context) ([]*api.PinInfo, error)

RecoverAllLocal triggers a RecoverLocal operation for all Cids tracked by this peer.

func (*Cluster) RecoverLocal added in v0.0.3 

func (c *Cluster) RecoverLocal(ctx context.Context, h cid.Cid) (pInfo *api.PinInfo, err error)

RecoverLocal triggers a recover operation for a given Cid in this peer only. It returns the updated PinInfo, after recovery.

func (*Cluster) Shutdown 

func (c *Cluster) Shutdown(ctx context.Context) error

Shutdown stops the IPFS cluster components

func (*Cluster) StateSync 

func (c *Cluster) StateSync(ctx context.Context) error

StateSync syncs the consensus state to the Pin Tracker, ensuring that every Cid in the shared state is tracked and that the Pin Tracker is not tracking more Cids than it should.

func (*Cluster) Status 

func (c *Cluster) Status(ctx context.Context, h cid.Cid) (*api.GlobalPinInfo, error)

Status returns the GlobalPinInfo for a given Cid as fetched from all current peers. If an error happens, the GlobalPinInfo should contain as much information as could be fetched from the other peers.

func (*Cluster) StatusAll added in v0.0.3 

func (c *Cluster) StatusAll(ctx context.Context) ([]*api.GlobalPinInfo, error)

StatusAll returns the GlobalPinInfo for all tracked Cids in all peers. If an error happens, the slice will contain as much information as could be fetched from other peers.

func (*Cluster) StatusAllLocal added in v0.3.1 

func (c *Cluster) StatusAllLocal(ctx context.Context) []*api.PinInfo

StatusAllLocal returns the PinInfo for all the tracked Cids in this peer.

func (*Cluster) StatusLocal added in v0.3.1 

func (c *Cluster) StatusLocal(ctx context.Context, h cid.Cid) *api.PinInfo

StatusLocal returns this peer's PinInfo for a given Cid.

func (*Cluster) Sync added in v0.0.3 

func (c *Cluster) Sync(ctx context.Context, h cid.Cid) (*api.GlobalPinInfo, error)

Sync triggers a SyncLocal() operation for a given Cid. in all cluster peers.

func (*Cluster) SyncAll added in v0.0.3 

func (c *Cluster) SyncAll(ctx context.Context) ([]*api.GlobalPinInfo, error)

SyncAll triggers SyncAllLocal() operations in all cluster peers, making sure that the state of tracked items matches the state reported by the IPFS daemon and returning the results as GlobalPinInfo. If an error happens, the slice will contain as much information as could be fetched from the peers.

func (*Cluster) SyncAllLocal added in v0.0.3 

func (c *Cluster) SyncAllLocal(ctx context.Context) ([]*api.PinInfo, error)

SyncAllLocal makes sure that the current state for all tracked items in this peer matches the state reported by the IPFS daemon.

SyncAllLocal returns the list of PinInfo that where updated because of the operation, along with those in error states.

func (*Cluster) SyncLocal added in v0.0.3 

func (c *Cluster) SyncLocal(ctx context.Context, h cid.Cid) (pInfo *api.PinInfo, err error)

SyncLocal performs a local sync operation for the given Cid. This will tell the tracker to verify the status of the Cid against the IPFS daemon. It returns the updated PinInfo for the Cid.

func (*Cluster) Unpin 

func (c *Cluster) Unpin(ctx context.Context, h cid.Cid) error

Unpin makes the cluster Unpin a Cid. This implies adding the Cid to the IPFS Cluster peers shared-state.

Unpin returns an error if the operation could not be persisted to the global state. Unpin does not reflect the success or failure of underlying IPFS daemon unpinning operations.

func (*Cluster) UnpinPath added in v0.10.0 

func (c *Cluster) UnpinPath(ctx context.Context, path string) (*api.Pin, error)

UnpinPath unpins a CID resolved from its IPFS Path. If returns the previously pinned Pin object.

func (*Cluster) Version 

func (c *Cluster) Version() string

Version returns the current IPFS Cluster version.

type Component 

type Component interface {
	SetClient(*rpc.Client)
	Shutdown(context.Context) error
}

Component represents a piece of ipfscluster. Cluster components usually run their own goroutines (a http server for example). They communicate with the main Cluster component and other components (both local and remote), using an instance of rpc.Client.

type Config 

type Config struct {
	config.Saver

	// Libp2p ID and private key for Cluster communication (including)
	// the Consensus component.
	ID         peer.ID
	PrivateKey crypto.PrivKey

	// User-defined peername for use as human-readable identifier.
	Peername string

	// Cluster secret for private network. Peers will be in the same cluster if and
	// only if they have the same ClusterSecret. The cluster secret must be exactly
	// 64 characters and contain only hexadecimal characters (`[0-9a-f]`).
	Secret []byte

	// Leave Cluster on shutdown. Politely informs other peers
	// of the departure and removes itself from the consensus
	// peer set. The Cluster size will be reduced by one.
	LeaveOnShutdown bool

	// Listen parameters for the Cluster libp2p Host. Used by
	// the RPC and Consensus components.
	ListenAddr ma.Multiaddr

	// Time between syncs of the consensus state to the
	// tracker state. Normally states are synced anyway, but this helps
	// when new nodes are joining the cluster. Reduce for faster
	// consistency, increase with larger states.
	StateSyncInterval time.Duration

	// Number of seconds between syncs of the local state and
	// the state of the ipfs daemon. This ensures that cluster
	// provides the right status for tracked items (for example
	// to detect that a pin has been removed. Reduce for faster
	// consistency, increase when the number of pinned items is very
	// large.
	IPFSSyncInterval time.Duration

	// ReplicationFactorMax indicates the target number of nodes
	// that should pin content. For exampe, a replication_factor of
	// 3 will have cluster allocate each pinned hash to 3 peers if
	// possible.
	// See also ReplicationFactorMin. A ReplicationFactorMax of -1
	// will allocate to every available node.
	ReplicationFactorMax int

	// ReplicationFactorMin indicates the minimum number of healthy
	// nodes pinning content. If the number of nodes available to pin
	// is less than this threshold, an error will be returned.
	// In the case of peer health issues, content pinned will be
	// re-allocated if the threshold is crossed.
	// For exampe, a ReplicationFactorMin of 2 will allocate at least
	// two peer to hold content, and return an error if this is not
	// possible.
	ReplicationFactorMin int

	// MonitorPingInterval is the frequency with which a cluster peer pings
	// the monitoring component. The ping metric has a TTL set to the double
	// of this value.
	MonitorPingInterval time.Duration

	// PeerWatchInterval is the frequency that we use to watch for changes
	// in the consensus peerset and save new peers to the configuration
	// file. This also affects how soon we realize that we have
	// been removed from a cluster.
	PeerWatchInterval time.Duration

	// If true, DisableRepinning, ensures that no repinning happens
	// when a node goes down.
	// This is useful when doing certain types of maintainance, or simply
	// when not wanting to rely on the monitoring system which needs a revamp.
	DisableRepinning bool

	// Peerstore file specifies the file on which we persist the
	// libp2p host peerstore addresses. This file is regularly saved.
	PeerstoreFile string

	// Tracing flag used to skip tracing specific paths when not enabled.
	Tracing bool
	// contains filtered or unexported fields
}

Config is the configuration object containing customizable variables to initialize the main ipfs-cluster component. It implements the config.ComponentConfig interface.

func (*Config) ApplyEnvVars added in v0.10.0 

func (cfg *Config) ApplyEnvVars() error

ApplyEnvVars fills in any Config fields found as environment variables.

func (*Config) ConfigKey added in v0.2.0 

func (cfg *Config) ConfigKey() string

ConfigKey returns a human-readable string to identify a cluster Config.

func (*Config) Default added in v0.2.0 

func (cfg *Config) Default() error

Default fills in all the Config fields with default working values. This means, it will generate a valid random ID, PrivateKey and Secret.

func (*Config) GetPeerstorePath added in v0.4.0 

func (cfg *Config) GetPeerstorePath() string

GetPeerstorePath returns the full path of the PeerstoreFile, obtained by concatenating that value with BaseDir of the configuration, if set. An empty string is returned when BaseDir is not set.

func (*Config) LoadJSON added in v0.2.0 

func (cfg *Config) LoadJSON(raw []byte) error

LoadJSON receives a raw json-formatted configuration and sets the Config fields from it. Note that it should be JSON as generated by ToJSON().

func (*Config) ToJSON added in v0.2.0 

func (cfg *Config) ToJSON() (raw []byte, err error)

ToJSON generates a human-friendly version of Config.

func (*Config) Validate added in v0.2.0 

func (cfg *Config) Validate() error

Validate will check that the values of this config seem to be working ones.

type Consensus 

type Consensus interface {
	Component
	// Returns a channel to signal that the consensus layer is ready
	// allowing the main component to wait for it during start.
	Ready(context.Context) <-chan struct{}
	// Logs a pin operation
	LogPin(ctx context.Context, c *api.Pin) error
	// Logs an unpin operation
	LogUnpin(ctx context.Context, c *api.Pin) error
	AddPeer(ctx context.Context, p peer.ID) error
	RmPeer(ctx context.Context, p peer.ID) error
	State(context.Context) (state.State, error)
	// Provide a node which is responsible to perform
	// specific tasks which must only run in 1 cluster peer
	Leader(context.Context) (peer.ID, error)
	// Only returns when the consensus state has all log
	// updates applied to it
	WaitForSync(context.Context) error
	// Clean removes all consensus data
	Clean(context.Context) error
	// Peers returns the peerset participating in the Consensus
	Peers(context.Context) ([]peer.ID, error)
}

Consensus is a component which keeps a shared state in IPFS Cluster and triggers actions on updates to that state. Currently, Consensus needs to be able to elect/provide a Cluster Leader and the implementation is very tight to the Cluster main component.

type IPFSConnector 

type IPFSConnector interface {
	Component
	ID(context.Context) (*api.IPFSID, error)
	Pin(context.Context, cid.Cid, int) error
	Unpin(context.Context, cid.Cid) error
	PinLsCid(context.Context, cid.Cid) (api.IPFSPinStatus, error)
	PinLs(ctx context.Context, typeFilter string) (map[string]api.IPFSPinStatus, error)
	// ConnectSwarms make sure this peer's IPFS daemon is connected to
	// other peers IPFS daemons.
	ConnectSwarms(context.Context) error
	// SwarmPeers returns the IPFS daemon's swarm peers
	SwarmPeers(context.Context) ([]peer.ID, error)
	// ConfigKey returns the value for a configuration key.
	// Subobjects are reached with keypaths as "Parent/Child/GrandChild...".
	ConfigKey(keypath string) (interface{}, error)
	// RepoStat returns the current repository size and max limit as
	// provided by "repo stat".
	RepoStat(context.Context) (*api.IPFSRepoStat, error)
	// Resolve returns a cid given a path
	Resolve(context.Context, string) (cid.Cid, error)
	// BlockPut directly adds a block of data to the IPFS repo
	BlockPut(context.Context, *api.NodeWithMeta) error
	// BlockGet retrieves the raw data of an IPFS block
	BlockGet(context.Context, cid.Cid) ([]byte, error)
}

IPFSConnector is a component which allows cluster to interact with an IPFS daemon. This is a base component.

type Informer added in v0.0.3 

type Informer interface {
	Component
	Name() string
	GetMetric(context.Context) *api.Metric
}

Informer provides Metric information from a peer. The metrics produced by informers are then passed to a PinAllocator which will use them to determine where to pin content. The metric is agnostic to the rest of Cluster.

type PeerMonitor added in v0.0.3 

type PeerMonitor interface {
	Component
	// LogMetric stores a metric. It can be used to manually inject
	// a metric to a monitor.
	LogMetric(context.Context, *api.Metric) error
	// PublishMetric sends a metric to the rest of the peers.
	// How to send it, and to who, is to be decided by the implementation.
	PublishMetric(context.Context, *api.Metric) error
	// LatestMetrics returns a map with the latest metrics of matching name
	// for the current cluster peers.
	LatestMetrics(ctx context.Context, name string) []*api.Metric
	// Alerts delivers alerts generated when this peer monitor detects
	// a problem (i.e. metrics not arriving as expected). Alerts can be used
	// to trigger self-healing measures or re-pinnings of content.
	Alerts() <-chan *api.Alert
}

PeerMonitor is a component in charge of publishing a peer's metrics and reading metrics from other peers in the cluster. The PinAllocator will use the metrics provided by the monitor as candidates for Pin allocations.

The PeerMonitor component also provides an Alert channel which is signaled when a metric is no longer received and the monitor identifies it as a problem.

type Peered 

type Peered interface {
	AddPeer(ctx context.Context, p peer.ID)
	RmPeer(ctx context.Context, p peer.ID)
}

Peered represents a component which needs to be aware of the peers in the Cluster and of any changes to the peer set.

type PinAllocator added in v0.0.3 

type PinAllocator interface {
	Component
	// Allocate returns the list of peers that should be assigned to
	// Pin content in order of preference (from the most preferred to the
	// least). The "current" map contains valid metrics for peers
	// which are currently pinning the content. The candidates map
	// contains the metrics for all peers which are eligible for pinning
	// the content.
	Allocate(ctx context.Context, c cid.Cid, current, candidates, priority map[peer.ID]*api.Metric) ([]peer.ID, error)
}

PinAllocator decides where to pin certain content. In order to make such decision, it receives the pin arguments, the peers which are currently allocated to the content and metrics available for all peers which could allocate the content.

type PinTracker 

type PinTracker interface {
	Component
	// Track tells the tracker that a Cid is now under its supervision
	// The tracker may decide to perform an IPFS pin.
	Track(context.Context, *api.Pin) error
	// Untrack tells the tracker that a Cid is to be forgotten. The tracker
	// may perform an IPFS unpin operation.
	Untrack(context.Context, cid.Cid) error
	// StatusAll returns the list of pins with their local status.
	StatusAll(context.Context) []*api.PinInfo
	// Status returns the local status of a given Cid.
	Status(context.Context, cid.Cid) *api.PinInfo
	// SyncAll makes sure that all tracked Cids reflect the real IPFS status.
	// It returns the list of pins which were updated by the call.
	SyncAll(context.Context) ([]*api.PinInfo, error)
	// Sync makes sure that the Cid status reflect the real IPFS status.
	// It returns the local status of the Cid.
	Sync(context.Context, cid.Cid) (*api.PinInfo, error)
	// RecoverAll calls Recover() for all pins tracked.
	RecoverAll(context.Context) ([]*api.PinInfo, error)
	// Recover retriggers a Pin/Unpin operation in a Cids with error status.
	Recover(context.Context, cid.Cid) (*api.PinInfo, error)
}

PinTracker represents a component which tracks the status of the pins in this cluster and ensures they are in sync with the IPFS daemon. This component should be thread safe.

type RPCAPI 

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

RPCAPI is a go-libp2p-gorpc service which provides the internal ipfs-cluster API, which enables components and cluster peers to communicate and request actions from each other.

The RPC API methods are usually redirects to the actual methods in the different components of ipfs-cluster, with very little added logic. Refer to documentation on those methods for details on their behaviour.

func (*RPCAPI) BlockAllocate added in v0.5.0 

func (rpcapi *RPCAPI) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer.ID) error

BlockAllocate returns allocations for blocks. This is used in the adders. It's different from pin allocations when ReplicationFactor < 0.

func (*RPCAPI) ConnectGraph added in v0.3.3 

func (rpcapi *RPCAPI) ConnectGraph(ctx context.Context, in struct{}, out *api.ConnectGraph) error

ConnectGraph runs Cluster.GetConnectGraph().

func (*RPCAPI) ConsensusAddPeer added in v0.3.0 

func (rpcapi *RPCAPI) ConsensusAddPeer(ctx context.Context, in peer.ID, out *struct{}) error

ConsensusAddPeer runs Consensus.AddPeer().

func (*RPCAPI) ConsensusLogPin 

func (rpcapi *RPCAPI) ConsensusLogPin(ctx context.Context, in *api.Pin, out *struct{}) error

ConsensusLogPin runs Consensus.LogPin().

func (*RPCAPI) ConsensusLogUnpin 

func (rpcapi *RPCAPI) ConsensusLogUnpin(ctx context.Context, in *api.Pin, out *struct{}) error

ConsensusLogUnpin runs Consensus.LogUnpin().

func (*RPCAPI) ConsensusPeers added in v0.3.0 

func (rpcapi *RPCAPI) ConsensusPeers(ctx context.Context, in struct{}, out *[]peer.ID) error

ConsensusPeers runs Consensus.Peers().

func (*RPCAPI) ConsensusRmPeer added in v0.3.0 

func (rpcapi *RPCAPI) ConsensusRmPeer(ctx context.Context, in peer.ID, out *struct{}) error

ConsensusRmPeer runs Consensus.RmPeer().

func (*RPCAPI) ID 

func (rpcapi *RPCAPI) ID(ctx context.Context, in struct{}, out *api.ID) error

ID runs Cluster.ID()

func (*RPCAPI) IPFSBlockGet added in v0.5.0 

func (rpcapi *RPCAPI) IPFSBlockGet(ctx context.Context, in cid.Cid, out *[]byte) error

IPFSBlockGet runs IPFSConnector.BlockGet().

func (*RPCAPI) IPFSBlockPut added in v0.5.0 

func (rpcapi *RPCAPI) IPFSBlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error

IPFSBlockPut runs IPFSConnector.BlockPut().

func (*RPCAPI) IPFSConfigKey added in v0.0.11 

func (rpcapi *RPCAPI) IPFSConfigKey(ctx context.Context, in string, out *interface{}) error

IPFSConfigKey runs IPFSConnector.ConfigKey().

func (*RPCAPI) IPFSConnectSwarms added in v0.0.11 

func (rpcapi *RPCAPI) IPFSConnectSwarms(ctx context.Context, in struct{}, out *struct{}) error

IPFSConnectSwarms runs IPFSConnector.ConnectSwarms().

func (*RPCAPI) IPFSPin 

func (rpcapi *RPCAPI) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}) error

IPFSPin runs IPFSConnector.Pin().

func (*RPCAPI) IPFSPinLs added in v0.0.3 

func (rpcapi *RPCAPI) IPFSPinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error

IPFSPinLs runs IPFSConnector.PinLs().

func (*RPCAPI) IPFSPinLsCid added in v0.0.3 

func (rpcapi *RPCAPI) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error

IPFSPinLsCid runs IPFSConnector.PinLsCid().

func (*RPCAPI) IPFSRepoStat added in v0.5.0 

func (rpcapi *RPCAPI) IPFSRepoStat(ctx context.Context, in struct{}, out *api.IPFSRepoStat) error

IPFSRepoStat runs IPFSConnector.RepoStat().

func (*RPCAPI) IPFSSwarmPeers added in v0.3.3 

func (rpcapi *RPCAPI) IPFSSwarmPeers(ctx context.Context, in struct{}, out *[]peer.ID) error

IPFSSwarmPeers runs IPFSConnector.SwarmPeers().

func (*RPCAPI) IPFSUnpin 

func (rpcapi *RPCAPI) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct{}) error

IPFSUnpin runs IPFSConnector.Unpin().

func (*RPCAPI) Join added in v0.0.3 

func (rpcapi *RPCAPI) Join(ctx context.Context, in api.Multiaddr, out *struct{}) error

Join runs Cluster.Join().

func (*RPCAPI) PeerAdd added in v0.0.3 

func (rpcapi *RPCAPI) PeerAdd(ctx context.Context, in peer.ID, out *api.ID) error

PeerAdd runs Cluster.PeerAdd().

func (*RPCAPI) PeerMonitorLatestMetrics added in v0.4.0 

func (rpcapi *RPCAPI) PeerMonitorLatestMetrics(ctx context.Context, in string, out *[]*api.Metric) error

PeerMonitorLatestMetrics runs PeerMonitor.LatestMetrics().

func (*RPCAPI) PeerMonitorLogMetric added in v0.0.3 

func (rpcapi *RPCAPI) PeerMonitorLogMetric(ctx context.Context, in *api.Metric, out *struct{}) error

PeerMonitorLogMetric runs PeerMonitor.LogMetric().

func (*RPCAPI) PeerRemove added in v0.0.3 

func (rpcapi *RPCAPI) PeerRemove(ctx context.Context, in peer.ID, out *struct{}) error

PeerRemove runs Cluster.PeerRm().

func (*RPCAPI) Peers added in v0.0.3 

func (rpcapi *RPCAPI) Peers(ctx context.Context, in struct{}, out *[]*api.ID) error

Peers runs Cluster.Peers().

func (*RPCAPI) Pin 

func (rpcapi *RPCAPI) Pin(ctx context.Context, in *api.Pin, out *struct{}) error

Pin runs Cluster.Pin().

func (*RPCAPI) PinGet added in v0.1.0 

func (rpcapi *RPCAPI) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error

PinGet runs Cluster.PinGet().

func (*RPCAPI) PinPath added in v0.10.0 

func (rpcapi *RPCAPI) PinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error

PinPath resolves path into a cid and runs Cluster.Pin().

func (*RPCAPI) Pins added in v0.1.0 

func (rpcapi *RPCAPI) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error

Pins runs Cluster.Pins().

func (*RPCAPI) Recover added in v0.0.3 

func (rpcapi *RPCAPI) Recover(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error

Recover runs Cluster.Recover().

func (*RPCAPI) RecoverAllLocal added in v0.3.1 

func (rpcapi *RPCAPI) RecoverAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error

RecoverAllLocal runs Cluster.RecoverAllLocal().

func (*RPCAPI) RecoverLocal added in v0.3.1 

func (rpcapi *RPCAPI) RecoverLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error

RecoverLocal runs Cluster.RecoverLocal().

func (*RPCAPI) SendInformerMetric added in v0.5.0 

func (rpcapi *RPCAPI) SendInformerMetric(ctx context.Context, in struct{}, out *api.Metric) error

SendInformerMetric runs Cluster.sendInformerMetric().

func (*RPCAPI) Status 

func (rpcapi *RPCAPI) Status(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error

Status runs Cluster.Status().

func (*RPCAPI) StatusAll added in v0.0.3 

func (rpcapi *RPCAPI) StatusAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error

StatusAll runs Cluster.StatusAll().

func (*RPCAPI) StatusAllLocal added in v0.3.1 

func (rpcapi *RPCAPI) StatusAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error

StatusAllLocal runs Cluster.StatusAllLocal().

func (*RPCAPI) StatusLocal added in v0.3.1 

func (rpcapi *RPCAPI) StatusLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error

StatusLocal runs Cluster.StatusLocal().

func (*RPCAPI) Sync added in v0.0.3 

func (rpcapi *RPCAPI) Sync(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error

Sync runs Cluster.Sync().

func (*RPCAPI) SyncAll added in v0.0.3 

func (rpcapi *RPCAPI) SyncAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error

SyncAll runs Cluster.SyncAll().

func (*RPCAPI) SyncAllLocal added in v0.0.3 

func (rpcapi *RPCAPI) SyncAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error

SyncAllLocal runs Cluster.SyncAllLocal().

func (*RPCAPI) SyncLocal added in v0.0.3 

func (rpcapi *RPCAPI) SyncLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error

SyncLocal runs Cluster.SyncLocal().

func (*RPCAPI) Track 

func (rpcapi *RPCAPI) Track(ctx context.Context, in *api.Pin, out *struct{}) error

Track runs PinTracker.Track().

func (*RPCAPI) TrackerRecover added in v0.0.3 

func (rpcapi *RPCAPI) TrackerRecover(ctx context.Context, in cid.Cid, out *api.PinInfo) error

TrackerRecover runs PinTracker.Recover().

func (*RPCAPI) TrackerRecoverAll added in v0.3.1 

func (rpcapi *RPCAPI) TrackerRecoverAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error

TrackerRecoverAll runs PinTracker.RecoverAll().f

func (*RPCAPI) TrackerStatus 

func (rpcapi *RPCAPI) TrackerStatus(ctx context.Context, in cid.Cid, out *api.PinInfo) error

TrackerStatus runs PinTracker.Status().

func (*RPCAPI) TrackerStatusAll added in v0.0.3 

func (rpcapi *RPCAPI) TrackerStatusAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error

TrackerStatusAll runs PinTracker.StatusAll().

func (*RPCAPI) Unpin 

func (rpcapi *RPCAPI) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error

Unpin runs Cluster.Unpin().

func (*RPCAPI) UnpinPath added in v0.10.0 

func (rpcapi *RPCAPI) UnpinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error

UnpinPath resolves path into a cid and runs Cluster.Unpin().

func (*RPCAPI) Untrack 

func (rpcapi *RPCAPI) Untrack(ctx context.Context, in *api.Pin, out *struct{}) error

Untrack runs PinTracker.Untrack().

func (*RPCAPI) Version 

func (rpcapi *RPCAPI) Version(ctx context.Context, in struct{}, out *api.Version) error

Version runs Cluster.Version().

type Tracer added in v0.9.0 

type Tracer interface {
	Component
}

Tracer implements Component as a way to shutdown and flush and remaining traces.

Source Files

View all Source files

Directories

Path Synopsis
Package adder implements functionality to add content to IPFS daemons managed by the Cluster.
 Package adder implements functionality to add content to IPFS daemons managed by the Cluster.
adderutils
Package adderutils provides some utilities for adding content to cluster.
 Package adderutils provides some utilities for adding content to cluster.
ipfsadd
Package ipfsadd is a simplified copy of go-ipfs/core/coreunix/add.go
 Package ipfsadd is a simplified copy of go-ipfs/core/coreunix/add.go
local
Package local implements a ClusterDAGService that chunks and adds content to a local peer, before pinning it.
 Package local implements a ClusterDAGService that chunks and adds content to a local peer, before pinning it.
sharding
Package sharding implements a sharding ClusterDAGService places content in different shards while it's being added, creating a final Cluster DAG and pinning it.
 Package sharding implements a sharding ClusterDAGService places content in different shards while it's being added, creating a final Cluster DAG and pinning it.
allocator
ascendalloc
Package ascendalloc implements an ipfscluster.PinAllocator, which returns allocations based on sorting the metrics in ascending order.
 Package ascendalloc implements an ipfscluster.PinAllocator, which returns allocations based on sorting the metrics in ascending order.
descendalloc
Package descendalloc implements an ipfscluster.PinAllocator returns allocations based on sorting the metrics in descending order.
 Package descendalloc implements an ipfscluster.PinAllocator returns allocations based on sorting the metrics in descending order.
util
Package util is a utility package used by the allocator implementations.
 Package util is a utility package used by the allocator implementations.
api
Package api holds declarations for types used in ipfs-cluster APIs to make them re-usable across differen tools.
 Package api holds declarations for types used in ipfs-cluster APIs to make them re-usable across differen tools.
ipfsproxy
pb
rest
Package rest implements an IPFS Cluster API component.
 Package rest implements an IPFS Cluster API component.
rest/client
Package client provides a Go Client for the IPFS Cluster API provided by the "api/rest" component.
 Package client provides a Go Client for the IPFS Cluster API provided by the "api/rest" component.
cmd
ipfs-cluster-ctl
The ipfs-cluster-ctl application.
 The ipfs-cluster-ctl application.
ipfs-cluster-service
The ipfs-cluster-service application.
 The ipfs-cluster-service application.
Package config provides interfaces and utilities for different Cluster components to register, read, write and validate configuration sections stored in a central configuration file.
 Package config provides interfaces and utilities for different Cluster components to register, read, write and validate configuration sections stored in a central configuration file.
consensus
raft
Package raft implements a Consensus component for IPFS Cluster which uses Raft (go-libp2p-raft).
 Package raft implements a Consensus component for IPFS Cluster which uses Raft (go-libp2p-raft).
informer
disk
Package disk implements an ipfs-cluster informer which can provide different disk-related metrics from the IPFS daemon as an api.Metric.
 Package disk implements an ipfs-cluster informer which can provide different disk-related metrics from the IPFS daemon as an api.Metric.
numpin
Package numpin implements an ipfs-cluster informer which determines how many items this peer is pinning and returns it as api.Metric
 Package numpin implements an ipfs-cluster informer which determines how many items this peer is pinning and returns it as api.Metric
ipfsconn
ipfshttp
Package ipfshttp implements an IPFS Cluster IPFSConnector component.
 Package ipfshttp implements an IPFS Cluster IPFSConnector component.
monitor
basic
Package basic implements a basic PeerMonitor component for IPFS Cluster.
 Package basic implements a basic PeerMonitor component for IPFS Cluster.
metrics
Package metrics provides common functionality for working with metrics, particulary useful for monitoring components.
 Package metrics provides common functionality for working with metrics, particulary useful for monitoring components.
pubsubmon
Package pubsubmon implements a PeerMonitor component for IPFS Cluster that uses PubSub to send and receive metrics.
 Package pubsubmon implements a PeerMonitor component for IPFS Cluster that uses PubSub to send and receive metrics.
pintracker
maptracker
Package maptracker implements a PinTracker component for IPFS Cluster.
 Package maptracker implements a PinTracker component for IPFS Cluster.
optracker
Package optracker implements functionality to track the status of pin and operations as needed by implementations of the pintracker component.
 Package optracker implements functionality to track the status of pin and operations as needed by implementations of the pintracker component.
stateless
Package stateless implements a PinTracker component for IPFS Cluster, which aims to reduce the memory footprint when handling really large cluster states.
 Package stateless implements a PinTracker component for IPFS Cluster, which aims to reduce the memory footprint when handling really large cluster states.
util
Package pstoremgr provides a Manager that simplifies handling addition, listing and removal of cluster peer multiaddresses from the libp2p Host.
 Package pstoremgr provides a Manager that simplifies handling addition, listing and removal of cluster peer multiaddresses from the libp2p Host.
Package rpcutil provides utility methods to perform go-libp2p-gorpc calls, particularly gorpc.MultiCall().
 Package rpcutil provides utility methods to perform go-libp2p-gorpc calls, particularly gorpc.MultiCall().
Package state holds the interface that any state implementation for IPFS Cluster must satisfy.
 Package state holds the interface that any state implementation for IPFS Cluster must satisfy.
dsstate
Package dsstate implements the IPFS Cluster state interface using an underlying go-datastore.
 Package dsstate implements the IPFS Cluster state interface using an underlying go-datastore.
mapstate
Package mapstate implements the State interface for IPFS Cluster by using a map to keep track of the consensus-shared state.
 Package mapstate implements the State interface for IPFS Cluster by using a map to keep track of the consensus-shared state.
Package test offers testing utilities for all the IPFS Cluster codebase, like IPFS daemon and RPC mocks and pre-defined testing CIDs.
 Package test offers testing utilities for all the IPFS Cluster codebase, like IPFS daemon and RPC mocks and pre-defined testing CIDs.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.