ipfs-cluster: github.com/ipfs/ipfs-cluster Index | Files | Directories

package ipfscluster

import "github.com/ipfs/ipfs-cluster"

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

IPFS Cluster peers form a separate libp2p swarm. A Cluster peer uses multiple Cluster Componenets which perform different tasks like managing the underlying IPFS daemons, or providing APIs for external control.

Index

Package Files

allocate.go cluster.go cluster_config.go clusterhost.go connect_graph.go ipfscluster.go logging.go rpc_api.go rpc_policy.go util.go

Constants

const (
    DefaultListenAddr          = "/ip4/0.0.0.0/tcp/9096"
    DefaultStateSyncInterval   = 600 * time.Second
    DefaultIPFSSyncInterval    = 130 * time.Second
    DefaultPinRecoverInterval  = 1 * time.Hour
    DefaultMonitorPingInterval = 15 * time.Second
    DefaultPeerWatchInterval   = 5 * time.Second
    DefaultReplicationFactor   = -1
    DefaultLeaveOnShutdown     = false
    DefaultDisableRepinning    = false
    DefaultPeerstoreFile       = "peerstore"
    DefaultConnMgrHighWater    = 400
    DefaultConnMgrLowWater     = 100
    DefaultConnMgrGracePeriod  = 2 * time.Minute
    DefaultFollowerMode        = false
    DefaultMDNSInterval        = 10 * time.Second
)

Configuration defaults

Variables

var DefaultRPCPolicy = map[string]RPCEndpointType{

    "Cluster.BlockAllocate":      RPCClosed,
    "Cluster.ConnectGraph":       RPCClosed,
    "Cluster.ID":                 RPCOpen,
    "Cluster.Join":               RPCClosed,
    "Cluster.PeerAdd":            RPCOpen,
    "Cluster.PeerRemove":         RPCTrusted,
    "Cluster.Peers":              RPCTrusted,
    "Cluster.Pin":                RPCClosed,
    "Cluster.PinGet":             RPCClosed,
    "Cluster.PinPath":            RPCClosed,
    "Cluster.Pins":               RPCClosed,
    "Cluster.Recover":            RPCClosed,
    "Cluster.RecoverAll":         RPCClosed,
    "Cluster.RecoverAllLocal":    RPCTrusted,
    "Cluster.RecoverLocal":       RPCTrusted,
    "Cluster.SendInformerMetric": RPCClosed,
    "Cluster.Status":             RPCClosed,
    "Cluster.StatusAll":          RPCClosed,
    "Cluster.StatusAllLocal":     RPCClosed,
    "Cluster.StatusLocal":        RPCClosed,
    "Cluster.Sync":               RPCClosed,
    "Cluster.SyncAll":            RPCClosed,
    "Cluster.SyncAllLocal":       RPCTrusted,
    "Cluster.SyncLocal":          RPCTrusted,
    "Cluster.Unpin":              RPCClosed,
    "Cluster.UnpinPath":          RPCClosed,
    "Cluster.Version":            RPCOpen,

    "PinTracker.Recover":    RPCTrusted,
    "PinTracker.RecoverAll": RPCClosed,
    "PinTracker.Status":     RPCTrusted,
    "PinTracker.StatusAll":  RPCTrusted,
    "PinTracker.Track":      RPCClosed,
    "PinTracker.Untrack":    RPCClosed,

    "IPFSConnector.BlockGet":   RPCClosed,
    "IPFSConnector.BlockPut":   RPCTrusted,
    "IPFSConnector.ConfigKey":  RPCClosed,
    "IPFSConnector.Pin":        RPCClosed,
    "IPFSConnector.PinLs":      RPCClosed,
    "IPFSConnector.PinLsCid":   RPCClosed,
    "IPFSConnector.RepoStat":   RPCTrusted,
    "IPFSConnector.Resolve":    RPCClosed,
    "IPFSConnector.SwarmPeers": RPCTrusted,
    "IPFSConnector.Unpin":      RPCClosed,

    "Consensus.AddPeer":  RPCTrusted,
    "Consensus.LogPin":   RPCTrusted,
    "Consensus.LogUnpin": RPCTrusted,
    "Consensus.Peers":    RPCClosed,
    "Consensus.RmPeer":   RPCTrusted,

    "PeerMonitor.LatestMetrics": RPCClosed,
}

DefaultRPCPolicy associates all rpc endpoints offered by cluster peers to an endpoint type. See rpcutil/policygen.go as a quick way to generate this without missing any endpoint.

