powergate: github.com/textileio/powergate/ffs Index | Files | Directories

package ffs

import "github.com/textileio/powergate/ffs"

Index

Package Files

interfaces.go types.go

Variables

var (
    // EmptyInstanceID represents an empty/invalid Instance ID.
    EmptyInstanceID = APIID("")
)
var (
    // EmptyJobID represents an empty JobID.
    EmptyJobID = JobID("")
)
var JobStatusStr = map[JobStatus]string{
    Unspecified: "Unspecified",
    Queued:      "Queued",
    Executing:   "Executing",
    Failed:      "Failed",
    Canceled:    "Canceled",
    Success:     "Success",
}

JobStatusStr maps JobStatus to describing string.

var PaychDirStr = map[PaychDir]string{
    PaychDirUnspecified: "Unspecified",
    PaychDirInbound:     "Inbound",
    PaychDirOutbound:    "Outbound",
}

PaychDirStr maps PaychDirs to describing string.

type APIID Uses

type APIID string

APIID is an identifier for a Api instance.

func NewAPIID Uses

func NewAPIID() APIID

NewAPIID returns a new InstanceID.

func (APIID) String Uses

func (i APIID) String() string

String returns a string representation of InstanceID.

func (APIID) Valid Uses

func (i APIID) Valid() bool

Valid returns true if the InstanceID is valid, false otherwise.

type CidInfo Uses

type CidInfo struct {
    JobID   JobID
    Cid     cid.Cid
    Created time.Time
    Hot     HotInfo
    Cold    ColdInfo
}

CidInfo contains information about the current storage state of a Cid.

type CidLogger Uses

type CidLogger interface {
    Log(context.Context, cid.Cid, string, ...interface{})
    Watch(context.Context, chan<- LogEntry) error
    Get(context.Context, cid.Cid) ([]LogEntry, error)
}

CidLogger saves log information about a Cid executions.

type CidLoggerCtxKey Uses

type CidLoggerCtxKey int

CidLoggerCtxKey is a type to use in ctx values for CidLogger.

const (
    // CtxKeyJid is the key to store Jid metadata.
    CtxKeyJid CidLoggerCtxKey = iota
)

type ColdConfig Uses

type ColdConfig struct {
    // Enabled indicates that data will be saved in Cold storage.
    // If is switched from false->true, it will consider the other attributes
    // as the desired state of the data in this Storage.
    Enabled bool
    // Filecoin describes the desired Filecoin configuration for a Cid in the
    // Filecoin network.
    Filecoin FilConfig
}

ColdConfig is the desired state of a Cid in a cold layer.

func (ColdConfig) Validate Uses

func (cc ColdConfig) Validate() error

Validate validates a ColdConfig.

type ColdInfo Uses

type ColdInfo struct {
    Enabled  bool
    Filecoin FilInfo
}

ColdInfo contains information about the current storage state of a Cid in the cold layer.

type ColdStorage Uses

type ColdStorage interface {
    // Store stores a Cid using the provided configuration and
    // account address. It returns a slice of accepted proposed deals,
    // a slice of rejected proposal deals, and the size of the data.
    Store(context.Context, cid.Cid, FilConfig) ([]cid.Cid, []DealError, uint64, error)

    // WaitForDeal blocks the provided Deal Proposal reach a
    // final state. If the deal finishes successfully it returns a FilStorage
    // result. If the deal finished with error, it returns a ffs.DealError
    // error result, so it should be considered in error handling.
    WaitForDeal(context.Context, cid.Cid, cid.Cid) (FilStorage, error)

    // Fetch fetches the cid data in the underlying storage.
    Fetch(context.Context, cid.Cid, string) error

    // EnsureRenewals executes renewal logic for a Cid under a particular
    // configuration. It returns a slice of deal errors happened during execution.
    EnsureRenewals(context.Context, cid.Cid, FilInfo, FilConfig) (FilInfo, []DealError, error)

    // IsFIlDealActive returns true if the proposal Cid is active on chain;
    // returns false otherwise.
    IsFilDealActive(context.Context, cid.Cid) (bool, error)
}

ColdStorage is slow/cheap storage for Cid data. It has native support for Filecoin storage.

type DealError Uses

type DealError struct {
    ProposalCid cid.Cid
    Miner       string
    Message     string
}

