Struct ipfs_embed::Ipfs

pub struct Ipfs<P, S, N> { /* fields omitted */ }

Implementations

impl<P, S, N> Ipfs<P, S, N> where
    P: StoreParams + Unpin + 'static,
    S: Storage<P>,
    N: Network<P>,
    Ipld: References<P::Codecs>, 

pub fn new(storage: Arc<S>, network: Arc<N>) -> Self

pub fn local_peer_id(&self) -> &PeerId

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

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

pub async fn pinned(&self, cid: &Cid) -> Result<Option<bool>>

pub fn bitswap_storage(&self) -> BitswapStorage<P, S>

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

impl Ipfs<DefaultParams, StorageService<DefaultParams>, NetworkService<DefaultParams>>

pub async fn default(path: Option<PathBuf>, cache_size: usize) -> Result<Self>

If no path is provided a temporary db will be created.

Trait Implementations

impl<P, S, N> Clone for Ipfs<P, S, N>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, S, N> Store for Ipfs<P, S, N> where
    P: StoreParams + Unpin + 'static,
    S: Storage<P>,
    N: Network<P>,
    Ipld: References<P::Codecs>, 

type Params = P

Store parameters.

pub fn get<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cid: &'life1 Cid
) -> Pin<Box<dyn Future<Output = Result<Block<P>>> + 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.

pub fn insert<'life0, 'life1, 'async_trait>(
    &'life0 self,
    block: &'life1 Block<P>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

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

pub fn alias<'life0, 'life1, 'async_trait, T: AsRef<[u8]> + Send + Sync>(
    &'life0 self,
    alias: T,
    cid: Option<&'life1 Cid>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Creates an alias for a Cid. To alias a block all it's recursive references must be in the store. If blocks are missing, they will be fetched from the network. If they aren't found, it will return a BlockNotFound error.

pub fn resolve<'life0, 'async_trait, T: AsRef<[u8]> + Send + Sync>(
    &'life0 self,
    alias: T
) -> Pin<Box<dyn Future<Output = Result<Option<Cid>>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Resolves an alias for a Cid.

#[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.