cadey
/
lena
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

add download url settings 

Signed-off-by: Xe <me@christine.website>
This commit is contained in:
Cadey Ratio 2021-10-21 19:12:27 -04:00
parent 11a333bef4
commit 8933661b03
7 changed files with 226 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Cargo.lock generated
View File

@ -338,6 +338,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]] [[package]]
name = "lena" name = "lena"
version = "0.1.0" version = "0.1.0"
dependencies = [
"transmission_rs",
]
[[package]] [[package]]
name = "libc" name = "libc"

2
crates/lena/Cargo.toml
View File

@ -6,3 +6,5 @@ edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]
transmission_rs = { path = "../transmission-rs" }

5
crates/lena/diesel.toml Normal file
View File

@ -0,0 +1,5 @@
# For documentation on how to configure this file,
# see diesel.rs/guides/configuring-diesel-cli
[print_schema]
file = "src/schema.rs"

0
crates/lena/migrations/.gitkeep Normal file
View File

311
crates/transmission-rs/src/client.rs
View File

@ -16,13 +16,12 @@ mod list;
use list::FieldList; use list::FieldList;
use list::TorrentList; use list::TorrentList;
pub mod torrent; pub mod torrent;
use torrent::Torrent;
use torrent::TorrentFile;
use torrent::AddTorrent; use torrent::AddTorrent;
use torrent::AddTorrentResponse; use torrent::AddTorrentResponse;
use torrent::GetTorrentFilesRequest; use torrent::GetTorrentFilesRequest;
use torrent::GetTorrentFilesResponse; use torrent::GetTorrentFilesResponse;
//use torrent::AddedTorrent; use torrent::Torrent;
use torrent::TorrentFile;
/// Interface into the major functions of Transmission /// Interface into the major functions of Transmission
/// including adding, and removing torrents. /// including adding, and removing torrents.
@ -31,149 +30,191 @@ use torrent::GetTorrentFilesResponse;
/// ``` /// ```
#[derive(Clone)] #[derive(Clone)]
pub struct Client { pub struct Client {
host: String, host: String,
port: u16, port: u16,
tls: bool, tls: bool,
auth: Option<(String, String)>, auth: Option<(String, String)>,
base_url: String, base_url: String,
session_id: Option<String>, session_id: Option<String>,
http: reqwest::Client, http: reqwest::Client,
} }
impl Client { impl Client {
// TODO: Take Option<(&str, &str)> for auth pub fn new<T, U>(
pub fn new(host: impl ToString, port: u16, tls: bool, auth: Option<(String, String)>) -> Result<Self, Error> { host: impl ToString,
let mut headers = reqwest::header::HeaderMap::new(); port: u16,
headers.insert(reqwest::header::USER_AGENT, "transmission-rs/0.1".try_into()?); tls: bool,
let this = Self{ auth: Option<(T, U)>,
host: host.to_string(), ) -> Result<Self, Error>
port: port, where
tls: tls, T: Into<String>,
auth: auth, U: Into<String>,
base_url: { {
let protocol = match tls { let mut headers = reqwest::header::HeaderMap::new();
true => "https", headers.insert(
false => "http" reqwest::header::USER_AGENT,
}; "transmission-rs/0.1".try_into()?,
format!("{}://{}:{}", protocol, host.to_string(), port) );
}, let auth = match auth {
session_id: None, Some((u, p)) => Some((u.into(), p.into())),
http: reqwest::Client::builder() None => None,
.gzip(true) };
.default_headers(headers) let this = Self {
.build()? host: host.to_string(),
}; port,
Ok(this) tls,
} auth,
base_url: {
let protocol = match tls {
true => "https",
false => "http",
};
format!("{}://{}:{}", protocol, host.to_string(), port)
},
session_id: None,
http: reqwest::Client::builder()
.gzip(true)
.default_headers(headers)
.build()?,
};
Ok(this)
}
fn build_url(&self, path: impl AsRef<str>) -> String { fn build_url(&self, path: impl AsRef<str>) -> String {
format!("{}{}", self.base_url, path.as_ref()).to_string() format!("{}{}", self.base_url, path.as_ref()).to_string()
} }
pub async fn authenticate(&mut self) -> Result<(), Error> { pub async fn authenticate(&mut self) -> Result<(), Error> {
self.session_id = None; self.session_id = None;
let response = self.post("/transmission/rpc/") let response = self
.header("Content-Type", "application/x-www-form-urlencoded") .post("/transmission/rpc/")
.send() .header("Content-Type", "application/x-www-form-urlencoded")
.await?; .send()
self.session_id = match response.headers().get("X-Transmission-Session-Id") { .await?;
Some(v) => Some(v.to_str()?.to_string()), self.session_id = match response.headers().get("X-Transmission-Session-Id") {
None => None // TODO: Return an error Some(v) => Some(v.to_str()?.to_string()),
}; None => None, // TODO: Return an error
Ok(()) };
} Ok(())
}
pub fn post(&self, path: impl AsRef<str>) -> reqwest::RequestBuilder { pub fn post(&self, path: impl AsRef<str>) -> reqwest::RequestBuilder {
let url = self.build_url(path); let url = self.build_url(path);
//println!("{}", url); //println!("{}", url);
let mut request = self.http.post(&url); let mut request = self.http.post(&url);
request = match &self.auth { request = match &self.auth {
Some(auth) => request.basic_auth(&auth.0, Some(&auth.1)), Some(auth) => request.basic_auth(&auth.0, Some(&auth.1)),
None => request None => request,
}; };
request = match &self.session_id { request = match &self.session_id {
Some(token) => request.header("X-Transmission-Session-Id", token), Some(token) => request.header("X-Transmission-Session-Id", token),
None => request None => request,
}; };
request request
} }
pub async fn rpc(&mut self, method: impl ToString, tag: u8, body: impl Serialize) -> Result<reqwest::Response, Error> { pub async fn rpc(
let request = Request::new(method, tag, body); &mut self,
let mut error = None; method: impl ToString,
for i in 0..5 { tag: u8,
sleep(Duration::from_secs(i)).await; body: impl Serialize,
let result = self.post("/transmission/rpc/") ) -> Result<reqwest::Response, Error> {
// Content-Type doesn't actually appear to be necessary, and is let request = Request::new(method, tag, body);
// technically a lie, since there's no key/value being passed, let mut error = None;
// just some JSON, but the official client sends this, so we for i in 0..5 {
// will too. sleep(Duration::from_secs(i)).await;
.header("Content-Type", "application/x-www-form-urlencoded") let result = self
.body(serde_json::to_string(&request)?) .post("/transmission/rpc/")
.send().await? // Content-Type doesn't actually appear to be necessary, and is
.error_for_status(); // technically a lie, since there's no key/value being passed,
match result { // just some JSON, but the official client sends this, so we
Ok(r) => return Ok(r), // will too.
Err(e) => match e.status() { .header("Content-Type", "application/x-www-form-urlencoded")
Some(reqwest::StatusCode::CONFLICT) => { .body(serde_json::to_string(&request)?)
self.authenticate().await?; .send()
error = Some(e); .await?
continue; .error_for_status();
}, match result {
_ => return Err(e.into()) Ok(r) => return Ok(r),
} Err(e) => match e.status() {
}; Some(reqwest::StatusCode::CONFLICT) => {
} self.authenticate().await?;
match error { error = Some(e);
Some(e) => Err(e.into()), continue;
// Should be unreachable }
None => Err(Error::HTTPUnknown) _ => return Err(e.into()),
} },
} };
}
match error {
Some(e) => Err(e.into()),
// Should be unreachable
None => Err(Error::HTTPUnknown),
}
}
pub async fn list(&mut self) -> Result<Vec<Torrent>, Error> { pub async fn list(&mut self) -> Result<Vec<Torrent>, Error> {
let field_list = FieldList::from_vec(vec![ let field_list = FieldList::from_vec(vec![
"error", "error",
"errorString", "errorString",
"eta", "eta",
"id", "id",
"isFinished", "isFinished",
"leftUntilDone", "leftUntilDone",
"name", "name",
"peersGettingFromUs", "peersGettingFromUs",
"peersSendingToUs", "peersSendingToUs",
"rateDownload", "rateDownload",
"rateUpload", "rateUpload",
"sizeWhenDone", "sizeWhenDone",
"status", "status",
"uploadRatio" "uploadRatio",
]); ]);
let response: Response<TorrentList> = self.rpc("torrent-get", 4, field_list).await?.error_for_status()?.json().await?; let response: Response<TorrentList> = self
Ok(response.arguments.torrents) .rpc("torrent-get", 4, field_list)
} .await?
.error_for_status()?
.json()
.await?;
Ok(response.arguments.torrents)
}
// TODO: Borrow key from value // TODO: Borrow key from value
pub async fn list_by_name(&mut self) -> Result<BTreeMap<String, Torrent>, Error> { pub async fn list_by_name(&mut self) -> Result<BTreeMap<String, Torrent>, Error> {
Ok(self.list().await?.into_iter().map(|v| (v.name.clone(), v)).collect::<BTreeMap<_, _>>()) Ok(self
} .list()
.await?
.into_iter()
.map(|v| (v.name.clone(), v))
.collect::<BTreeMap<_, _>>())
}
pub async fn add_torrent_from_link(&mut self, url: impl ToString) -> Result<AddTorrentResponse, Error> { pub async fn add_torrent(&mut self, data: AddTorrent) -> Result<AddTorrentResponse, Error> {
let response: Response<AddTorrentResponse> = self.rpc("torrent-add", 8, AddTorrent{filename: url.to_string()}).await?.error_for_status()?.json().await?; let response: Response<AddTorrentResponse> = self
Ok(response.arguments) .rpc("torrent-add", 8, data)
} .await?
.error_for_status()?
.json()
.await?;
Ok(response.arguments)
}
pub async fn get_files_by_id(&mut self, id: u16) -> Result<Vec<TorrentFile>, Error> { pub async fn get_files_by_id(&mut self, id: u16) -> Result<Vec<TorrentFile>, Error> {
let response: Response<GetTorrentFilesResponse> = self.rpc("torrent-get", 3, GetTorrentFilesRequest::new(id)).await?.error_for_status()?.json().await?; let response: Response<GetTorrentFilesResponse> = self
if(response.arguments.torrents.len() == 0) { .rpc("torrent-get", 3, GetTorrentFilesRequest::new(id))
// TODO: Maybe make the Ok result an Option? Or maybe return a 404 error? .await?
return Ok(vec![]); .error_for_status()?
} else if(response.arguments.torrents.len() > 1) { .json()
return Err(Error::WeirdGetFilesResponse); .await?;
} if (response.arguments.torrents.len() == 0) {
// TODO: Figure out how to move files out of this structure, since we're discarding the rest anyway, instead of cloning // TODO: Maybe make the Ok result an Option? Or maybe return a 404 error?
Ok(response.arguments.torrents[0].files.clone()) return Ok(vec![]);
} } else if (response.arguments.torrents.len() > 1) {
return Err(Error::WeirdGetFilesResponse);
}
// TODO: Figure out how to move files out of this structure, since we're discarding the rest anyway, instead of cloning
Ok(response.arguments.torrents[0].files.clone())
}
} }

