qbit-rs 0.5.1

A Rust library for interacting with qBittorrent's Web API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

#![allow(private_interfaces, private_bounds)]

use std::{fmt::Debug, sync::Mutex};

use tap::Pipe;
use url::Url;

use crate::{Client, LoginState, Qbit, ext::Cookie, model::Credential};

pub struct QbitBuilder<C = (), R = (), E = ()> {
    credential: C,
    client: R,
    endpoint: E,
}

trait IntoLoginState {
    fn into_login_state(self) -> LoginState;
}

impl IntoLoginState for Cookie {
    fn into_login_state(self) -> LoginState {
        LoginState::CookieProvided { cookie: self.0 }
    }
}

impl IntoLoginState for Credential {
    fn into_login_state(self) -> LoginState {
        LoginState::NotLoggedIn { credential: self }
    }
}

impl QbitBuilder {
    /// Creates a new `QbitBuilder` with default values.
    pub fn new() -> Self {
        QbitBuilder {
            credential: (),
            client: (),
            endpoint: (),
        }
    }
}

impl Default for QbitBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl<C, R, E> QbitBuilder<C, R, E> {
    /// Sets the HTTP client for the `Qbit` instance.
    ///
    /// - When `reqwest` feature is enabled (by default), this method accepts a
    ///   `reqwest::Client`.
    /// - When `cyper` feature is enabled, this method accepts a
    ///   `cyper::Client`.
    pub fn client(self, client: Client) -> QbitBuilder<C, Client, E> {
        QbitBuilder {
            credential: self.credential,
            client,
            endpoint: self.endpoint,
        }
    }

    /// Sets the cookie for authentication.
    ///
    /// Note that if you have already set the credential, this method will
    /// overwrite the credential and use the cookie instead. The builder
    /// will use the latest provided credential for authentication.
    #[allow(private_interfaces)]
    pub fn cookie(self, cookie: impl Into<String>) -> QbitBuilder<Cookie, R, E> {
        QbitBuilder {
            credential: Cookie(cookie.into()),
            client: self.client,
            endpoint: self.endpoint,
        }
    }

    /// Sets the username-password credentials for authentication.
    ///
    /// Note that if you have already set the cookie, this method will overwrite
    /// the cookie and use the credential instead. The builder will use the
    /// latest provided credential for authentication.
    pub fn credential(self, credential: Credential) -> QbitBuilder<Credential, R, E> {
        QbitBuilder {
            credential,
            client: self.client,
            endpoint: self.endpoint,
        }
    }

    /// Sets the endpoint URL for the qBittorrent Web API.
    pub fn endpoint<U>(self, endpoint: U) -> QbitBuilder<C, R, U>
    where
        U: TryInto<Url>,
    {
        QbitBuilder {
            credential: self.credential,
            client: self.client,
            endpoint,
        }
    }
}

impl<C, U> QbitBuilder<C, Client, U>
where
    C: IntoLoginState,
    U: TryInto<Url>,
    U::Error: Debug,
{
    /// Builds the `Qbit` instance with the provided configuration and HTTP
    /// Client.
    pub fn build(self) -> Qbit {
        let endpoint = self.endpoint.try_into().expect("Invalid endpoint");
        let state = self.credential.into_login_state().pipe(Mutex::new);

        Qbit {
            client: self.client,
            endpoint,
            state,
        }
    }
}

impl<C, U> QbitBuilder<C, (), U>
where
    C: IntoLoginState,
    U: TryInto<Url>,
    U::Error: Debug,
{
    /// Builds the `Qbit` instance with the provided configuration and a default
    /// HTTP Client.
    pub fn build(self) -> Qbit {
        self.client(Client::new()).build()
    }
}

#[test]
fn test_builder() {
    QbitBuilder::new()
        .client(Client::new())
        .endpoint("http://localhost:8080")
        .credential(Credential::new("admin", "adminadmin"))
        .build();

    QbitBuilder::new()
        .endpoint("http://localhost:8080")
        .credential(Credential::new("admin", "adminadmin"))
        .build();

    QbitBuilder::new()
        .client(Client::new())
        .endpoint("http://localhost:8080")
        .cookie("SID=1234567890")
        .build();

    QbitBuilder::new()
        .endpoint("http://localhost:8080")
        .cookie("SID=1234567890")
        .build();
}