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_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(
    &self,
    addr: Multiaddr
) -> Result<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(&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)

Dials a PeerId using a known address.

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

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 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 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 fn is_bootstrapped(&self) -> bool

Returns true if the dht was bootstrapped.

pub async fn get_closest_peers<K>(&self, key: K) -> Result<()> where
    K: Into<BucketKey<K>> + Into<Vec<u8>> + Clone, 

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

pub async fn providers(&self, key: Key) -> Result<HashSet<PeerId>>

Gets providers of a key from the dht.

pub async fn provide(&self, key: Key) -> Result<()>

Provides a key in the dht.

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

Stops providing a key in the dht.

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 = 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(&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, 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 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, providers: Vec<PeerId>) -> 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 read_batch<F: FnOnce(&mut Batch<'_, P>) -> Result<R>, R>(
    &self,
    f: F
) -> Result<R>

Perform a set of storage operations in a batch, and discards the result.

You should keep a batch open for as short as possible. You must not create a batch inside a batch, or use the outer ipfs.

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

Perform a set of storage operations in a batch, and stores the result.

You should keep a batch open for as short as possible. You must not create a batch inside a batch, or use the outer ipfs.

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

Registers prometheus metrics in a registry.

pub fn swarm_events(&self) -> SwarmEvents

Subscribes to the swarm event stream.

pub fn docs(&self) -> Result<Vec<DocId>>

Returns the documents both local and replicated.

pub fn streams(&self) -> Result<Vec<StreamId>>

Returns the streams both local and replicated.

pub fn substreams(&self, doc: DocId) -> Result<Vec<StreamId>>

Returns the streams both local and replicated for the given document id.

pub fn stream_add_peers(&self, doc: DocId, peers: impl Iterator<Item = PeerId>)

Adds the peers to a replicated stream.

pub fn stream_head(&self, id: &StreamId) -> Result<Option<SignedHead>>

Returns the current head of a stream.

pub fn stream_slice(
    &self,
    id: &StreamId,
    start: u64,
    len: u64
) -> Result<StreamReader>

Returns a reader for the slice.

pub fn stream_remove(&self, id: &StreamId) -> Result<()>

Removes a local or replicated stream.

pub fn stream_append(&self, id: DocId) -> Result<LocalStreamWriter>

Returns a writter to append to a local stream.

pub fn stream_subscribe(&self, id: &StreamId) -> Result<()>

Subscribes to a replicated stream.

pub fn stream_update_head(&self, head: SignedHead)

Updates the head of a replicated 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<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.

fn query<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    path: &'life1 DagPath<'life2>
) -> Pin<Box<dyn Future<Output = Result<Ipld, Error>> + Send + 'async_trait, 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.