Struct transmission_rpc::TransClient[−][src]

pub struct TransClient { /* fields omitted */ }

Implementations

[src]

impl TransClient

[src]

pub fn with_auth(url: &str, basic_auth: BasicAuth) -> TransClient

Returns HTTP(S) client with configured Basic Auth

[src]

pub fn new(url: &str) -> TransClient

Returns HTTP(S) client

[src]

pub async fn session_get(&self) -> Result<RpcResponse<SessionGet>>

Performs a session get call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, SessionGet, BasicAuth};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let response: Result<RpcResponse<SessionGet>> = client.session_get().await;
    match response {
        Ok(_) => println!("Yay!"),
        Err(_) => panic!("Oh no!")
    }
    println!("Rpc response is ok: {}", response?.is_ok());
    Ok(())
}

[src]

pub async fn session_stats(&self) -> Result<RpcResponse<SessionStats>>

Performs a session stats call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, SessionStats, BasicAuth};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let response: Result<RpcResponse<SessionStats>> = client.session_stats().await;
    match response {
        Ok(_) => println!("Yay!"),
        Err(_) => panic!("Oh no!")
    }
    println!("Rpc response is ok: {}", response?.is_ok());
    Ok(())
}

[src]

pub async fn session_close(&self) -> Result<RpcResponse<SessionClose>>

Performs a session close call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth, SessionClose};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let response: Result<RpcResponse<SessionClose>> = client.session_close().await;
    match response {
        Ok(_) => println!("Yay!"),
        Err(_) => panic!("Oh no!")
    }
    println!("Rpc response is ok: {}", response?.is_ok());
    Ok(())
}

[src]

pub async fn blocklist_update(&self) -> Result<RpcResponse<BlocklistUpdate>>

Performs a blocklist update call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, BlocklistUpdate, RpcResponse, BasicAuth};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let response: Result<RpcResponse<BlocklistUpdate>> = client.blocklist_update().await;
    match response {
        Ok(_) => println!("Yay!"),
        Err(_) => panic!("Oh no!")
    }
    println!("Rpc response is ok: {}", response?.is_ok());
    Ok(())
}

[src]

pub async fn free_space(&self, path: String) -> Result<RpcResponse<FreeSpace>>

Performs a session stats call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth, FreeSpace};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let dir = env::var("TDIR")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let response: Result<RpcResponse<FreeSpace>> = client.free_space(dir).await;
    match response {
        Ok(_) => println!("Yay!"),
        Err(_) => panic!("Oh no!")
    }
    println!("Rpc response is ok: {}", response?.is_ok());
    Ok(())
}

[src]

pub async fn port_test(&self) -> Result<RpcResponse<PortTest>>

Performs a port test call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth, PortTest};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let response: Result<RpcResponse<PortTest>> = client.port_test().await;
    match response {
        Ok(_) => println!("Yay!"),
        Err(_) => panic!("Oh no!")
    }
    println!("Rpc response is ok: {}", response?.is_ok());
    Ok(())
}

[src]

pub async fn torrent_get(
 &self,
 fields: Option<Vec<TorrentGetField>>,
 ids: Option<Vec<Id>>
) -> Result<RpcResponse<Torrents<Torrent>>>

Performs a torrent get call fileds - if None then ALL fields ids - if None then All items

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth};
use transmission_rpc::types::{Torrents, Torrent, TorrentGetField, Id};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);

    let res: RpcResponse<Torrents<Torrent>> = client.torrent_get(None, None).await?;
    let names: Vec<&String> = res.arguments.torrents.iter().map(|it| it.name.as_ref().unwrap()).collect();
    println!("{:#?}", names);

    let res1: RpcResponse<Torrents<Torrent>> = client.torrent_get(Some(vec![TorrentGetField::Id, TorrentGetField::Name]), Some(vec![Id::Id(1), Id::Id(2), Id::Id(3)])).await?;
    let first_three: Vec<String> = res1.arguments.torrents.iter().map(|it|
        format!("{}. {}",&it.id.as_ref().unwrap(), &it.name.as_ref().unwrap())
    ).collect();
    println!("{:#?}", first_three);


    let res2: RpcResponse<Torrents<Torrent>> = client.torrent_get(Some(vec![TorrentGetField::Id, TorrentGetField::HashString, TorrentGetField::Name]), Some(vec![Id::Hash(String::from("64b0d9a53ac9cd1002dad1e15522feddb00152fe"))])).await?;
    let info: Vec<String> = res2.arguments.torrents.iter().map(|it|
        format!("{:5}. {:^45} {}",
            &it.id.as_ref().unwrap(),
            &it.hash_string.as_ref().unwrap(),
            &it.name.as_ref().unwrap())
    ).collect();
    println!("{:#?}", info);

    Ok(())
}

[src]

pub async fn torrent_action(
 &self,
 action: TorrentAction,
 ids: Vec<Id>
) -> Result<RpcResponse<Nothing>>

Performs a torrent action call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth};
use transmission_rpc::types::{TorrentAction, Nothing, Id};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let res1: RpcResponse<Nothing> = client.torrent_action(TorrentAction::Start, vec![Id::Id(1)]).await?;
    println!("Start result: {:?}", &res1.is_ok());
    let res2: RpcResponse<Nothing> = client.torrent_action(TorrentAction::Stop, vec![Id::Id(1)]).await?;
    println!("Stop result: {:?}", &res2.is_ok());

    Ok(())
}

[src]

pub async fn torrent_remove(
 &self,
 ids: Vec<Id>,
 delete_local_data: bool
) -> Result<RpcResponse<Nothing>>