var LoggingFacilities = map[string]string{
    "cluster":      "INFO",
    "restapi":      "INFO",
    "restapilog":   "INFO",
    "ipfsproxy":    "INFO",
    "ipfsproxylog": "INFO",
    "ipfshttp":     "INFO",
    "monitor":      "INFO",
    "dsstate":      "INFO",
    "raft":         "INFO",
    "crdt":         "INFO",
    "pintracker":   "INFO",
    "ascendalloc":  "INFO",
    "diskinfo":     "INFO",
    "apitypes":     "INFO",
    "config":       "INFO",
    "shardingdags": "INFO",
    "singledags":   "INFO",
    "adder":        "INFO",
    "optracker":    "INFO",
    "pstoremgr":    "INFO",
}

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

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

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

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.

func DecodeClusterSecret Uses

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 Uses

func EncodeProtectorKey(secretBytes []byte) string

EncodeProtectorKey converts a byte slice to its hex string representation.

func NewClusterHost Uses

func NewClusterHost(
    ctx context.Context,
    ident *config.Identity,
    cfg *Config,
) (host.Host, *pubsub.PubSub, *dht.IpfsDHT, error)

NewClusterHost creates a libp2p Host with the options from the provided cluster configuration. Using that host, it creates pubsub and a DHT instances, for shared use by all cluster components. The returned host uses the DHT for routing. The resulting DHT is not bootstrapped.

func PeersFromMultiaddrs Uses

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 RPCServiceID Uses

func RPCServiceID(rpcSvc interface{}) string

RPCServiceID returns the Service ID for the given RPCAPI object.

func SetFacilityLogLevel Uses

func SetFacilityLogLevel(f, l string)

SetFacilityLogLevel sets the log level for a given module

type API Uses

type API interface {
    Component
}

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

type Cluster Uses

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 Uses