DealError contains information about a failed deal.

func (DealError) Error Uses

func (de DealError) Error() string

type DealRecordsManager Uses

type DealRecordsManager interface {
    ListStorageDealRecords(opts ...deals.ListDealRecordsOption) ([]deals.StorageDealRecord, error)
    ListRetrievalDealRecords(opts ...deals.ListDealRecordsOption) ([]deals.RetrievalDealRecord, error)
}

DealRecordsManager provides access to deal records.

type FilConfig Uses

type FilConfig struct {
    // RepFactor indicates the desired amount of active deals
    // with different miners to store the data. While making deals
    // the other attributes of FilConfig are considered for miner selection.
    RepFactor int
    // DealMinDuration indicates the duration to be used when making new deals.
    DealMinDuration int64
    // ExcludedMiners is a set of miner addresses won't be ever be selected
    // when making new deals, even if they comply to other filters.
    ExcludedMiners []string
    // TrustedMiners is a set of miner addresses which will be forcibly used
    // when making new deals. An empty/nil list disables this feature.
    TrustedMiners []string
    // CountryCodes indicates that new deals should select miners on specific
    // countries.
    CountryCodes []string
    // Renew indicates deal-renewal configuration.
    Renew FilRenew
    // Addr is the wallet address used to store the data in filecoin
    Addr string
    // MaxPrice is the maximum price that will be spent to store the data
    MaxPrice uint64
}

FilConfig is the desired state of a Cid in the Filecoin network.

func (*FilConfig) Validate Uses

func (fc *FilConfig) Validate() error

Validate returns a non-nil error if the configuration is invalid.

type FilInfo Uses

type FilInfo struct {
    DataCid   cid.Cid
    Size      uint64
    Proposals []FilStorage
}

FilInfo contains information about the current storage state of a Cid in the Filecoin network.

type FilRenew Uses

type FilRenew struct {
    // Enabled indicates that deal-renewal is enabled for this Cid.
    Enabled bool
    // Threshold indicates how many epochs before expiring should trigger
    // deal renewal. e.g: 100 epoch before expiring.
    Threshold int
}

FilRenew contains renew configuration for a Cid Cold Storage deals.

func (*FilRenew) Validate Uses

func (fr *FilRenew) Validate() error

Validate returns a non-nil error if the configuration is invalid.

type FilStorage Uses

type FilStorage struct {
    ProposalCid     cid.Cid
    Renewed         bool
    Duration        int64
    ActivationEpoch int64
    StartEpoch      uint64
    Miner           string
    EpochPrice      uint64
}

FilStorage contains Deal information of a storage in Filecoin.

type HotConfig Uses

type HotConfig struct {
    // Enable indicates if Cid data is stored. If true, it will consider
    // further configurations to execute actions.
    Enabled bool
    // AllowUnfreeze indicates that if data isn't available in the Hot Storage,
    // it's allowed to be feeded by Cold Storage if available.
    AllowUnfreeze bool
    // Ipfs contains configuration related to storing Cid data in a IPFS node.
    Ipfs IpfsConfig
}

HotConfig is the desired storage of a Cid in a Hot Storage.

func (HotConfig) Validate Uses

func (hc HotConfig) Validate() error

Validate validates a HotConfig.

type HotInfo Uses

type HotInfo struct {
    Enabled bool
    Size    int
    Ipfs    IpfsHotInfo
}

HotInfo contains information about the current storage state of a Cid in the hot layer.

type HotStorage Uses

type HotStorage interface {
    // Add adds io.Reader data ephemerally (not pinned).
    Add(context.Context, io.Reader) (cid.Cid, error)

    // Remove removes a stored Cid.
    Remove(context.Context, cid.Cid) error

    // Get retrieves a stored Cid data.
    Get(context.Context, cid.Cid) (io.Reader, error)

    // Store stores a Cid. If the data wasn't previously Added,
    // depending on the implementation it may use internal mechanisms
    // for pulling the data, e.g: IPFS network
    Store(context.Context, cid.Cid) (int, error)

    // Replace replaces a stored Cid with a new one. It's mostly
    // thought for mutating data doing this efficiently.
    Replace(context.Context, cid.Cid, cid.Cid) (int, error)

    // IsStore returns true if the Cid is stored, or false
    // otherwise.
    IsStored(context.Context, cid.Cid) (bool, error)
}