Performs a torrent remove call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth};
use transmission_rpc::types::{Nothing, Id};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let res: RpcResponse<Nothing> = client.torrent_remove(vec![Id::Id(1)], false).await?;
    println!("Remove result: {:?}", &res.is_ok());

    Ok(())
}

[src]

pub async fn torrent_set_location(
 &self,
 ids: Vec<Id>,
 location: String,
 move_from: Option<bool>
) -> Result<RpcResponse<Nothing>>

Performs a torrent set location call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth};
use transmission_rpc::types::{Nothing, Id};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let res: RpcResponse<Nothing> = client.torrent_set_location(vec![Id::Id(1)], String::from("/new/location"), Option::from(false)).await?;
    println!("Set-location result: {:?}", &res.is_ok());

    Ok(())
}

[src]

pub async fn torrent_rename_path(
 &self,
 ids: Vec<Id>,
 path: String,
 name: String
) -> Result<RpcResponse<TorrentRenamePath>>

Performs a torrent rename path call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;
 
use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth};
use transmission_rpc::types::{TorrentRenamePath, Id};
 
#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let res: RpcResponse<TorrentRenamePath> = client.torrent_rename_path(vec![Id::Id(1)], String::from("Folder/OldFile.jpg"), String::from("NewFile.jpg")).await?;
    println!("rename-path result: {:#?}", res);
 
    Ok(())
}

[src]

pub async fn torrent_add(
&self,
add: TorrentAddArgs
) -> Result<RpcResponse<TorrentAdded>>

Performs a torrent add call

Errors

Any IO Error or Deserialization error

Example

extern crate transmission_rpc;

use std::env;
use dotenv::dotenv;
use transmission_rpc::TransClient;
use transmission_rpc::types::{Result, RpcResponse, BasicAuth};
use transmission_rpc::types::{TorrentAddArgs, TorrentAdded};

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
    env_logger::init();
    let url= env::var("TURL")?;
    let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
    let client = TransClient::with_auth(&url, basic_auth);
    let add: TorrentAddArgs = TorrentAddArgs {
        filename: Some("https://releases.ubuntu.com/20.04/ubuntu-20.04-desktop-amd64.iso.torrent".to_string()),
        ..TorrentAddArgs::default()
    };
    let res: RpcResponse<TorrentAdded> = client.torrent_add(add).await?;
    println!("Add result: {:?}", &res.is_ok());
    println!("response: {:?}", &res);

    Ok(())
}

Auto Trait Implementations

impl RefUnwindSafe for TransClient

impl Send for TransClient

impl Sync for TransClient

impl Unpin for TransClient

impl UnwindSafe for TransClient

Blanket Implementations

[src]

impl<T> Any for T where
T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<T> Borrow<T> for T where
T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

impl<T> Instrument for T

[src]

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

[src]

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

[src]

impl<T, U> Into for T where
U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

[src]

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

[src]

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

[src]

impl<T> WithSubscriber for T

[src]

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

[src]

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct transmission_rpc::TransClient[−][src]

Implementations

impl TransClient

pub fn with_auth(url: &str, basic_auth: BasicAuth) -> TransClient

pub fn new(url: &str) -> TransClient

pub async fn session_get(&self) -> Result<RpcResponse<SessionGet>>

pub async fn session_stats(&self) -> Result<RpcResponse<SessionStats>>

pub async fn session_close(&self) -> Result<RpcResponse<SessionClose>>

pub async fn blocklist_update(&self) -> Result<RpcResponse<BlocklistUpdate>>

pub async fn free_space(&self, path: String) -> Result<RpcResponse<FreeSpace>>

pub async fn port_test(&self) -> Result<RpcResponse<PortTest>>

pub async fn torrent_get( &self, fields: Option<Vec<TorrentGetField>>, ids: Option<Vec<Id>>) -> Result<RpcResponse<Torrents<Torrent>>>

pub async fn torrent_action( &self, action: TorrentAction, ids: Vec<Id>) -> Result<RpcResponse<Nothing>>

pub async fn torrent_remove( &self, ids: Vec<Id>, delete_local_data: bool) -> Result<RpcResponse<Nothing>>

pub async fn torrent_set_location( &self, ids: Vec<Id>, location: String, move_from: Option<bool>) -> Result<RpcResponse<Nothing>>

pub async fn torrent_rename_path( &self, ids: Vec<Id>, path: String, name: String) -> Result<RpcResponse<TorrentRenamePath>>

pub async fn torrent_add( &self, add: TorrentAddArgs) -> Result<RpcResponse<TorrentAdded>>

Auto Trait Implementations

impl RefUnwindSafe for TransClient

impl Send for TransClient

impl Sync for TransClient

impl Unpin for TransClient

impl UnwindSafe for TransClient

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

pub async fn torrent_get(
&self,
fields: Option<Vec<TorrentGetField>>,
ids: Option<Vec<Id>>
) -> Result<RpcResponse<Torrents<Torrent>>>

pub async fn torrent_action(
&self,
action: TorrentAction,
ids: Vec<Id>
) -> Result<RpcResponse<Nothing>>

pub async fn torrent_remove(
&self,
ids: Vec<Id>,
delete_local_data: bool
) -> Result<RpcResponse<Nothing>>

pub async fn torrent_set_location(
&self,
ids: Vec<Id>,
location: String,
move_from: Option<bool>
) -> Result<RpcResponse<Nothing>>

pub async fn torrent_rename_path(
&self,
ids: Vec<Id>,
path: String,
name: String
) -> Result<RpcResponse<TorrentRenamePath>>

pub async fn torrent_add(
&self,
add: TorrentAddArgs
) -> Result<RpcResponse<TorrentAdded>>

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,