Struct ipfs_embed::Ipfs

pub struct Ipfs<P: StoreParams> { /* private fields */ }

Ipfs node.

Implementations

impl<P: StoreParams> Ipfs<P>where
    Ipld: References<P::Codecs>,

pub async fn new(config: Config) -> Result<Self>

Creates a new Ipfs from a Config.

This starts three background tasks. The swarm, garbage collector and the dht cleanup tasks run in the background.

pub fn local_public_key(&self) -> PublicKey

Returns the local PublicKey.

pub fn local_peer_id(&self) -> PeerId

Returns the local PeerId.

pub fn local_node_name(&self) -> String

Returns the local node name.

pub fn listen_on(&mut self, addr: Multiaddr) -> impl Stream<Item = ListenerEvent>

Listens on a new Multiaddr.

pub fn listeners(&self) -> Vec<Multiaddr>

Returns the currently active listener addresses.

pub fn add_external_address(&mut self, addr: Multiaddr)

Adds an external address.

pub fn external_addresses(&self) -> Vec<AddressRecord>

Returns the currently used external addresses.

pub fn add_address(&mut self, peer: PeerId, addr: Multiaddr)

Adds a known Multiaddr for a PeerId.

pub fn remove_address(&mut self, peer: PeerId, addr: Multiaddr)

Removes a Multiaddr for a PeerId.

pub fn prune_peers(&mut self, min_age: Duration)

Removes all unconnected peers without addresses which have been in this state for at least the given duration

pub fn dial(&mut self, peer: PeerId)

Dials a PeerId using a known address.

pub fn dial_address(&mut self, peer: PeerId, addr: Multiaddr)

Dials a PeerId using Multiaddr.

pub fn ban(&mut self, peer: PeerId)

Bans a PeerId from the swarm, dropping all existing connections and preventing new connections from the peer.

pub fn unban(&mut self, peer: PeerId)

Unbans a previously banned PeerId.

pub fn peers(&self) -> Vec<PeerId>

Returns the known peers.

pub fn connections(&self) -> Vec<(PeerId, Multiaddr, DateTime<Utc>, Direction)>

Returns a list of connected peers.

pub fn is_connected(&self, peer: &PeerId) -> bool

Returns true if there is a connection to peer.

pub fn peer_info(&self, peer: &PeerId) -> Option<PeerInfo>

Returns the PeerInfo of a peer.

pub fn bootstrap(
    &mut self,
    nodes: Vec<(PeerId, Multiaddr)>
) -> impl Future<Output = Result<()>>

Bootstraps the dht using a set of bootstrap nodes. After bootstrap completes it provides all blocks in the block store.

pub fn is_bootstrapped(&self) -> bool

Returns true if the dht was bootstrapped.

pub fn providers(
    &mut self,
    key: Key
) -> impl Future<Output = Result<HashSet<PeerId>>>

Gets the closest peer to a key. Useful for finding the Multiaddr of a PeerId. Gets providers of a key from the dht.

pub fn provide(&mut self, key: Key) -> impl Future<Output = Result<()>>

Provides a key in the dht.

pub fn unprovide(&mut self, key: Key) -> Result<()>

Stops providing a key in the dht.

pub fn get_record(
    &mut self,
    key: Key,
    quorum: Quorum
) -> impl Future<Output = Result<Vec<PeerRecord>>>

Gets a record from the dht.

pub fn put_record(
    &mut self,
    record: Record,
    quorum: Quorum
) -> impl Future<Output = Result<()>>

Puts a new record in the dht.

pub fn remove_record(&mut self, key: Key) -> Result<()>

Removes a record from the dht.

pub fn subscribe(
    &mut self,
    topic: String
) -> impl Future<Output = Result<impl Stream<Item = GossipEvent>>>

Subscribes to a topic returning a Stream of messages. If all Streams for a topic are dropped it unsubscribes from the topic.

pub fn publish(
    &mut self,
    topic: String,
    msg: Vec<u8>
) -> impl Future<Output = Result<()>>

Publishes a new message in a topic, sending the message to all subscribed peers.

pub fn broadcast(
    &mut self,
    topic: String,
    msg: Vec<u8>
) -> impl Future<Output = Result<()>>

Publishes a new message in a topic, sending the message to all subscribed connected peers.

pub fn create_temp_pin(&self) -> Result<TempPin>

Creates a temporary pin in the block store. A temporary pin is not persisted to disk and is released once it is dropped.

