go-ipfs/core/coreapi/interface

Version: 0.4.15

Source: https://github.com/ipfs/go-ipfs/

import "github.com/ipfs/go-ipfs/core/coreapi/interface"

Overview

Package iface defines IPFS Core API which is a set of interfaces used to interact with IPFS nodes.

Index

Variables

var (
    ErrIsDir   = errors.New("object is a directory")
    ErrOffline = errors.New("can't resolve, ipfs node is offline")
)

type BadPinNode

type BadPinNode interface {
    // Path is the path of the node
    Path() Path

    // Err is the reason why the node has been marked as bad
    Err() error
}

BadPinNode is a node that has been marked as bad by Pin.Verify

type BlockAPI

type BlockAPI interface {
    // Put imports raw block data, hashing it using specified settings.
    Put(context.Context, io.Reader, ...options.BlockPutOption) (Path, error)

    // Get attempts to resolve the path and return a reader for data in the block
    Get(context.Context, Path) (io.Reader, error)

    // Rm removes the block specified by the path from local blockstore.
    // By default an error will be returned if the block can't be found locally.
    //
    // NOTE: If the specified block is pinned it won't be removed and no error
    // will be returned
    Rm(context.Context, Path, ...options.BlockRmOption) error

    // Stat returns information on
    Stat(context.Context, Path) (BlockStat, error)
}

BlockAPI specifies the interface to the block layer

type BlockStat

type BlockStat interface {
    // Size is the size of a block
    Size() int

    // Path returns path to the block
    Path() Path
}

BlockStat contains information about a block

type CoreAPI

type CoreAPI interface {
    // Unixfs returns an implementation of Unixfs API
    Unixfs() UnixfsAPI

    // Block returns an implementation of Block API
    Block() BlockAPI

    // Dag returns an implementation of Dag API
    Dag() DagAPI

    // Name returns an implementation of Name API
    Name() NameAPI

    // Key returns an implementation of Key API
    Key() KeyAPI

    // Pin returns an implementation of Pin API
    Pin() PinAPI

    // ObjectAPI returns an implementation of Object API
    Object() ObjectAPI

    // ResolvePath resolves the path using Unixfs resolver
    ResolvePath(context.Context, Path) (Path, error)

    // ResolveNode resolves the path (if not resolved already) using Unixfs
    // resolver, gets and returns the resolved Node
    ResolveNode(context.Context, Path) (ipld.Node, error)
}

CoreAPI defines an unified interface to IPFS for Go programs

type DagAPI

type DagAPI interface {
    // Put inserts data using specified format and input encoding.
    // Unless used with WithCodec or WithHash, the defaults "dag-cbor" and
    // "sha256" are used.
    Put(ctx context.Context, src io.Reader, opts ...options.DagPutOption) (Path, error)

    // Get attempts to resolve and get the node specified by the path
    Get(ctx context.Context, path Path) (ipld.Node, error)

    // Tree returns list of paths within a node specified by the path.
    Tree(ctx context.Context, path Path, opts ...options.DagTreeOption) ([]Path, error)
}

DagAPI specifies the interface to IPLD

type IpnsEntry

type IpnsEntry interface {
    // Name returns IpnsEntry name
    Name() string
    // Value returns IpnsEntry value
    Value() Path
}

IpnsEntry specifies the interface to IpnsEntries

type Key

type Key interface {
    // Key returns key name
    Name() string
    // Path returns key path
    Path() Path
}

Key specifies the interface to Keys in KeyAPI Keystore

type KeyAPI

type KeyAPI interface {
    // Generate generates new key, stores it in the keystore under the specified
    // name and returns a base58 encoded multihash of it's public key
    Generate(ctx context.Context, name string, opts ...options.KeyGenerateOption) (Key, error)

    // Rename renames oldName key to newName. Returns the key and whether another
    // key was overwritten, or an error
    Rename(ctx context.Context, oldName string, newName string, opts ...options.KeyRenameOption) (Key, bool, error)

    // List lists keys stored in keystore
    List(ctx context.Context) ([]Key, error)

    // Remove removes keys from keystore. Returns ipns path of the removed key
    Remove(ctx context.Context, name string) (Path, error)
}

KeyAPI specifies the interface to Keystore

type NameAPI

