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(
    &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 prune_peers(&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(&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, 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 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: &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 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 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 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 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(&self) -> 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.

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.