HotStorage is a fast storage layer for Cid data.

type IpfsConfig Uses

type IpfsConfig struct {
    // AddTimeout is an upper bound on adding data to IPFS node from
    // the network before failing.
    AddTimeout int
}

IpfsConfig is the desired storage of a Cid in IPFS.

func (*IpfsConfig) Validate Uses

func (ic *IpfsConfig) Validate() error

Validate validates an IpfsConfig.

type IpfsHotInfo Uses

type IpfsHotInfo struct {
    Created time.Time
}

IpfsHotInfo contains information about the current storage state of a Cid in an IPFS node.

type Job Uses

type Job struct {
    ID         JobID
    APIID      APIID
    Cid        cid.Cid
    Status     JobStatus
    ErrCause   string
    DealErrors []DealError
}

Job is a task executed by the Scheduler.

type JobID Uses

type JobID string

JobID is an identifier for a ffs.Job.

func NewJobID Uses

func NewJobID() JobID

NewJobID returns a new JobID.

func (JobID) String Uses

func (jid JobID) String() string

String returns a string representation of JobID.

type JobStatus Uses

type JobStatus int

JobStatus is a type for Job statuses.

const (
    // Unspecified indicates a default or empty value
    Unspecified JobStatus = iota
    // Queued indicates the Job is queued in the Scheduler.
    Queued
    // Executing indicates that the Job is currently being
    // executed.
    Executing
    // Failed indicates the Job failed, with job.ErrCause with
    // the error cause.
    Failed
    // Canceled indicates the Job was canceled from Queued,
    // and didn't reach execution.
    Canceled
    // Success indicates the Job was successfully executed.
    Success
)

type LogEntry Uses

type LogEntry struct {
    Cid       cid.Cid
    Timestamp time.Time
    Jid       JobID
    Msg       string
}

LogEntry is a log entry from a Cid execution.

type MinerProposal Uses

type MinerProposal struct {
    Addr       string
    EpochPrice uint64
}

MinerProposal contains a miners address and storage ask information to make a, most probably, successful deal.

type MinerSelector Uses

type MinerSelector interface {
    // GetMiners returns a specified amount of miners that satisfy
    // provided filters.
    GetMiners(int, MinerSelectorFilter) ([]MinerProposal, error)
}

MinerSelector returns miner addresses and ask storage information using a desired strategy.

type MinerSelectorFilter Uses

type MinerSelectorFilter struct {
    // ExcludedMiners contains miner addresses that should not be considered in
    // returned results. An empty list means no exclusions.
    ExcludedMiners []string
    // TrustedMiners contains miner addresses that will be prioritized
    // if are available in the query result. If the number of expected
    // results exceeeds the number of trusted miners, the remaining amount
    // of results will be returned still applying the rest of the filters
    // and the MinerSelector sorting logic.
    TrustedMiners []string
    // CountryCodes contains long-ISO country names that should be
    // considered in selected miners. An empty list means no filtering.
    CountryCodes []string
    // MaxPrice is the max ask price to consider when selecting miner deals
    MaxPrice uint64
}

MinerSelectorFilter establishes filters that should be considered when returning miners.

type PaychDir Uses

type PaychDir int

PaychDir specifies the direction of a payment channel.

const (
    // PaychDirUnspecified is an undefined direction.
    PaychDirUnspecified PaychDir = iota
    // PaychDirInbound is an inbound direction.
    PaychDirInbound
    // PaychDirOutbound is an outbound direction.
    PaychDirOutbound
)

type PaychInfo Uses

type PaychInfo struct {
    CtlAddr   string
    Addr      string
    Direction PaychDir
}

PaychInfo holds information about a payment channel.

type PaychManager Uses

type PaychManager interface {
    // List lists all payment channels involving the specified addresses.
    List(ctx context.Context, addrs ...string) ([]PaychInfo, error)
    // Create creates a new payment channel.
    Create(ctx context.Context, from string, to string, amount uint64) (PaychInfo, cid.Cid, error)
    // Redeem redeems a payment channel.
    Redeem(ctx context.Context, ch string) error
}

PaychManager provides access to payment channels.

type StorageConfig Uses

