Struct ipfs_embed::Ipfs

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

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_peer_id(&self) -> PeerId

Returns the local PeerId.

pub async fn listen_on(&self, addr: Multiaddr) -> Result<Multiaddr>

Listens on a new Multiaddr.

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

Returns the currently active listener addresses.

pub fn add_external_address(&self, addr: Multiaddr)

Adds an external address.

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

Returns the currently used external addresses.

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

Adds a known Multiaddr for a PeerId.

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

Removes a Multiaddr for a PeerId.

pub fn dial(&self, peer: &PeerId) -> Result<()>

Dials a PeerId using a known address.

pub fn dial_address(&self, peer: &PeerId, addr: Multiaddr) -> Result<()>

Dials a PeerId using Multiaddr.

pub fn ban(&self, peer: PeerId)

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

pub fn unban(&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)>

Returns a list of connected peers.

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

Returns the PeerInfo of a peer.

pub async fn bootstrap(&self, nodes: &[(PeerId, Multiaddr)]) -> Result<()>

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

pub async fn get_record(
    &self,
    key: &Key,
    quorum: Quorum
) -> Result<Vec<PeerRecord>>

Gets a record from the dht.

pub async fn put_record(&self, record: Record, quorum: Quorum) -> Result<()>

Puts a new record in the dht.

pub fn remove_record(&self, key: &Key)

Removes a record from the dht.

pub fn subscribe(&self, topic: &str) -> Result<impl Stream<Item = Vec<u8>>>

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(&self, topic: &str, msg: Vec<u8>) -> Result<()>

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

pub fn broadcast(&self, topic: &str, msg: Vec<u8>) -> 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: &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) -> 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<impl Future<Output = Result<()>> + '_>

Inserts a block in to the block store and announces it to peers.

pub async fn evict(&self) -> 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) -> SyncQuery<P>

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 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<Vec<Vec<u8>>>>

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

pub async fn flush(&self) -> Result<()>

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

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

Registers prometheus metrics in a registry.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

type Params = P

Store parameters.

type TempPin = Arc<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.

#[must_use]pub fn query<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    path: &'life1 DagPath<'life2>
) -> Pin<Box<dyn Future<Output = Result<Ipld, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait,
    Ipld: Decode<<Self::Params as StoreParams>::Codecs>, 

Resolves a path recursively and returns the ipld.