Struct ipfs_api::IpfsClient

pub struct IpfsClient { /* fields omitted */ }

Asynchronous Ipfs client.

Methods

impl IpfsClient

fn new(handle: &Handle, host: &str, port: u16) -> Result<IpfsClient, UriError>

Creates a new IpfsClient.

fn default(handle: &Handle) -> IpfsClient

Creates an IpfsClient connected to localhost:5001.

impl IpfsClient

fn add<R>(&self, data: R) -> Box<Future<Item = AddResponse, Error = Error>> where
    R: 'static + Read + Send, 

Add file to Ipfs.

Examples

use ipfs_api::IpfsClient;
use std::io::Cursor;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let data = Cursor::new("Hello World!");
let req = client.add(data);

fn bitswap_ledger(
    &self,
    peer: &str
) -> Box<Future<Item = BitswapLedgerResponse, Error = Error>>

Returns the current ledger for a peer.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bitswap_ledger("QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ");

fn bitswap_reprovide(
    &self
) -> Box<Future<Item = BitswapReprovideResponse, Error = Error>>

Triggers a reprovide.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bitswap_reprovide();

fn bitswap_stat(&self) -> Box<Future<Item = BitswapStatResponse, Error = Error>>

Returns some stats about the bitswap agent.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bitswap_stat();

fn bitswap_unwant(
    &self,
    key: &str
) -> Box<Future<Item = BitswapUnwantResponse, Error = Error>>

Remove a given block from your wantlist.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bitswap_unwant("QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA");

fn bitswap_wantlist(
    &self,
    peer: Option<&str>
) -> Box<Future<Item = BitswapWantlistResponse, Error = Error>>

Shows blocks on the wantlist for you or the specified peer.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bitswap_wantlist(Some("QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ"));

fn block_get(&self, hash: &str) -> Box<Stream<Item = Chunk, Error = Error>>

Gets a raw IPFS block.

Examples

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let hash = "QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA";
let req = client.block_get(hash).concat2();

fn block_put<R>(
    &self,
    data: R
) -> Box<Future<Item = BlockPutResponse, Error = Error>> where
    R: 'static + Read + Send, 

Store input as an IPFS block.

Examples

use ipfs_api::IpfsClient;
use std::io::Cursor;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let data = Cursor::new("Hello World!");
let req = client.block_put(data);

fn block_rm(
    &self,
    hash: &str
) -> Box<Future<Item = BlockRmResponse, Error = Error>>

Removes an IPFS block.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.block_rm("QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA");

fn block_stat(
    &self,
    hash: &str
) -> Box<Future<Item = BlockStatResponse, Error = Error>>

Prints information about a raw IPFS block.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.block_stat("QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA");

fn bootstrap_add_default(
    &self
) -> Box<Future<Item = BootstrapAddDefaultResponse, Error = Error>>

Add default peers to the bootstrap list.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bootstrap_add_default();

fn bootstrap_list(
    &self
) -> Box<Future<Item = BootstrapListResponse, Error = Error>>

Lists peers in bootstrap list.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bootstrap_list();

fn bootstrap_rm_all(
    &self
) -> Box<Future<Item = BootstrapRmAllResponse, Error = Error>>

Removes all peers in bootstrap list.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.bootstrap_rm_all();

fn cat(&self, path: &str) -> Box<Stream<Item = Chunk, Error = Error>>

Returns the contents of an Ipfs object.

Examples

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let hash = "QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA";
let req = client.cat(hash).concat2();

fn commands(&self) -> Box<Future<Item = CommandsResponse, Error = Error>>

List available commands that the server accepts.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.commands();

fn config_edit(&self) -> Box<Future<Item = ConfigEditResponse, Error = Error>>

Opens the config file for editing (on the server).

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.config_edit();

fn config_replace<R>(
    &self,
    data: R
) -> Box<Future<Item = ConfigReplaceResponse, Error = Error>> where
    R: 'static + Read + Send, 

Replace the config file.

use ipfs_api::IpfsClient;
use std::io::Cursor;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let config = Cursor::new("{..json..}");
let req = client.config_replace(config);

fn config_show(&self) -> Box<Future<Item = ConfigShowResponse, Error = Error>>

Show the current config of the server.

Returns an unparsed json string, due to an unclear spec.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.config_show();

fn dag_get(
    &self,
    path: &str
) -> Box<Future<Item = DagGetResponse, Error = Error>>

Returns information about a dag node in Ipfs.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.dag_get("QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA");

fn dht_findpeer(
    &self,
    peer: &str
) -> Box<Stream<Item = DhtFindPeerResponse, Error = Error>>