75
crates/transmission-rs/src/client/torrent.rs
View File

@ -6,79 +6,80 @@ use serde::Serialize;
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
pub struct Torrent { pub struct Torrent {
pub id: u16, pub id: u16,
pub error: u8, pub error: u8,
pub error_string: String, pub error_string: String,
pub eta: i64, // TODO: Option<u64> with -1 as None pub eta: i64, // TODO: Option<u64> with -1 as None
pub is_finished: bool, pub is_finished: bool,
pub left_until_done: u64, // TODO: u32? pub left_until_done: u64, // TODO: u32?
pub name: String, pub name: String,
pub peers_getting_from_us: u16, pub peers_getting_from_us: u16,
pub peers_sending_to_us: u16, pub peers_sending_to_us: u16,
pub rate_download: u32, pub rate_download: u32,
pub rate_upload: u32, pub rate_upload: u32,
pub size_when_done: u64, pub size_when_done: u64,
pub status: u8, pub status: u8,
pub upload_ratio: f32 pub upload_ratio: f32,
} }
#[derive(Debug, Serialize)] #[derive(Debug, Serialize)]
pub struct AddTorrent { pub struct AddTorrent {
pub filename: String pub filename: String,
#[serde(rename = "download-dir")]
pub download_dir: String,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
pub struct AddedTorrent { pub struct AddedTorrent {
pub id: u16, pub id: u16,
pub name: String, pub name: String,
pub hash_string: String pub hash_string: String,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")] #[serde(rename_all = "kebab-case")]
pub enum AddTorrentResponse { pub enum AddTorrentResponse {
TorrentAdded(AddedTorrent), TorrentAdded(AddedTorrent),
TorrentDuplicate(AddedTorrent) TorrentDuplicate(AddedTorrent),
} }
#[derive(Debug, Serialize)] #[derive(Debug, Serialize)]
#[serde(rename_all = "kebab-case")] #[serde(rename_all = "kebab-case")]
pub struct GetTorrentFilesRequest { pub struct GetTorrentFilesRequest {
fields: Vec<String>, fields: Vec<String>,
ids: u16 ids: u16,
} }
impl GetTorrentFilesRequest { impl GetTorrentFilesRequest {
pub fn new(id: u16) -> Self { pub fn new(id: u16) -> Self {
Self{ Self {
fields: vec!["files".to_string()], fields: vec!["files".to_string()],
ids: id ids: id,
} }
} }
} }
#[derive(Clone, Debug, Deserialize)] #[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
pub struct TorrentFile { pub struct TorrentFile {
pub name: PathBuf, pub name: PathBuf,
pub bytes_completed: u64, pub bytes_completed: u64,
pub length: u64 pub length: u64,
} }
impl TorrentFile { impl TorrentFile {
pub fn take_name(self) -> PathBuf { pub fn take_name(self) -> PathBuf {
self.name self.name
} }
} }
#[derive(Debug, Deserialize)] #[derive(Debug, Deserialize)]
pub struct TorrentFileWrapper { pub struct TorrentFileWrapper {
pub files: Vec<TorrentFile> pub files: Vec<TorrentFile>,
} }
#[derive(Debug, Deserialize)] #[derive(Debug, Deserialize)]
pub struct GetTorrentFilesResponse { pub struct GetTorrentFilesResponse {
pub torrents: Vec<TorrentFileWrapper> pub torrents: Vec<TorrentFileWrapper>,
} }

3
shell.nix
View File

@ -3,9 +3,10 @@
pkgs.mkShell { pkgs.mkShell {
buildInputs = with pkgs; [ buildInputs = with pkgs; [
rustc cargo rustfmt rls rust-analyzer rustc cargo rustfmt rls rust-analyzer
pkg-config sqlite openssl pkg-config sqlite openssl diesel-cli
# keep this line if you use bash # keep this line if you use bash
pkgs.bashInteractive pkgs.bashInteractive
]; ];
DATABASE_URL = "./var/lena.db";
} }