type NameAPI interface {
    // Publish announces new IPNS name
    Publish(ctx context.Context, path Path, opts ...options.NamePublishOption) (IpnsEntry, error)

    // Resolve attempts to resolve the newest version of the specified name
    Resolve(ctx context.Context, name string, opts ...options.NameResolveOption) (Path, error)
}

NameAPI specifies the interface to IPNS.

IPNS is a PKI namespace, where names are the hashes of public keys, and the private key enables publishing new (signed) values. In both publish and resolve, the default name used is the node’s own PeerID, which is the hash of its public key.

You can use .Key API to list and generate more names and their respective keys.

type ObjectAPI

type ObjectAPI interface {
    // New creates new, empty (by default) dag-node.
    New(context.Context, ...options.ObjectNewOption) (ipld.Node, error)

    // Put imports the data into merkledag
    Put(context.Context, io.Reader, ...options.ObjectPutOption) (Path, error)

    // Get returns the node for the path
    Get(context.Context, Path) (ipld.Node, error)

    // Data returns reader for data of the node
    Data(context.Context, Path) (io.Reader, error)

    // Links returns lint or links the node contains
    Links(context.Context, Path) ([]*ipld.Link, error)

    // Stat returns information about the node
    Stat(context.Context, Path) (*ObjectStat, error)

    // AddLink adds a link under the specified path. child path can point to a
    // subdirectory within the patent which must be present (can be overridden
    // with WithCreate option).
    AddLink(ctx context.Context, base Path, name string, child Path, opts ...options.ObjectAddLinkOption) (Path, error)

    // RmLink removes a link from the node
    RmLink(ctx context.Context, base Path, link string) (Path, error)

    // AppendData appends data to the node
    AppendData(context.Context, Path, io.Reader) (Path, error)

    // SetData sets the data contained in the node
    SetData(context.Context, Path, io.Reader) (Path, error)
}

ObjectAPI specifies the interface to MerkleDAG and contains useful utilities for manipulating MerkleDAG data structures.

type ObjectStat

type ObjectStat struct {
    // Cid is the CID of the node
    Cid *cid.Cid

    // NumLinks is number of links the node contains
    NumLinks int

    // BlockSize is size of the raw serialized node
    BlockSize int

    // LinksSize is size of the links block section
    LinksSize int

    // DataSize is the size of data block section
    DataSize int

    // CumulativeSize is size of the tree (BlockSize + link sizes)
    CumulativeSize int
}

ObjectStat provides information about dag nodes

type Path

type Path interface {
    // String returns the path as a string.
    String() string
    // Cid returns cid referred to by path
    Cid() *cid.Cid
    // Root returns cid of root path
    Root() *cid.Cid
    // Resolved returns whether path has been fully resolved
    Resolved() bool
}

Path is a generic wrapper for paths used in the API. A path can be resolved to a CID using one of Resolve functions in the API.

type Pin

type Pin interface {
    // Path to the pinned object
    Path() Path

    // Type of the pin
    Type() string
}

Pin holds information about pinned resource

type PinAPI

type PinAPI interface {
    // Add creates new pin, be default recursive - pinning the whole referenced
    // tree
    Add(context.Context, Path, ...options.PinAddOption) error

    // Ls returns list of pinned objects on this node
    Ls(context.Context, ...options.PinLsOption) ([]Pin, error)

    // Rm removes pin for object specified by the path
    Rm(context.Context, Path) error

    // Update changes one pin to another, skipping checks for matching paths in
    // the old tree
    Update(ctx context.Context, from Path, to Path, opts ...options.PinUpdateOption) error

    // Verify verifies the integrity of pinned objects
    Verify(context.Context) (<-chan PinStatus, error)
}

PinAPI specifies the interface to pining

type PinStatus

type PinStatus interface {
    // Ok indicates whether the pin has been verified to be correct
    Ok() bool

    // BadNodes returns any bad (usually missing) nodes from the pin
    BadNodes() []BadPinNode
}

PinStatus holds information about pin health

type Reader

type Reader interface {
    io.ReadSeeker
    io.Closer
}

type UnixfsAPI

type UnixfsAPI interface {
    // Add imports the data from the reader into merkledag file
    Add(context.Context, io.Reader) (Path, error)

    // Cat returns a reader for the file
    Cat(context.Context, Path) (Reader, error)

    // Ls returns the list of links in a directory
    Ls(context.Context, Path) ([]*ipld.Link, error)
}

UnixfsAPI is the basic interface to immutable files in IPFS


Generated by godoc2md