Query the DHT for all of the multiaddresses associated with a Peer ID.

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let peer = "QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM";
let req = client.dht_findpeer(peer).collect();

fn dht_findprovs(
    &self,
    key: &str
) -> Box<Stream<Item = DhtFindProvsResponse, Error = Error>>

Find peers in the DHT that can provide a specific value given a key.

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let key = "QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA";
let req = client.dht_findprovs(key).collect();

fn dht_get(
    &self,
    key: &str
) -> Box<Stream<Item = DhtGetResponse, Error = Error>>

Query the DHT for a given key.

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let key = "QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA";
let req = client.dht_get(key).collect();

fn dht_provide(
    &self,
    key: &str
) -> Box<Stream<Item = DhtProvideResponse, Error = Error>>

Announce to the network that you are providing a given value.

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let key = "QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA";
let req = client.dht_provide(key).collect();

fn dht_put(
    &self,
    key: &str,
    value: &str
) -> Box<Stream<Item = DhtPutResponse, Error = Error>>

Write a key/value pair to the DHT.

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.dht_put("test", "Hello World!").collect();

fn dht_query(
    &self,
    peer: &str
) -> Box<Stream<Item = DhtQueryResponse, Error = Error>>

Find the closest peer given the peer ID by querying the DHT.

use futures::stream::Stream;
use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let peer = "QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM";
let req = client.dht_query(peer).collect();

fn diag_cmds_clear(
    &self
) -> Box<Future<Item = DiagCmdsClearResponse, Error = Error>>

Clear inactive requests from the log.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.diag_cmds_clear();

fn diag_cmds_set_time(
    &self,
    time: &str
) -> Box<Future<Item = DiagCmdsSetTimeResponse, Error = Error>>

Set how long to keep inactive requests in the log.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.diag_cmds_set_time("1m");

fn diag_sys(&self) -> Box<Future<Item = DiagSysResponse, Error = Error>>

Print system diagnostic information.

Note: There isn't good documentation on what this call is supposed to return. It might be platform dependent, but if it isn't, this can be fixed to return an actual object.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.diag_sys();

fn dns(
    &self,
    link: &str,
    recursive: bool
) -> Box<Future<Item = DnsResponse, Error = Error>>

Resolve DNS link.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.dns("ipfs.io", true);

fn file_ls(
    &self,
    path: &str
) -> Box<Future<Item = FileLsResponse, Error = Error>>

List directory for Unix filesystem objects.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.file_ls("/ipns/ipfs.io");

fn files_cp(
    &self,
    path: &str,
    dest: &str
) -> Box<Future<Item = FilesCpResponse, Error = Error>>

Copy files into MFS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_cp("/path/to/file", "/dest");

fn files_flush(
    &self,
    path: Option<&str>
) -> Box<Future<Item = FilesFlushResponse, Error = Error>>

Flush a path's data to disk.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_flush(None);
let req = client.files_flush(Some("/tmp"));

fn files_ls(
    &self,
    path: Option<&str>
) -> Box<Future<Item = FilesLsResponse, Error = Error>>

List directories in MFS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_ls(None);
let req = client.files_ls(Some("/tmp"));

fn files_mkdir(
    &self,
    path: &str,
    parents: bool
) -> Box<Future<Item = FilesMkdirResponse, Error = Error>>

Make directories in MFS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_mkdir("/test", false);
let req = client.files_mkdir("/test/nested/dir", true);

fn files_mv(
    &self,
    path: &str,
    dest: &str
) -> Box<Future<Item = FilesMvResponse, Error = Error>>

Copy files into MFS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_mv("/test/tmp.json", "/test/file.json");

fn files_read(&self, path: &str) -> Box<Stream<Item = Chunk, Error = Error>>

Read a file in MFS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_read("/test/file.json");

fn files_rm(
    &self,
    path: &str,
    recursive: bool
) -> Box<Future<Item = FilesRmResponse, Error = Error>>

Remove a file in MFS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_rm("/test/dir", true);
let req = client.files_rm("/test/file.json", false);

fn files_stat(
    &self,
    path: &str
) -> Box<Future<Item = FilesStatResponse, Error = Error>>

Display a file's status in MDFS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.files_stat("/test/file.json");

fn files_write<R>(
    &self,
    path: &str,
    create: bool,
    truncate: bool,
    data: R
) -> Box<Future<Item = FilesWriteResponse, Error = Error>> where
    R: 'static + Read + Send, 

Write to a mutable file in the filesystem.

use ipfs_api::IpfsClient;
use std::fs::File;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let file = File::open("test.json").unwrap();
let req = client.files_write("/test/file.json", true, true, file);

