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"
)

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

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

var RPCProtocol = protocol.ID(
    fmt.Sprintf("/ipfscluster/%d.%d/rpc", Version.Major, Version.Minor),
)

var ReadyTimeout = 30 * time.Second

var Version = semver.MustParse("0.5.0")

type API interface {
    Component
}

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

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

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
    // contains filtered or unexported fields
}

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() <-chan struct{}
    // Logs a pin operation
    LogPin(c api.Pin) error
    // Logs an unpin operation
    LogUnpin(c api.Pin) error
    AddPeer(p peer.ID) error
    RmPeer(p peer.ID) error
    State() (state.State, error)
    // Provide a node which is responsible to perform
    // specific tasks which must only run in 1 cluster peer
    Leader() (peer.ID, error)
    // Only returns when the consensus state has all log
    // updates applied to it
    WaitForSync() error
    // Clean removes all consensus data
    Clean() error
    // Peers returns the peerset participating in the Consensus
    Peers() ([]peer.ID, error)
}

type IPFSConnector interface {
    Component
    ID() (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() error
    // SwarmPeers returns the IPFS daemon's swarm peers
    SwarmPeers() (api.SwarmPeers, 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() (api.IPFSRepoStat, error)
    // BlockPut directly adds a block of data to the IPFS repo
    BlockPut(api.NodeWithMeta) error
    // BlockGet retrieves the raw data of an IPFS block
    BlockGet(cid.Cid) ([]byte, error)
}

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

type PeerMonitor interface {
    Component
    // LogMetric stores a metric. It can be used to manually inject
    // a metric to a monitor.
    LogMetric(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(api.Metric) error
    // LatestMetrics returns a map with the latest metrics of matching name
    // for the current cluster peers.
    LatestMetrics(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
}

type Peered interface {
    AddPeer(p peer.ID)
    RmPeer(p peer.ID)
}

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(c cid.Cid, current, candidates, priority map[peer.ID]api.Metric) ([]peer.ID, error)
}

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(api.Pin) error
    // Untrack tells the tracker that a Cid is to be forgotten. The tracker
    // may perform an IPFS unpin operation.
    Untrack(cid.Cid) error
    // StatusAll returns the list of pins with their local status.
    StatusAll() []api.PinInfo
    // Status returns the local status of a given Cid.
    Status(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() ([]api.PinInfo, error)
    // Sync makes sure that the Cid status reflect the real IPFS status.
    // It returns the local status of the Cid.
    Sync(cid.Cid) (api.PinInfo, error)
    // RecoverAll calls Recover() for all pins tracked.
    RecoverAll() ([]api.PinInfo, error)
    // Recover retriggers a Pin/Unpin operation in a Cids with error status.
    Recover(cid.Cid) (api.PinInfo, error)
}

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