pub fn temp_pin(&self, tmp: &mut TempPin, cid: &Cid) -> Result<()>

Adds a new root to a temporary pin.

pub fn iter(&self) -> Result<impl Iterator<Item = Cid>>

Returns an Iterator of Cids stored in the block store.

pub fn contains(&self, cid: &Cid) -> Result<bool>

Checks if the block is in the block store.

pub fn get(&self, cid: &Cid) -> Result<Block<P>>

Returns a block from the block store.

pub async fn fetch(&self, cid: &Cid, providers: Vec<PeerId>) -> Result<Block<P>>

Either returns a block if it’s in the block store or tries to retrieve it from a peer.

pub fn insert(&self, block: Block<P>) -> Result<()>

Inserts a block in to the block store.

pub fn evict(&self) -> impl Future<Output = Result<()>>

Manually runs garbage collection to completion. This is mainly useful for testing and administrative interfaces. During normal operation, the garbage collector automatically runs in the background.

pub fn sync(
    &self,
    cid: &Cid,
    providers: Vec<PeerId>
) -> impl Future<Output = Result<SyncQuery>>

pub fn alias<T: AsRef<[u8]> + Send + Sync>(
    &self,
    alias: T,
    cid: Option<&Cid>
) -> Result<()>

Creates, updates or removes an alias with a new root Cid.

pub fn aliases(&self) -> Result<Vec<(Vec<u8>, Cid)>>

List all known aliases.

pub fn resolve<T: AsRef<[u8]> + Send + Sync>(
    &self,
    alias: T
) -> Result<Option<Cid>>

Returns the root of an alias.

pub fn reverse_alias(&self, cid: &Cid) -> Result<Option<HashSet<Vec<u8>>>>

Returns a list of aliases preventing a Cid from being garbage collected.

pub fn flush(&self) -> impl Future<Output = Result<()>>

Flushes the block store. After flush completes successfully it is guaranteed that all writes have been persisted to disk.

pub fn batch_ops<R>(
    &self,
    f: impl FnOnce(&mut Batch<'_, P>) -> Result<R>
) -> Result<R>

Perform a set of storage operations in a batch

The batching concerns only the CacheTracker, it implies no atomicity guarantees!

pub fn register_metrics(&self, registry: &Registry) -> Result<()>

Registers prometheus metrics in a registry.

pub fn swarm_events(&mut self) -> impl Future<Output = Result<SwarmEvents>>

Subscribes to the swarm event stream.

Trait Implementations

impl<P: Clone + StoreParams> Clone for Ipfs<P>

fn clone(&self) -> Ipfs<P>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: StoreParams> Debug for Ipfs<P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P: StoreParams> Store for Ipfs<P>where
    Ipld: References<P::Codecs>,

type Params = P

Store parameters.

type TempPin = Arc<Mutex<RawMutex, TempPin>>

Temp pin.

fn create_temp_pin(&self) -> Result<Self::TempPin>

Creates a new temporary pin.

fn temp_pin(&self, tmp: &Self::TempPin, cid: &Cid) -> Result<()>

Adds a block to a temp pin.

fn contains(&self, cid: &Cid) -> Result<bool>

Returns true if the store contains the block.

fn get(&self, cid: &Cid) -> Result<Block<P>>

Returns a block from the store. If the block wasn’t found it returns a BlockNotFound error.

fn insert(&self, block: &Block<P>) -> Result<()>

Inserts a block into the store and publishes the block on the network.

fn alias<T: AsRef<[u8]> + Send + Sync>(
    &self,
    alias: T,
    cid: Option<&Cid>
) -> Result<()>

Creates an alias for a Cid.

fn resolve<T: AsRef<[u8]> + Send + Sync>(&self, alias: T) -> Result<Option<Cid>>

Resolves an alias for a Cid.

fn reverse_alias(&self, cid: &Cid) -> Result<Option<Vec<Vec<u8>>>>

Returns all the aliases that are keeping the block around.

fn flush<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Flushes the store.

fn fetch<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cid: &'life1 Cid
) -> Pin<Box<dyn Future<Output = Result<Block<Self::Params>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Returns a block from the store. If the store supports networking and the block is not in the store it fetches it from the network and inserts it into the store. Dropping the future cancels the request.

fn sync<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cid: &'life1 Cid
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Fetches all missing blocks recursively from the network. If a block isn’t found it returns a BlockNotFound error.