fn filestore_dups(
    &self
) -> Box<Stream<Item = FilestoreDupsResponse, Error = Error>>

List blocks that are both in the filestore and standard block storage.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.filestore_dups();

fn filestore_ls(
    &self,
    cid: Option<&str>
) -> Box<Stream<Item = FilestoreLsResponse, Error = Error>>

List objects in filestore.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.filestore_ls(Some("QmYPP3BovR2m8UqCZxFbdXSit6SKgExxDkFAPLqiGsap4X"));

fn filestore_verify(
    &self,
    cid: Option<&str>
) -> Box<Stream<Item = FilestoreVerifyResponse, Error = Error>>

Verify objects in filestore.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.filestore_verify(None);

fn get(&self, path: &str) -> Box<Stream<Item = Chunk, Error = Error>>

Download Ipfs object.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.get("/test/file.json");

fn id(
    &self,
    peer: Option<&str>
) -> Box<Future<Item = IdResponse, Error = Error>>

Returns information about a peer.

If peer is None, returns information about you.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.id(None);
let req = client.id(Some("QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM"));

fn key_gen(
    &self,
    name: &str,
    kind: KeyType,
    size: i32
) -> Box<Future<Item = KeyGenResponse, Error = Error>>

Create a new keypair.

use ipfs_api::{IpfsClient, KeyType};
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.key_gen("test", KeyType::Rsa, 64);

fn key_list(&self) -> Box<Future<Item = KeyListResponse, Error = Error>>

List all local keypairs.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.key_list();

fn key_rename(
    &self,
    name: &str,
    new: &str,
    force: bool
) -> Box<Future<Item = KeyRenameResponse, Error = Error>>

Rename a keypair.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.key_rename("key_0", "new_name", false);

fn key_rm(&self, name: &str) -> Box<Future<Item = KeyRmResponse, Error = Error>>

Remove a keypair.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.key_rm("key_0");

fn log_level(
    &self,
    logger: Logger,
    level: LoggingLevel
) -> Box<Future<Item = LogLevelResponse, Error = Error>>

Change the logging level for a logger.

use ipfs_api::{IpfsClient, Logger, LoggingLevel};
use std::borrow::Cow;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.log_level(Logger::All, LoggingLevel::Debug);
let req = client.log_level(
    Logger::Specific(Cow::Borrowed("web")),
    LoggingLevel::Warning);

fn log_ls(&self) -> Box<Future<Item = LogLsResponse, Error = Error>>

List all logging subsystems.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.log_ls();

fn log_tail(&self) -> Box<Stream<Item = String, Error = Error>>

Read the event log.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.log_tail();

fn ls(
    &self,
    path: Option<&str>
) -> Box<Future<Item = LsResponse, Error = Error>>

List the contents of an Ipfs multihash.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.ls(None);
let req = client.ls(Some("/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY"));

fn name_publish(
    &self,
    path: &str,
    resolve: bool,
    lifetime: Option<&str>,
    ttl: Option<&str>,
    key: Option<&str>
) -> Box<Future<Item = NamePublishResponse, Error = Error>>

Publish an IPFS path to IPNS.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.name_publish(
    "/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY",
    false,
    Some("12h"),
    None,
    None);

fn name_resolve(
    &self,
    name: Option<&str>,
    recursive: bool,
    nocache: bool
) -> Box<Future<Item = NameResolveResponse, Error = Error>>

Resolve an IPNS name.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.name_resolve(
    Some("/ipns/ipfs.io"),
    true,
    false);

fn object_data(&self, key: &str) -> Box<Stream<Item = Chunk, Error = Error>>

Output the raw bytes of an Ipfs object.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.object_data("/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY");

fn object_diff(
    &self,
    key0: &str,
    key1: &str
) -> Box<Future<Item = ObjectDiffResponse, Error = Error>>

Returns the diff of two Ipfs objects.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.object_diff(
    "/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY",
    "/ipfs/QmXdNSQx7nbdRvkjGCEQgVjVtVwsHvV8NmV2a8xzQVwuFA");

fn object_get(
    &self,
    key: &str
) -> Box<Future<Item = ObjectGetResponse, Error = Error>>

Returns the data in an object.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.object_get("/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY");

fn object_links(
    &self,
    key: &str
) -> Box<Future<Item = ObjectLinksResponse, Error = Error>>

Returns the links that an object points to.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.object_links("/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY");

fn object_new(
    &self,
    template: Option<ObjectTemplate>
) -> Box<Future<Item = ObjectNewResponse, Error = Error>>

Create a new object.

