#ipfs

ipfs-api

Implementation of an IPFS HTTP API client

20 releases (9 breaking)

0.13.0 Oct 13, 2021
0.11.0 Feb 14, 2021
0.9.0 Nov 2, 2020
0.8.0-rc Jul 19, 2020
0.4.0-alpha.1 Dec 26, 2017

#24 in Web programming

Download history 172/week @ 2021-07-04 441/week @ 2021-07-11 401/week @ 2021-07-18 458/week @ 2021-07-25 345/week @ 2021-08-01 269/week @ 2021-08-08 234/week @ 2021-08-15 242/week @ 2021-08-22 164/week @ 2021-08-29 206/week @ 2021-09-05 237/week @ 2021-09-12 249/week @ 2021-09-19 162/week @ 2021-09-26 274/week @ 2021-10-03 368/week @ 2021-10-10 224/week @ 2021-10-17

1,218 downloads per month
Used in 6 crates (5 directly)

MIT/Apache

180KB
3.5K SLoC

Workflow Status Maintenance

ipfs-api

Components

Name Documentation Crate
ipfs-api-prelude Docs Crate
ipfs-api-backend-actix Docs Crate
ipfs-api-backend-hyper Docs Crate
ipfs-api (deprecated) Docs Crate

Rust library for connecting to the IPFS HTTP API using Hyper/Actix.

Usage

Using Hyper

To use the Hyper backend, declare:

[dependencies]
ipfs-api-backend-hyper = "0.2"

You can specify either with-hyper-rustls or with-hyper-tls (mutually exclusive) feature for TLS support.

Using Actix

To use the Actix backend, declare:

[dependencies]
ipfs-api-backend-actix = "0.3"

Builder Pattern

With either the Hyper or Actix backend, you can specify the with-builder feature to enable a builder pattern to use when building requests.

Usage (DEPRECATED)

[dependencies]
ipfs-api = "0.13.0"

Feature Flags (DEPRECATED)

You can use actix-web as a backend instead of hyper.

[dependencies]
ipfs-api = { version = "0.13.0", features = ["with-actix"], default-features = false }

You also have the option of using rustls instead of native tls:

[dependencies]
ipfs-api = { version = "0.13.0", features = ["with-hyper-rustls"], default-features = false }

To enable the builder pattern (default) use the with-builder feature:

[dependencies]
ipfs-api = { version = "0.13.0", features = ["with-hyper-rustls", "with-builder"], default-features = false }

Examples

Writing a file to IPFS

With Hyper
use ipfs_api::{IpfsApi, IpfsClient};
use std::io::Cursor;

#[tokio::main]
async fn main() {
    let client = IpfsClient::default();
    let data = Cursor::new("Hello World!");

    match client.add(data).await {
        Ok(res) => println!("{}", res.hash),
        Err(e) => eprintln!("error adding file: {}", e)
    }
}
With Actix
use ipfs_api::{IpfsApi, IpfsClient};
use std::io::Cursor;

#[actix_rt::main]
async fn main() {
    let client = IpfsClient::default();
    let data = Cursor::new("Hello World!");

    match client.add(data).await {
        Ok(res) => println!("{}", res.hash),
        Err(e) => eprintln!("error adding file: {}", e)
    }
}

Reading a file from IPFS

With Hyper
use futures::TryStreamExt;
use ipfs_api::{IpfsApi, IpfsClient};
use std::io::{self, Write};

#[tokio::main]
async fn main() {
    let client = IpfsClient::default();

    match client
        .get("/test/file.json")
        .map_ok(|chunk| chunk.to_vec())
        .try_concat()
        .await
    {
        Ok(res) => {
            let out = io::stdout();
            let mut out = out.lock();

            out.write_all(&res).unwrap();
        }
        Err(e) => eprintln!("error getting file: {}", e)
    }
}
With Actix
use futures::TryStreamExt;
use ipfs_api::{IpfsApi, IpfsClient};
use std::io::{self, Write};

#[actix_rt::main]
async fn main() {
    let client = IpfsClient::default();

    match client
        .get("/test/file.json")
        .map_ok(|chunk| chunk.to_vec())
        .try_concat()
        .await
    {
        Ok(res) => {
            let out = io::stdout();
            let mut out = out.lock();

            out.write_all(&res).unwrap();
        }
        Err(e) => eprintln!("error getting file: {}", e)
    }
}

Additional Examples

There are also a bunch of examples included in the project, which I used for testing

For a list of examples, run:

$ cargo run --example

You can run any of the examples with cargo:

$ cargo run --example add_file

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Dependencies

~7–13MB
~284K SLoC

Qfa