func NewCluster(
    ctx context.Context,
    host host.Host,
    dht *dht.IpfsDHT,
    cfg *Config,
    datastore ds.Datastore,
    consensus Consensus,
    apis []API,
    ipfs IPFSConnector,
    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 Uses

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 Uses

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 Uses

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 Uses

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

ID returns information about the Cluster peer

func (*Cluster) Join Uses

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 Uses

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 Uses

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 Uses

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

Peers returns the IDs of the members of this Cluster.

func (*Cluster) Pin Uses

func (c *Cluster) Pin(ctx context.Context, h cid.Cid, opts api.PinOptions) (*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 the Pin as stored in the global state (with the given allocations and an error if the operation could not be persisted. Pin does not reflect the success or failure of underlying IPFS daemon pinning operations which happen in async fashion.

If the options UserAllocations 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 minimum 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.

If the Update option is set, the pin options (including allocations) will be copied from an existing one. This is equivalent to running PinUpdate.

func (*Cluster) PinGet Uses

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 Uses

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

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

func (*Cluster) PinUpdate Uses

func (c *Cluster) PinUpdate(ctx context.Context, from cid.Cid, to cid.Cid, opts api.PinOptions) (*api.Pin, error)

PinUpdate pins a new CID based on an existing cluster Pin. The allocations and most pin options (replication factors) are copied from the existing Pin. The options object can be used to set the Name for the new pin and might support additional options in the future.

The from pin is NOT unpinned upon completion. The new pin might take advantage of efficient pin/update operation on IPFS-side (if the IPFSConnector supports it - the default one does). This may offer significant speed when pinning items which are similar to previously pinned content.

func (*Cluster) Pins Uses

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

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 Uses

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

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

func (*Cluster) Recover Uses

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.

Recover operations ask IPFS to pin or unpin items in error state. Recover is faster than calling Pin on the same CID as it avoids committing an identical pin to the consensus layer.

func (*Cluster) RecoverAll Uses

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

RecoverAll triggers a RecoverAllLocal operation on all peer.

func (*Cluster) RecoverAllLocal Uses

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

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

Recover operations ask IPFS to pin or unpin items in error state. Recover is faster than calling Pin on the same CID as it avoids committing an identical pin to the consensus layer.

func (*Cluster) RecoverLocal Uses

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.

Recover operations ask IPFS to pin or unpin items in error state. Recover is faster than calling Pin on the same CID as it avoids committing an identical pin to the consensus layer.

func (*Cluster) Shutdown Uses

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

Shutdown stops the IPFS cluster components

func (*Cluster) StateSync Uses

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 Uses

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 Uses

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 Uses

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

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

func (*Cluster) StatusLocal Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

Unpin removes a previously pinned Cid from Cluster. It returns the global state Pin object as it was stored before removal, or an error if it was not possible to update the global state.

Unpin does not reflect the success or failure of underlying IPFS daemon unpinning operations, which happen in async fashion.

func (*Cluster) UnpinPath Uses

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 Uses

func (c *Cluster) Version() string

Version returns the current IPFS Cluster version.

type ClusterRPCAPI Uses

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

ClusterRPCAPI is a go-libp2p-gorpc service which provides the internal peer API for the main cluster component.

func (*ClusterRPCAPI) BlockAllocate Uses

func (rpcapi *ClusterRPCAPI) 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 (*ClusterRPCAPI) ConnectGraph Uses

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

ConnectGraph runs Cluster.GetConnectGraph().

func (*ClusterRPCAPI) ID Uses

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

ID runs Cluster.ID()

func (*ClusterRPCAPI) Join Uses

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

Join runs Cluster.Join().

func (*ClusterRPCAPI) PeerAdd Uses

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

PeerAdd runs Cluster.PeerAdd().

func (*ClusterRPCAPI) PeerRemove Uses

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

PeerRemove runs Cluster.PeerRm().

func (*ClusterRPCAPI) Peers Uses

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

Peers runs Cluster.Peers().

func (*ClusterRPCAPI) Pin Uses

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

Pin runs Cluster.pin().

func (*ClusterRPCAPI) PinGet Uses

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

PinGet runs Cluster.PinGet().

func (*ClusterRPCAPI) PinPath Uses

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

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

func (*ClusterRPCAPI) Pins Uses

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

Pins runs Cluster.Pins().

func (*ClusterRPCAPI) Recover Uses

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

Recover runs Cluster.Recover().

func (*ClusterRPCAPI) RecoverAll Uses

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

RecoverAll runs Cluster.RecoverAll().

func (*ClusterRPCAPI) RecoverAllLocal Uses

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

RecoverAllLocal runs Cluster.RecoverAllLocal().

func (*ClusterRPCAPI) RecoverLocal Uses

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

RecoverLocal runs Cluster.RecoverLocal().

func (*ClusterRPCAPI) SendInformerMetric Uses

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

SendInformerMetric runs Cluster.sendInformerMetric().

func (*ClusterRPCAPI) Status Uses

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

Status runs Cluster.Status().

func (*ClusterRPCAPI) StatusAll Uses

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

StatusAll runs Cluster.StatusAll().

func (*ClusterRPCAPI) StatusAllLocal Uses

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

StatusAllLocal runs Cluster.StatusAllLocal().

func (*ClusterRPCAPI) StatusLocal Uses

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

StatusLocal runs Cluster.StatusLocal().

func (*ClusterRPCAPI) Sync Uses

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

Sync runs Cluster.Sync().

func (*ClusterRPCAPI) SyncAll Uses

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

SyncAll runs Cluster.SyncAll().

func (*ClusterRPCAPI) SyncAllLocal Uses

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

SyncAllLocal runs Cluster.SyncAllLocal().

func (*ClusterRPCAPI) SyncLocal Uses

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

SyncLocal runs Cluster.SyncLocal().

func (*ClusterRPCAPI) Unpin Uses

func (rpcapi *ClusterRPCAPI) Unpin(ctx context.Context, in *api.Pin, out *api.Pin) error

Unpin runs Cluster.Unpin().

func (*ClusterRPCAPI) UnpinPath Uses

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

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

func (*ClusterRPCAPI) Version Uses

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

Version runs Cluster.Version().

type Component Uses

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 Uses

type Config struct {
    config.Saver

    // 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

    // RPCPolicy defines access control to RPC endpoints.
    RPCPolicy map[string]RPCEndpointType

    // 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

    // ConnMgr holds configuration values for the connection manager for
    // the libp2p host.
    // FIXME: This only applies to ipfs-cluster-service.
    ConnMgr ConnMgrConfig

    // 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

    // Time 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

    // Time between automatic runs of the "recover" operation
    // which will retry to pin/unpin items in error state.
    PinRecoverInterval 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

    // MDNSInterval controls the time between mDNS broadcasts to the
    // network announcing the peer addresses. Set to 0 to disable
    // mDNS.
    MDNSInterval 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

    // FollowerMode disables broadcast requests from this peer
    // (sync, recover, status) and disallows pinset management
    // operations (Pin/Unpin).
    FollowerMode 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 Uses

func (cfg *Config) ApplyEnvVars() error

ApplyEnvVars fills in any Config fields found as environment variables.

func (*Config) ConfigKey Uses

func (cfg *Config) ConfigKey() string

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

func (*Config) Default Uses

func (cfg *Config) Default() error

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

func (*Config) GetPeerstorePath Uses

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 Uses

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 Uses

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

ToJSON generates a human-friendly version of Config.

func (*Config) Validate Uses

func (cfg *Config) Validate() error

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

type ConnMgrConfig Uses

type ConnMgrConfig struct {
    HighWater   int
    LowWater    int
    GracePeriod time.Duration
}

ConnMgrConfig configures the libp2p host connection manager.

type Consensus Uses

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(context.Context, *api.Pin) error
    // Logs an unpin operation.
    LogUnpin(context.Context, *api.Pin) error
    AddPeer(context.Context, peer.ID) error
    RmPeer(context.Context, peer.ID) error
    State(context.Context) (state.ReadOnly, 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)
    // IsTrustedPeer returns true if the given peer is "trusted".
    // This will grant access to more rpc endpoints and a
    // non-trusted one. This should be fast as it will be
    // called repeteadly for every remote RPC request.
    IsTrustedPeer(context.Context, peer.ID) bool
    // Trust marks a peer as "trusted".
    Trust(context.Context, peer.ID) error
    // Distrust removes a peer from the "trusted" set.
    Distrust(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 ConsensusRPCAPI Uses

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

ConsensusRPCAPI is a go-libp2p-gorpc service which provides the internal peer API for the Consensus component.

func (*ConsensusRPCAPI) AddPeer Uses

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

AddPeer runs Consensus.AddPeer().

func (*ConsensusRPCAPI) LogPin Uses

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

LogPin runs Consensus.LogPin().

func (*ConsensusRPCAPI) LogUnpin Uses

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

LogUnpin runs Consensus.LogUnpin().

func (*ConsensusRPCAPI) Peers Uses

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

Peers runs Consensus.Peers().

func (*ConsensusRPCAPI) RmPeer Uses

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

RmPeer runs Consensus.RmPeer().

type IPFSConnector Uses

type IPFSConnector interface {
    Component
    ID(context.Context) (*api.IPFSID, error)
    Pin(context.Context, *api.Pin) 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 IPFSConnectorRPCAPI Uses

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

IPFSConnectorRPCAPI is a go-libp2p-gorpc service which provides the internal peer API for the IPFSConnector component.

func (*IPFSConnectorRPCAPI) BlockGet Uses

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

BlockGet runs IPFSConnector.BlockGet().

func (*IPFSConnectorRPCAPI) BlockPut Uses

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

BlockPut runs IPFSConnector.BlockPut().

func (*IPFSConnectorRPCAPI) ConfigKey Uses

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

ConfigKey runs IPFSConnector.ConfigKey().

func (*IPFSConnectorRPCAPI) Pin Uses

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

Pin runs IPFSConnector.Pin().

func (*IPFSConnectorRPCAPI) PinLs Uses

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

PinLs runs IPFSConnector.PinLs().

func (*IPFSConnectorRPCAPI) PinLsCid Uses

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

PinLsCid runs IPFSConnector.PinLsCid().

func (*IPFSConnectorRPCAPI) RepoStat Uses

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

RepoStat runs IPFSConnector.RepoStat().

func (*IPFSConnectorRPCAPI) Resolve Uses

func (rpcapi *IPFSConnectorRPCAPI) Resolve(ctx context.Context, in string, out *cid.Cid) error

Resolve runs IPFSConnector.Resolve().

func (*IPFSConnectorRPCAPI) SwarmPeers Uses

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

SwarmPeers runs IPFSConnector.SwarmPeers().

func (*IPFSConnectorRPCAPI) Unpin Uses

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

Unpin runs IPFSConnector.Unpin().

type Informer Uses

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 Uses

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 PeerMonitorRPCAPI Uses

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

PeerMonitorRPCAPI is a go-libp2p-gorpc service which provides the internal peer API for the PeerMonitor component.

func (*PeerMonitorRPCAPI) LatestMetrics Uses

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

LatestMetrics runs PeerMonitor.LatestMetrics().

type Peered Uses

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 Uses

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 Uses

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 PinTrackerRPCAPI Uses

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

PinTrackerRPCAPI is a go-libp2p-gorpc service which provides the internal peer API for the PinTracker component.

func (*PinTrackerRPCAPI) Recover Uses

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

Recover runs PinTracker.Recover().

func (*PinTrackerRPCAPI) RecoverAll Uses

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

RecoverAll runs PinTracker.RecoverAll().f

func (*PinTrackerRPCAPI) Status Uses

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

Status runs PinTracker.Status().

func (*PinTrackerRPCAPI) StatusAll Uses

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

StatusAll runs PinTracker.StatusAll().

func (*PinTrackerRPCAPI) Track Uses

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

Track runs PinTracker.Track().

func (*PinTrackerRPCAPI) Untrack Uses

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

Untrack runs PinTracker.Untrack().

type RPCEndpointType Uses

type RPCEndpointType int

RPCEndpointType controls how access is granted to an RPC endpoint

const (
    // RPCClosed endpoints can only be called by the local cluster peer
    // on itself.
    RPCClosed RPCEndpointType = iota
    // RPCTrusted endpoints can be called by "trusted" peers.
    // It depends which peers are considered trusted. For example,
    // in "raft" mode, Cluster will all peers as "trusted". In "crdt" mode,
    // trusted peers are those specified in the configuration.
    RPCTrusted
    // RPCOpen endpoints can be called by any peer in the Cluster swarm.
    RPCOpen
)

RPC endpoint types w.r.t. trust level

type Tracer Uses

type Tracer interface {
    Component
}

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

Directories

PathSynopsis
adderPackage adder implements functionality to add content to IPFS daemons managed by the Cluster.
adder/adderutilsPackage adderutils provides some utilities for adding content to cluster.
adder/ipfsaddPackage ipfsadd is a simplified copy of go-ipfs/core/coreunix/add.go
adder/shardingPackage sharding implements a sharding ClusterDAGService places content in different shards while it's being added, creating a final Cluster DAG and pinning it.
adder/singlePackage single implements a ClusterDAGService that chunks and adds content to cluster without sharding, before pinning it.
allocator/ascendallocPackage ascendalloc implements an ipfscluster.PinAllocator, which returns allocations based on sorting the metrics in ascending order.
allocator/descendallocPackage descendalloc implements an ipfscluster.PinAllocator returns allocations based on sorting the metrics in descending order.
allocator/utilPackage util is a utility package used by the allocator implementations.
apiPackage api holds declarations for types used in ipfs-cluster APIs to make them re-usable across differen tools.
api/ipfsproxy
api/pbCode generated by protoc-gen-go.
api/restPackage rest implements an IPFS Cluster API component.
api/rest/clientPackage client provides a Go Client for the IPFS Cluster API provided by the "api/rest" component.
cmdutilsPackage cmdutils contains utilities to facilitate building of command line applications launching cluster peers.
configPackage config provides interfaces and utilities for different Cluster components to register, read, write and validate configuration sections stored in a central configuration file.
consensus/crdt
consensus/raftPackage raft implements a Consensus component for IPFS Cluster which uses Raft (go-libp2p-raft).
datastore/badgerPackage badger provides a configurable BadgerDB go-datastore for use with IPFS Cluster.
datastore/inmemPackage inmem provides a in-memory thread-safe datastore for use with Cluster.
informer/diskPackage disk implements an ipfs-cluster informer which can provide different disk-related metrics from the IPFS daemon as an api.Metric.
informer/numpinPackage numpin implements an ipfs-cluster informer which determines how many items this peer is pinning and returns it as api.Metric
ipfsconn/ipfshttpPackage ipfshttp implements an IPFS Cluster IPFSConnector component.
monitor/metricsPackage metrics provides common functionality for working with metrics, particulary useful for monitoring components.
monitor/pubsubmonPackage pubsubmon implements a PeerMonitor component for IPFS Cluster that uses PubSub to send and receive metrics.
observations
pintracker/maptrackerPackage maptracker implements a PinTracker component for IPFS Cluster.
pintracker/optrackerPackage optracker implements functionality to track the status of pin and operations as needed by implementations of the pintracker component.
pintracker/statelessPackage stateless implements a PinTracker component for IPFS Cluster, which aims to reduce the memory footprint when handling really large cluster states.
pintracker/util
pstoremgrPackage pstoremgr provides a Manager that simplifies handling addition, listing and removal of cluster peer multiaddresses from the libp2p Host.
rpcutilPackage rpcutil provides utility methods to perform go-libp2p-gorpc calls, particularly gorpc.MultiCall().
rpcutil/policygen
statePackage state holds the interface that any state implementation for IPFS Cluster must satisfy.
state/dsstatePackage dsstate implements the IPFS Cluster state interface using an underlying go-datastore.
testPackage test offers testing utilities for all the IPFS Cluster codebase, like IPFS daemon and RPC mocks and pre-defined testing CIDs.
utils
version

Package ipfscluster imports 42 packages (graph) and is imported by 3 packages. Updated 2019-10-13. Refresh now. Tools for package owners.