type StorageConfig struct {
    Hot        HotConfig
    Cold       ColdConfig
    Repairable bool
}

StorageConfig contains a default storage configuration for an Api instance.

func (StorageConfig) Validate Uses

func (s StorageConfig) Validate() error

Validate validates a StorageConfig.

func (StorageConfig) WithColdAddr Uses

func (s StorageConfig) WithColdAddr(addr string) StorageConfig

WithColdAddr specifies the wallet address that should be used for transactions.

func (StorageConfig) WithColdEnabled Uses

func (s StorageConfig) WithColdEnabled(enabled bool) StorageConfig

WithColdEnabled allows to enable/disable Cold storage usage.

func (StorageConfig) WithColdFilCountryCodes Uses

func (s StorageConfig) WithColdFilCountryCodes(countryCodes []string) StorageConfig

WithColdFilCountryCodes defines a list of allowed country codes to select miners for deals.

func (StorageConfig) WithColdFilDealDuration Uses

func (s StorageConfig) WithColdFilDealDuration(duration int64) StorageConfig

WithColdFilDealDuration defines the duration used for deals for Filecoin storage.

func (StorageConfig) WithColdFilExcludedMiners Uses

func (s StorageConfig) WithColdFilExcludedMiners(miners []string) StorageConfig

WithColdFilExcludedMiners defines a list of miner addresses which won't be selected for making deals, no matter if they comply to other filters in the configuration.

func (StorageConfig) WithColdFilRenew Uses

func (s StorageConfig) WithColdFilRenew(enabled bool, threshold int) StorageConfig

WithColdFilRenew specifies if deals should be renewed before they expire with a particular threshold chain epochs.

func (StorageConfig) WithColdFilRepFactor Uses

func (s StorageConfig) WithColdFilRepFactor(repFactor int) StorageConfig

WithColdFilRepFactor defines the replication factor for Filecoin storage.

func (StorageConfig) WithColdFilTrustedMiners Uses

func (s StorageConfig) WithColdFilTrustedMiners(miners []string) StorageConfig

WithColdFilTrustedMiners defines a list of trusted miners addresses which will be returned if available. If more miners reusults are needed, other filters will be applied as usual.

func (StorageConfig) WithColdMaxPrice Uses

func (s StorageConfig) WithColdMaxPrice(maxPrice uint64) StorageConfig

WithColdMaxPrice specifies the max price that should be considered for deal asks even when all other filers match.

func (StorageConfig) WithHotAllowUnfreeze Uses

func (s StorageConfig) WithHotAllowUnfreeze(allow bool) StorageConfig

WithHotAllowUnfreeze allows the Scheduler to fetch data from the Cold Storage, if the Enabled flag of the Hot Storage switches from false->true.

func (StorageConfig) WithHotEnabled Uses

func (s StorageConfig) WithHotEnabled(enabled bool) StorageConfig

WithHotEnabled allows to enable/disable Hot storage usage.

func (StorageConfig) WithHotIpfsAddTimeout Uses

func (s StorageConfig) WithHotIpfsAddTimeout(seconds int) StorageConfig

WithHotIpfsAddTimeout specifies a timeout for fetching data in Ipfs.

func (StorageConfig) WithRepairable Uses

func (s StorageConfig) WithRepairable(enabled bool) StorageConfig

WithRepairable allows to enable/disable auto-repair.

type WalletManager Uses

type WalletManager interface {
    // MasterAddr returns the master address.
    // Will return address.Undef is Powergate was started with no master address.
    MasterAddr() address.Address
    // NewAddress creates a new address.
    NewAddress(context.Context, string) (string, error)
    // Balance returns the current balance for an address.
    Balance(context.Context, string) (uint64, error)
    // SendFil sends fil from one address to another.
    SendFil(context.Context, string, string, *big.Int) error
}

WalletManager provides access to a Lotus wallet for a Lotus node.

Directories

PathSynopsis
api
auth
cidlogger
coreipfs
filcold
manager
minerselector/fixed
minerselector/reptop
rpc
scheduler
scheduler/internal/astore
scheduler/internal/cistore
scheduler/internal/jstore

Package ffs imports 9 packages (graph) and is imported by 23 packages. Updated 2020-08-05. Refresh now. Tools for package owners.