use ipfs_api::{IpfsClient, ObjectTemplate};
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.object_new(None);
let req = client.object_new(Some(ObjectTemplate::UnixFsDir));

fn object_stat(
    &self,
    key: &str
) -> Box<Future<Item = ObjectStatResponse, Error = Error>>

Returns the stats for an object.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.object_stat("/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY");

fn pin_add(
    &self,
    key: &str,
    recursive: bool
) -> Box<Future<Item = PinAddResponse, Error = Error>>

Pins a new object.

The "recursive" option tells the server whether to pin just the top-level object, or all sub-objects it depends on. For most cases you want it to be true.

Does not yet implement the "progress" agument because reading it is kinda squirrelly.

Examples

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.pin_add("QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ", true);

fn pin_ls(
    &self,
    key: Option<&str>,
    typ: Option<&str>
) -> Box<Future<Item = PinLsResponse, Error = Error>>

Returns a list of pinned objects in local storage.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.pin_ls(None, None);
let req = client.pin_ls(
    Some("/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY"),
    None);
let req = client.pin_ls(None, Some("direct"));

fn pin_rm(
    &self,
    key: &str,
    recursive: bool
) -> Box<Future<Item = PinRmResponse, Error = Error>>

Removes a pinned object from local storage.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.pin_rm(
    "/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY",
    false);
let req = client.pin_rm(
    "/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY",
    true);

fn ping(
    &self,
    peer: &str,
    count: Option<i32>
) -> Box<Stream<Item = PingResponse, Error = Error>>

Pings a peer.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.ping("QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64", None);
let req = client.ping("QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64", Some(15));

fn pubsub_ls(&self) -> Box<Future<Item = PubsubLsResponse, Error = Error>>

List subscribed pubsub topics.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.pubsub_ls();

fn pubsub_peers(
    &self,
    topic: Option<&str>
) -> Box<Future<Item = PubsubPeersResponse, Error = Error>>

List peers that are being published to.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.pubsub_peers(None);
let req = client.pubsub_peers(Some("feed"));

fn pubsub_pub(
    &self,
    topic: &str,
    payload: &str
) -> Box<Future<Item = PubsubPubResponse, Error = Error>>

Publish a message to a topic.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.pubsub_pub("feed", "Hello World!");

fn pubsub_sub(
    &self,
    topic: &str,
    discover: bool
) -> Box<Stream<Item = PubsubSubResponse, Error = Error>>

Subscribes to a pubsub topic.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.pubsub_sub("feed", false);
let req = client.pubsub_sub("feed", true);

fn refs_local(&self) -> Box<Stream<Item = RefsLocalResponse, Error = Error>>

Gets a list of local references.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.refs_local();

fn shutdown(&self) -> Box<Future<Item = ShutdownResponse, Error = Error>>

Shutdown the Ipfs daemon.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.shutdown();

fn stats_bitswap(
    &self
) -> Box<Future<Item = StatsBitswapResponse, Error = Error>>

Returns bitswap stats.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.stats_bitswap();

fn stats_bw(&self) -> Box<Future<Item = StatsBwResponse, Error = Error>>

Returns bandwidth stats.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.stats_bw();

fn stats_repo(&self) -> Box<Future<Item = StatsRepoResponse, Error = Error>>

Returns repo stats.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.stats_repo();

fn swarm_addrs_local(
    &self
) -> Box<Future<Item = SwarmAddrsLocalResponse, Error = Error>>

Return a list of local addresses.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.swarm_addrs_local();

fn swarm_peers(&self) -> Box<Future<Item = SwarmPeersResponse, Error = Error>>

Return a list of peers with open connections.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.swarm_peers();

fn tar_add<R>(
    &self,
    data: R
) -> Box<Future<Item = TarAddResponse, Error = Error>> where
    R: 'static + Read + Send, 

Add a tar file to Ipfs.

Note: data should already be a tar file. If it isn't the Api will return an error.

use ipfs_api::IpfsClient;
use std::fs::File;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let tar = File::open("/path/to/file.tar").unwrap();
let req = client.tar_add(tar);

fn tar_cat(&self, path: &str) -> Box<Stream<Item = Chunk, Error = Error>>

Export a tar file from Ipfs.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.tar_cat("/ipfs/QmVrLsEDn27sScp3k23sgZNefVTjSAL3wpgW1iWPi4MgoY");

fn version(&self) -> Box<Future<Item = VersionResponse, Error = Error>>

Returns information about the Ipfs server version.

use ipfs_api::IpfsClient;
use tokio_core::reactor::Core;

let mut core = Core::new().unwrap();
let client = IpfsClient::default(&core.handle());
let req = client.version();