Struct Client 

pub struct Client<K, S>
where
    K: KeyMaterial + Clone + 'static,
    S: UcanStore + BlockStore + 'static,
{
    pub session: IdentifyResponse,
    pub sphere_identity: String,
    pub api_base: Url,
    pub author: Author<K>,
    pub store: S,
    /* private fields */
}

A Client is a simple, portable HTTP client for the Noosphere gateway REST API. It embodies the intended usage of the REST API, which includes an opening handshake (with associated key verification) and various UCAN-authorized verbs over sphere data.

Fields

session: IdentifyResponse

The v0alpha1::IdentifyResponse that was received from the gateway when the Client was initialized

sphere_identity: String

The Did of the sphere represented by this Client

api_base: Url

The Url for the gateway API being used by this Client

author: Author<K>

The Author that is wielding this Client to interact with the gateway API

store: S

The backing BlockStore (also used as a UcanStore) for this Client

Implementations

impl<K, S> Client<K, S>

where K: KeyMaterial + Clone + 'static, S: UcanStore + BlockStore + 'static,

pub async fn identify( sphere_identity: &str, api_base: &Url, author: &Author<K>, did_parser: &mut DidParser, store: S, ) -> Result<Client<K, S>>

Initialize the Client by perfoming an “identification” handshake with a gateway whose API presumably lives at the specified URL. The request is authorized (so the provided Author must have the appropriate credentials), and the gateway responds with a v0alpha1::IdentifyResponse to verify its own credentials for the client.

pub async fn replicate<R>( &self, mode: R, params: Option<&ReplicateParameters>, ) -> Result<(Cid, impl Stream<Item = Result<(Cid, Vec<u8>)>>)>

where R: Into<ReplicationMode>,

Replicate content from Noosphere, streaming its blocks from the configured gateway.

If v0alpha1::ReplicateParameters are specified, then the replication will represent incremental history going back to the since version.

Otherwise, the full crate::data::SphereIpld will be replicated (excluding any history).

If the gateway doesn’t have the desired content, it will look it up from other sources such as IPFS if they are available. Note that this means this call can potentially block on upstream access to an IPFS node (which, depending on the node’s network configuration and peering status, can be quite slow).

pub async fn fetch( &self, params: &FetchParameters, ) -> Result<Option<(Link<MemoIpld>, impl Stream<Item = Result<(Cid, Vec<u8>)>>)>>

Fetch the latest, canonical history of the client’s sphere from the gateway, which serves as the aggregation point for history across many clients.

pub async fn push( &self, push_body: &PushBody, ) -> Result<PushResponse, PushError>

Push the latest local history of this client to the gateway