From 6b20f4a2eb8134b35d63cfdb9eed71c76bce6148 Mon Sep 17 00:00:00 2001 From: Bryan Newbold Date: Thu, 4 Feb 2021 22:38:58 -0800 Subject: refactor into new commands file/module; add several commands; work-in-progress --- rust/fatcat-cli/src/api.rs | 66 ++-------- rust/fatcat-cli/src/commands.rs | 272 +++++++++++++++++++++++++++++++++++++++ rust/fatcat-cli/src/download.rs | 17 ++- rust/fatcat-cli/src/entities.rs | 38 +++++- rust/fatcat-cli/src/lib.rs | 190 ++------------------------- rust/fatcat-cli/src/main.rs | 241 ++++++++++++++++++++++++++++++---- rust/fatcat-cli/src/specifier.rs | 110 +++++++++++++++- 7 files changed, 667 insertions(+), 267 deletions(-) create mode 100644 rust/fatcat-cli/src/commands.rs (limited to 'rust') diff --git a/rust/fatcat-cli/src/api.rs b/rust/fatcat-cli/src/api.rs index 2db2efb..cc6fa6a 100644 --- a/rust/fatcat-cli/src/api.rs +++ b/rust/fatcat-cli/src/api.rs @@ -1,4 +1,4 @@ -use crate::{parse_macaroon_editor_id, ClientStatus, EntityType, Specifier}; +use crate::{parse_macaroon_editor_id, EntityType, Specifier}; use anyhow::{anyhow, Context, Result}; use fatcat_openapi::models; use fatcat_openapi::{ApiNoContext, ContextWrapperExt}; @@ -14,16 +14,13 @@ type FatcatApiContextType = swagger::make_context_ty!( pub struct FatcatApiClient { pub api: Box>, pub rt: tokio::runtime::Runtime, - api_token: Option, - api_host: String, + pub api_token: Option, + pub api_host: String, pub editor_id: Option, } impl FatcatApiClient { - pub fn new( - api_host: String, - api_token: Option, - ) -> Result { + pub fn new(api_host: String, api_token: Option) -> Result { let auth_data = match api_token { Some(ref token) => Some(AuthData::Bearer(auth::Bearer { token: token.clone(), @@ -39,9 +36,11 @@ impl FatcatApiClient { ); //let wrapped_client: swagger::ContextWrapper< - let client = fatcat_openapi::client::Client::try_new(&api_host).context("failed to create HTTP(S) client")?; + let client = fatcat_openapi::client::Client::try_new(&api_host) + .context("failed to create HTTP(S) client")?; let wrapped_client = Box::new(client.with_context(context)); - let rt: tokio::runtime::Runtime = tokio::runtime::Runtime::new().expect("create tokio runtime"); + let rt: tokio::runtime::Runtime = + tokio::runtime::Runtime::new().expect("create tokio runtime"); let editor_id = match api_token { Some(ref token) => { @@ -59,55 +58,6 @@ impl FatcatApiClient { }) } - pub fn status(&mut self) -> Result { - let last_changelog = match self.rt.block_on(self.api.get_changelog(Some(1))) { - Ok(fatcat_openapi::GetChangelogResponse::Success(entry_vec)) => { - Some(entry_vec[0].index) - } - Ok(_) | Err(_) => None, - }; - let has_api_token = self.api_token.is_some(); - let account: Option = if has_api_token && last_changelog.is_some() { - match self - .rt - .block_on(self.api.auth_check(None)) - .context("check auth token")? - { - fatcat_openapi::AuthCheckResponse::Success(_) => Ok(()), - fatcat_openapi::AuthCheckResponse::Forbidden(err) => { - Err(anyhow!("Forbidden ({}): {}", err.error, err.message)) - } - fatcat_openapi::AuthCheckResponse::NotAuthorized { body: err, .. } => { - Err(anyhow!("Bad Request ({}): {}", err.error, err.message)) - } - resp => return Err(anyhow!("{:?}", resp)).context("auth check failed"), - } - .context("check auth token")?; - match self - .rt - .block_on( - self.api - .get_editor(self.editor_id.as_ref().unwrap().to_string()), - ) - .context("fetching editor account info")? - { - fatcat_openapi::GetEditorResponse::Found(editor) => Some(editor), - fatcat_openapi::GetEditorResponse::NotFound(err) => { - return Err(anyhow!("Not Found: {}", err.message)) - } - resp => return Err(anyhow!("{:?}", resp)).context("editor fetch failed"), - } - } else { - None - }; - Ok(ClientStatus { - api_host: self.api_host.clone(), - has_api_token, - last_changelog, - account, - }) - } - pub fn update_editgroup_submit( &mut self, editgroup_id: String, diff --git a/rust/fatcat-cli/src/commands.rs b/rust/fatcat-cli/src/commands.rs new file mode 100644 index 0000000..c0000c7 --- /dev/null +++ b/rust/fatcat-cli/src/commands.rs @@ -0,0 +1,272 @@ +use anyhow::{anyhow, Context, Result}; +use chrono_humanize::HumanTime; +use fatcat_openapi::models; +#[allow(unused_imports)] +use log::{self, debug, info}; +use std::io::{Write, BufRead}; +use tabwriter::TabWriter; +use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor}; + +use crate::api::FatcatApiClient; +//use crate::download::download_file; +use crate::entities::{ApiEntityModel, ApiModelIdent, ApiModelSer, Mutation}; +//use crate::specifier::Specifier; + +// Want to show: +// - whether api_token found +// - configured api_host we are connecting to +// - whether we can connect to remote host (eg, get most recent changelog) +// - whether our auth is valid +// - current active editgroup +#[derive(Debug, PartialEq, Clone, serde::Serialize)] +pub struct ClientStatus { + pub has_api_token: bool, + pub api_host: String, + pub last_changelog: Option, + pub account: Option, +} + +impl ClientStatus { + pub fn generate(api_client: &mut FatcatApiClient) -> Result { + let last_changelog = match api_client + .rt + .block_on(api_client.api.get_changelog(Some(1))) + { + Ok(fatcat_openapi::GetChangelogResponse::Success(entry_vec)) => { + Some(entry_vec[0].index) + } + Ok(_) | Err(_) => None, + }; + let has_api_token = api_client.api_token.is_some(); + let account: Option = if has_api_token && last_changelog.is_some() { + match api_client + .rt + .block_on(api_client.api.auth_check(None)) + .context("check auth token")? + { + fatcat_openapi::AuthCheckResponse::Success(_) => Ok(()), + fatcat_openapi::AuthCheckResponse::Forbidden(err) => { + Err(anyhow!("Forbidden ({}): {}", err.error, err.message)) + } + fatcat_openapi::AuthCheckResponse::NotAuthorized { body: err, .. } => { + Err(anyhow!("Bad Request ({}): {}", err.error, err.message)) + } + resp => return Err(anyhow!("{:?}", resp)).context("auth check failed"), + } + .context("check auth token")?; + match api_client + .rt + .block_on( + api_client + .api + .get_editor(api_client.editor_id.as_ref().unwrap().to_string()), + ) + .context("fetching editor account info")? + { + fatcat_openapi::GetEditorResponse::Found(editor) => Some(editor), + fatcat_openapi::GetEditorResponse::NotFound(err) => { + return Err(anyhow!("Not Found: {}", err.message)) + } + resp => return Err(anyhow!("{:?}", resp)).context("editor fetch failed"), + } + } else { + None + }; + Ok(ClientStatus { + api_host: api_client.api_host.clone(), + has_api_token, + last_changelog, + account, + }) + } + + pub fn pretty_print(self) -> Result<()> { + let mut color_stdout = StandardStream::stdout(if atty::is(atty::Stream::Stdout) { + ColorChoice::Auto + } else { + ColorChoice::Never + }); + let color_normal = ColorSpec::new(); + let mut color_bold = ColorSpec::new(); + color_bold.set_bold(true); + let mut color_happy = ColorSpec::new(); + color_happy.set_fg(Some(Color::Green)).set_bold(true); + let mut color_sad = ColorSpec::new(); + color_sad.set_fg(Some(Color::Red)).set_bold(true); + + color_stdout.set_color(&color_normal)?; + write!(&mut color_stdout, "{:>16}: ", "API host")?; + color_stdout.set_color(&color_bold)?; + write!(&mut color_stdout, "{}", self.api_host)?; + match self.last_changelog { + Some(index) => { + color_stdout.set_color(&color_happy)?; + writeln!(&mut color_stdout, " [successfully connected]")?; + color_stdout.set_color(&color_normal)?; + write!(&mut color_stdout, "{:>16}: ", "Last changelog")?; + color_stdout.set_color(&color_bold)?; + writeln!(&mut color_stdout, "{}", index)?; + } + None => { + color_stdout.set_color(&color_sad)?; + writeln!(&mut color_stdout, " [Failed to connect]")?; + } + }; + color_stdout.set_color(&color_normal)?; + write!(&mut color_stdout, "{:>16}: ", "API auth token")?; + if self.has_api_token { + color_stdout.set_color(&color_happy)?; + writeln!(&mut color_stdout, "[configured]")?; + } else { + color_stdout.set_color(&color_sad)?; + writeln!(&mut color_stdout, "[not configured]")?; + }; + if let Some(editor) = self.account { + color_stdout.set_color(&color_normal)?; + write!(&mut color_stdout, "{:>16}: ", "Account")?; + color_stdout.set_color(&color_bold)?; + write!(&mut color_stdout, "{}", editor.username)?; + if editor.is_bot == Some(true) { + color_stdout + .set_color(ColorSpec::new().set_fg(Some(Color::Blue)).set_bold(true))?; + write!(&mut color_stdout, " [bot]")?; + } + if editor.is_admin == Some(true) { + color_stdout + .set_color(ColorSpec::new().set_fg(Some(Color::Magenta)).set_bold(true))?; + write!(&mut color_stdout, " [admin]")?; + } + match editor.is_active { + Some(true) => { + color_stdout.set_color(&color_happy)?; + writeln!(&mut color_stdout, " [active]")?; + } + Some(false) | None => { + color_stdout.set_color(&color_sad)?; + writeln!(&mut color_stdout, " [disabled]")?; + } + }; + color_stdout.set_color(&color_normal)?; + writeln!( + &mut color_stdout, + "{:>16} editor_{}", + "", + editor.editor_id.unwrap() + )?; + }; + color_stdout.set_color(&color_normal)?; + Ok(()) + } +} + +pub fn print_editgroups(eg_list: Vec, json: bool) -> Result<()> { + if json { + for eg in eg_list { + writeln!(&mut std::io::stdout(), "{}", eg.to_json_string()?)?; + } + } else { + let mut tw = TabWriter::new(std::io::stdout()); + writeln!( + tw, + "editgroup_id\tchangelog_index\tcreated\tsubmitted\tdescription" + )?; + for eg in eg_list { + writeln!( + tw, + "{}\t{}\t{}\t{}\t{}", + eg.editgroup_id.unwrap(), + eg.changelog_index + .map_or("-".to_string(), |v| v.to_string()), + eg.created + .map_or("-".to_string(), |v| HumanTime::from(v).to_string()), + eg.submitted + .map_or("-".to_string(), |v| HumanTime::from(v).to_string()), + eg.description.unwrap_or_else(|| "-".to_string()) + )?; + } + tw.flush()?; + } + Ok(()) +} + +pub fn print_changelog_entries(entry_list: Vec, json: bool) -> Result<()> { + if json { + for entry in entry_list { + writeln!(&mut std::io::stdout(), "{}", entry.to_json_string()?)?; + } + } else { + let mut tw = TabWriter::new(std::io::stdout()); + writeln!(tw, "index\ttimestamp\teditor\teditgroup_description")?; + for entry in entry_list { + writeln!( + tw, + "{}\t{}\t{}\t{}", + entry.index, + HumanTime::from(entry.timestamp).to_string(), + entry + .editgroup + .as_ref() + .unwrap() + .editor + .as_ref() + .map_or("-".to_string(), |v| v.username.to_string()), + entry + .editgroup + .as_ref() + .unwrap() + .description + .as_ref() + .map_or("-".to_string(), |v| v.to_string()), + )?; + } + tw.flush()?; + } + Ok(()) +} + +pub fn print_entity_histories( + history_list: Vec, + json: bool, +) -> Result<()> { + if json { + for history in history_list { + writeln!(&mut std::io::stdout(), "{}", history.to_json_string()?)?; + } + } else { + let mut tw = TabWriter::new(std::io::stdout()); + writeln!( + tw, + "changelog_index\ttype\ttimestamp\teditor\teditgroup_description" + )?; + for history in history_list { + let state = match ( + history.edit.revision, + history.edit.prev_revision, + history.edit.redirect_ident, + ) { + (Some(_), None, None) => "create", + (Some(_), Some(_), None) => "update", + (None, _, None) => "delete", + (None, _, Some(_)) => "redirect", + _ => "-", + }; + writeln!( + tw, + "{}\t{}\t{}\t{}\t{}", + history.changelog_entry.index, + state, + HumanTime::from(history.changelog_entry.timestamp).to_string(), + history + .editgroup + .editor + .map_or("-".to_string(), |v| v.username.to_string()), + history + .editgroup + .description + .unwrap_or_else(|| "-".to_string()) + )?; + } + tw.flush()?; + } + Ok(()) +} diff --git a/rust/fatcat-cli/src/download.rs b/rust/fatcat-cli/src/download.rs index c8c05fd..0fcf370 100644 --- a/rust/fatcat-cli/src/download.rs +++ b/rust/fatcat-cli/src/download.rs @@ -1,10 +1,9 @@ - use anyhow::{anyhow, Context, Result}; -use indicatif::ProgressBar; use fatcat_openapi::models::FileEntity; +use indicatif::ProgressBar; use reqwest::header::USER_AGENT; -use url::Url; use std::fs::File; +use url::Url; #[derive(Debug, PartialEq, Clone)] pub enum DownloadStatus { @@ -18,7 +17,11 @@ pub enum DownloadStatus { // eg, https://web.archive.org/web/20140802044207/http://www.geo.coop:80/sites/default/files/labs_of_oligarchy.pdf fn rewrite_wayback_url(url: Url) -> Result { // TODO: make this function correct, and add tests - let mut segments: Vec = url.path_segments().unwrap().map(|x| x.to_string()).collect(); + let mut segments: Vec = url + .path_segments() + .unwrap() + .map(|x| x.to_string()) + .collect(); if segments[0] == "web" && segments[1].len() == 14 { segments[1] = format!("{}id_", segments[1]); } @@ -27,7 +30,6 @@ fn rewrite_wayback_url(url: Url) -> Result { /// Attempts to download a file entity, including verifying checksum. pub fn download_file(fe: FileEntity) -> Result { - // TODO: check if file has sha1hex // TODO: check if file already exists @@ -44,7 +46,8 @@ pub fn download_file(fe: FileEntity) -> Result { println!("downloading: {}", url); let client = reqwest::blocking::Client::new(); - let mut resp = client.get(url) + let mut resp = client + .get(url) .header(USER_AGENT, "fatcat-cli/0.0.0") .send()?; @@ -57,7 +60,7 @@ pub fn download_file(fe: FileEntity) -> Result { // TODO: what if no filesize? // TODO: compare with resp.content_length(() -> Option let pb = ProgressBar::new(fe.size.unwrap() as u64); - let out_size = resp.copy_to(&mut pb.wrap_write(out_file))?; + let _out_size = resp.copy_to(&mut pb.wrap_write(out_file))?; Ok(DownloadStatus::NotYet) } diff --git a/rust/fatcat-cli/src/entities.rs b/rust/fatcat-cli/src/entities.rs index eee3946..314af51 100644 --- a/rust/fatcat-cli/src/entities.rs +++ b/rust/fatcat-cli/src/entities.rs @@ -1,8 +1,12 @@ use crate::Specifier; -use anyhow::{anyhow, Result}; +use anyhow::{anyhow, Context, Result}; use fatcat_openapi::models; use lazy_static::lazy_static; +use log::{self, info}; use regex::Regex; +use std::io::BufRead; +use std::io::Read; +use std::path::PathBuf; use std::str::FromStr; #[derive(Debug, PartialEq, Clone)] @@ -58,6 +62,38 @@ impl ApiEntityModel for models::Editor {} impl ApiEntityModel for models::Editgroup {} impl ApiEntityModel for models::ChangelogEntry {} +pub fn read_entity_file(input_path: Option) -> Result { + // treat "-" as "use stdin" + let input_path = match input_path { + Some(s) if s.to_string_lossy() == "-" => None, + _ => input_path, + }; + match input_path { + None => { + let mut line = String::new(); + std::io::stdin().read_line(&mut line)?; + Ok(line) + } + Some(path) if path.extension().map(|v| v.to_str()) == Some(Some("toml")) => { + info!("reading {:?} as TOML", path); + // as a hack, read TOML but then serialize it back to JSON + let mut contents = String::new(); + let mut input_file = + std::fs::File::open(path).context("reading entity from TOML file")?; + input_file.read_to_string(&mut contents)?; + let value: toml::Value = contents.parse().context("parsing TOML file")?; + Ok(serde_json::to_string(&value)?) + } + Some(path) => { + let mut line = String::new(); + let input_file = std::fs::File::open(path)?; + let mut buffered = std::io::BufReader::new(input_file); + buffered.read_line(&mut line)?; + Ok(line) + } + } +} + pub trait ApiModelSer { fn to_json_string(&self) -> Result; fn to_toml_string(&self) -> Result; diff --git a/rust/fatcat-cli/src/lib.rs b/rust/fatcat-cli/src/lib.rs index 93c17fb..8a48a3b 100644 --- a/rust/fatcat-cli/src/lib.rs +++ b/rust/fatcat-cli/src/lib.rs @@ -1,123 +1,23 @@ use anyhow::{anyhow, Context, Result}; -use chrono_humanize::HumanTime; use data_encoding::BASE64; -use fatcat_openapi::models; -#[allow(unused_imports)] -use log::{self, debug, info}; use macaroon::{Macaroon, Verifier}; -use std::io::BufRead; -use std::io::Read; -use std::io::Write; -use std::path::PathBuf; use std::str::FromStr; -use tabwriter::TabWriter; -use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor}; mod api; +mod commands; +mod download; mod entities; mod search; mod specifier; -mod download; pub use api::FatcatApiClient; -pub use entities::{ApiEntityModel, ApiModelIdent, ApiModelSer, Mutation}; +pub use commands::{ + print_changelog_entries, print_editgroups, print_entity_histories, ClientStatus, +}; +pub use download::download_file; +pub use entities::{read_entity_file, ApiEntityModel, ApiModelIdent, ApiModelSer, Mutation}; pub use search::crude_search; pub use specifier::Specifier; -pub use download::download_file; - -// Want to show: -// - whether api_token found -// - configured api_host we are connecting to -// - whether we can connect to remote host (eg, get most recent changelog) -// - whether our auth is valid -// - current active editgroup -#[derive(Debug, PartialEq, Clone, serde::Serialize)] -pub struct ClientStatus { - pub has_api_token: bool, - pub api_host: String, - pub last_changelog: Option, - pub account: Option, -} - -impl ClientStatus { - pub fn pretty_print(self) -> Result<()> { - let mut color_stdout = StandardStream::stdout(if atty::is(atty::Stream::Stdout) { - ColorChoice::Auto - } else { - ColorChoice::Never - }); - let color_normal = ColorSpec::new(); - let mut color_bold = ColorSpec::new(); - color_bold.set_bold(true); - let mut color_happy = ColorSpec::new(); - color_happy.set_fg(Some(Color::Green)).set_bold(true); - let mut color_sad = ColorSpec::new(); - color_sad.set_fg(Some(Color::Red)).set_bold(true); - - color_stdout.set_color(&color_normal)?; - write!(&mut color_stdout, "{:>16}: ", "API host")?; - color_stdout.set_color(&color_bold)?; - write!(&mut color_stdout, "{}", self.api_host)?; - match self.last_changelog { - Some(index) => { - color_stdout.set_color(&color_happy)?; - writeln!(&mut color_stdout, " [successfully connected]")?; - color_stdout.set_color(&color_normal)?; - write!(&mut color_stdout, "{:>16}: ", "Last changelog")?; - color_stdout.set_color(&color_bold)?; - writeln!(&mut color_stdout, "{}", index)?; - } - None => { - color_stdout.set_color(&color_sad)?; - writeln!(&mut color_stdout, " [Failed to connect]")?; - } - }; - color_stdout.set_color(&color_normal)?; - write!(&mut color_stdout, "{:>16}: ", "API auth token")?; - if self.has_api_token { - color_stdout.set_color(&color_happy)?; - writeln!(&mut color_stdout, "[configured]")?; - } else { - color_stdout.set_color(&color_sad)?; - writeln!(&mut color_stdout, "[not configured]")?; - }; - if let Some(editor) = self.account { - color_stdout.set_color(&color_normal)?; - write!(&mut color_stdout, "{:>16}: ", "Account")?; - color_stdout.set_color(&color_bold)?; - write!(&mut color_stdout, "{}", editor.username)?; - if editor.is_bot == Some(true) { - color_stdout - .set_color(ColorSpec::new().set_fg(Some(Color::Blue)).set_bold(true))?; - write!(&mut color_stdout, " [bot]")?; - } - if editor.is_admin == Some(true) { - color_stdout - .set_color(ColorSpec::new().set_fg(Some(Color::Magenta)).set_bold(true))?; - write!(&mut color_stdout, " [admin]")?; - } - match editor.is_active { - Some(true) => { - color_stdout.set_color(&color_happy)?; - writeln!(&mut color_stdout, " [active]")?; - } - Some(false) | None => { - color_stdout.set_color(&color_sad)?; - writeln!(&mut color_stdout, " [disabled]")?; - } - }; - color_stdout.set_color(&color_normal)?; - writeln!( - &mut color_stdout, - "{:>16} editor_{}", - "", - editor.editor_id.unwrap() - )?; - }; - color_stdout.set_color(&color_normal)?; - Ok(()) - } -} #[derive(Debug, PartialEq, Clone, Copy)] pub enum EntityType { @@ -135,13 +35,13 @@ impl FromStr for EntityType { fn from_str(s: &str) -> Result { match s { - "release" => Ok(EntityType::Release), - "work" => Ok(EntityType::Work), - "container" => Ok(EntityType::Container), - "creator" => Ok(EntityType::Creator), - "file" => Ok(EntityType::File), - "FILESET" => Ok(EntityType::FileSet), - "webcapture" => Ok(EntityType::WebCapture), + "release" | "releases" => Ok(EntityType::Release), + "work" | "works" => Ok(EntityType::Work), + "container" | "containers" => Ok(EntityType::Container), + "creator" | "creators" => Ok(EntityType::Creator), + "file" | "files" => Ok(EntityType::File), + "fileset" | "filesets" => Ok(EntityType::FileSet), + "webcapture" | "webcaptures" => Ok(EntityType::WebCapture), _ => Err(anyhow!("invalid entity type : {}", s)), } } @@ -178,65 +78,3 @@ pub fn parse_macaroon_editor_id(s: &str) -> Result { verifier.satisfy_exact(&format!("editor_id = {}", editor_id.to_string())); Ok(editor_id) } - -pub fn print_editgroups(eg_list: Vec, json: bool) -> Result<()> { - if json { - for eg in eg_list { - writeln!(&mut std::io::stdout(), "{}", eg.to_json_string()?)?; - } - } else { - let mut tw = TabWriter::new(std::io::stdout()); - writeln!( - tw, - "editgroup_id\tchangelog_index\tcreated\tsubmitted\tdescription" - )?; - for eg in eg_list { - writeln!( - tw, - "{}\t{}\t{}\t{}\t{}", - eg.editgroup_id.unwrap(), - eg.changelog_index - .map_or("-".to_string(), |v| v.to_string()), - eg.created - .map_or("-".to_string(), |v| HumanTime::from(v).to_string()), - eg.submitted - .map_or("-".to_string(), |v| HumanTime::from(v).to_string()), - eg.description.unwrap_or_else(|| "-".to_string()) - )?; - } - tw.flush()?; - } - Ok(()) -} - -pub fn read_entity_file(input_path: Option) -> Result { - // treat "-" as "use stdin" - let input_path = match input_path { - Some(s) if s.to_string_lossy() == "-" => None, - _ => input_path, - }; - match input_path { - None => { - let mut line = String::new(); - std::io::stdin().read_line(&mut line)?; - Ok(line) - } - Some(path) if path.extension().map(|v| v.to_str()) == Some(Some("toml")) => { - info!("reading {:?} as TOML", path); - // as a hack, read TOML but then serialize it back to JSON - let mut contents = String::new(); - let mut input_file = - std::fs::File::open(path).context("reading entity from TOML file")?; - input_file.read_to_string(&mut contents)?; - let value: toml::Value = contents.parse().context("parsing TOML file")?; - Ok(serde_json::to_string(&value)?) - } - Some(path) => { - let mut line = String::new(); - let input_file = std::fs::File::open(path)?; - let mut buffered = std::io::BufReader::new(input_file); - buffered.read_line(&mut line)?; - Ok(line) - } - } -} diff --git a/rust/fatcat-cli/src/main.rs b/rust/fatcat-cli/src/main.rs index 75ddc6a..b677aca 100644 --- a/rust/fatcat-cli/src/main.rs +++ b/rust/fatcat-cli/src/main.rs @@ -13,13 +13,16 @@ use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor}; #[structopt(rename_all = "kebab-case", about = "CLI interface to Fatcat API")] struct Opt { #[structopt( + global = true, long = "--api-host", env = "FATCAT_API_HOST", default_value = "https://api.fatcat.wiki" )] api_host: String, + /// API auth tokens can be generated from the account page in the fatcat.wiki web interface #[structopt( + global = true, long = "--api-token", env = "FATCAT_API_AUTH_TOKEN", hide_env_values = true @@ -27,17 +30,18 @@ struct Opt { api_token: Option, #[structopt( + global = true, long = "--search-host", env = "FATCAT_SEARCH_HOST", default_value = "https://search.fatcat.wiki" )] search_host: String, - /// Pass many times for more log output + /// Log more messages. Pass multiple times for ever more verbosity /// /// By default, it'll only report errors. Passing `-v` one time also prints /// warnings, `-vv` enables info logging, `-vvv` debug, and `-vvvv` trace. - #[structopt(long, short = "v", parse(from_occurrences))] + #[structopt(global = true, long, short = "v", parse(from_occurrences))] verbose: i8, #[structopt(subcommand)] @@ -46,10 +50,12 @@ struct Opt { #[derive(StructOpt)] enum EditgroupCommand { + /// Create a new editgroup Create { #[structopt(long, short)] description: String, }, + /// Print editgroups for current user List { #[structopt(long = "--editor-id", short)] editor_id: Option, @@ -60,6 +66,7 @@ enum EditgroupCommand { #[structopt(long)] json: bool, }, + /// Print recent editgroups from any user which need review Reviewable { #[structopt(long, short = "-n", default_value = "20")] limit: i64, @@ -67,14 +74,17 @@ enum EditgroupCommand { #[structopt(long)] json: bool, }, + /// Accept (merge) a single editgroup Accept { #[structopt(env = "FATCAT_EDITGROUP", hide_env_values = true)] editgroup_id: String, }, + /// Submit a single editgroup for review Submit { #[structopt(env = "FATCAT_EDITGROUP", hide_env_values = true)] editgroup_id: String, }, + /// Un-submit a single editgroup (for more editing) Unsubmit { #[structopt(env = "FATCAT_EDITGROUP", hide_env_values = true)] editgroup_id: String, @@ -82,11 +92,73 @@ enum EditgroupCommand { } #[derive(StructOpt)] -enum Command { - Status { +enum BatchCommand { + Create { + entity_type: EntityType, + + #[structopt(long, default_value = "50")] + batch_size: u64, + #[structopt(long)] - json: bool, + dry_run: bool, + + #[structopt(long)] + auto_accept: bool, + + #[structopt( + long = "--editgroup-id", + short, + env = "FATCAT_EDITGROUP", + hide_env_values = true + )] + editgroup_id: String, + }, + Update { + entity_type: EntityType, + mutations: Vec, + + #[structopt(long, default_value = "50")] + batch_size: u64, + + #[structopt(long)] + dry_run: bool, + + #[structopt(long)] + auto_accept: bool, + + #[structopt( + long = "--editgroup-id", + short, + env = "FATCAT_EDITGROUP", + hide_env_values = true + )] + editgroup_id: String, + }, + Delete { + entity_type: EntityType, + + #[structopt(long, default_value = "50")] + batch_size: u64, + + #[structopt(long)] + dry_run: bool, + + #[structopt(long)] + auto_accept: bool, + + #[structopt( + long = "--editgroup-id", + short, + env = "FATCAT_EDITGROUP", + hide_env_values = true + )] + editgroup_id: String, }, + Download {}, +} + +#[derive(StructOpt)] +enum Command { Get { specifier: Specifier, @@ -96,6 +168,9 @@ enum Command { #[structopt(long = "--hide")] hide: Option, + #[structopt(long)] + json: bool, + #[structopt(long)] toml: bool, }, @@ -131,7 +206,7 @@ enum Command { mutations: Vec, }, - Edit { + Delete { specifier: Specifier, #[structopt( @@ -141,14 +216,8 @@ enum Command { hide_env_values = true )] editgroup_id: String, - - #[structopt(long)] - json: bool, - - #[structopt(long = "--editing-command", env = "EDITOR")] - editing_command: String, }, - Delete { + Edit { specifier: Specifier, #[structopt( @@ -158,16 +227,28 @@ enum Command { hide_env_values = true )] editgroup_id: String, - }, - Editgroup { - #[structopt(subcommand)] - cmd: EditgroupCommand, + + #[structopt(long)] + json: bool, + + #[structopt(long)] + toml: bool, + + #[structopt(long = "--editing-command", env = "EDITOR")] + editing_command: String, }, Download { specifier: Specifier, }, - //Changelog - //History + History { + specifier: Specifier, + + #[structopt(long, short = "-n", default_value = "20")] + limit: u64, + + #[structopt(long)] + json: bool, + }, Search { entity_type: EntityType, @@ -185,6 +266,36 @@ enum Command { #[structopt(long = "--search-schema")] search_schema: bool, }, + Editgroup { + #[structopt(subcommand)] + cmd: EditgroupCommand, + }, + Changelog { + #[structopt(long, short = "-n", default_value = "20")] + limit: i64, + + /* TODO: follow (streaming) mode for changelog + #[structopt(long, short = "-f")] + follow: bool, + */ + #[structopt(long)] + json: bool, + }, + Batch { + #[structopt(subcommand)] + cmd: BatchCommand, + + /// Input file, "-" for stdin. + #[structopt(long = "--file", short = "-f", parse(from_os_str))] + input_path: Option, + + #[structopt(long)] + limit: Option, + }, + Status { + #[structopt(long)] + json: bool, + }, } fn main() -> Result<()> { @@ -230,15 +341,15 @@ fn main() -> Result<()> { } fn run(opt: Opt) -> Result<()> { - let mut api_client = FatcatApiClient::new(opt.api_host.clone(), opt.api_token.clone())?; match opt.cmd { Command::Get { - toml, specifier, expand, hide, + json: _, + toml, } => { let result = specifier.get_from_api(&mut api_client, expand, hide)?; if toml { @@ -284,6 +395,7 @@ fn run(opt: Opt) -> Result<()> { specifier, editgroup_id, json, + toml: _, editing_command, } => { // TODO: fetch editgroup, check if this entity is already being updated in it. If so, @@ -326,11 +438,83 @@ fn run(opt: Opt) -> Result<()> { .context("updating after edit")?; println!("{}", serde_json::to_string(&ee)?); } + Command::Changelog { + limit, + json, + } => { + let resp = api_client + .rt + .block_on(api_client.api.get_changelog(Some(limit))) + .context("fetch recent changelogs")?; + match resp { + fatcat_openapi::GetChangelogResponse::Success(change_list) => { + print_changelog_entries(change_list, json)?; + } + other => { + return Err(anyhow!("{:?}", other)).with_context(|| { + format!("failed to fetch changelogs") + }) + } + } + } + Command::Batch { + cmd: + BatchCommand::Create { + entity_type, + batch_size, + dry_run, + auto_accept, + editgroup_id, + }, + input_path, + limit, + } => { + unimplemented!("batch create") + }, + Command::Batch { + cmd: + BatchCommand::Update { + entity_type, + mutations, + batch_size, + dry_run, + auto_accept, + editgroup_id, + }, + input_path, + limit, + } => { + unimplemented!("batch update") + }, + Command::Batch { + cmd: + BatchCommand::Delete { + entity_type, + batch_size, + dry_run, + auto_accept, + editgroup_id, + }, + input_path, + limit, + } => { + unimplemented!("batch delete") + }, + Command::Batch { + cmd: + BatchCommand::Download { + // TODO + }, + input_path, + limit, + } => { + unimplemented!("batch create") + }, Command::Download{specifier} => { // run lookups if necessary (inefficient) let specifier = match specifier { - Specifier::ReleaseLookup(_, _) | Specifier::FileLookup(_, _) => - specifier.into_entity_specifier(&mut api_client)?, + Specifier::ReleaseLookup(_, _) | Specifier::FileLookup(_, _) => specifier.into_entity_specifier(&mut api_client)?, + // XXX: _ => specifier, }; let file_entities = match specifier { @@ -411,6 +595,15 @@ fn run(opt: Opt) -> Result<()> { .with_context(|| format!("delete entity: {:?}", specifier))?; println!("{}", serde_json::to_string(&result)?); } + Command::History { + specifier, + limit, + json, + } => { + let specifier = specifier.into_entity_specifier(&mut api_client)?; + let history_entries = specifier.get_history(&mut api_client, Some(limit))?; + print_entity_histories(history_entries, json)?; + } Command::Editgroup { cmd: EditgroupCommand::List { @@ -521,7 +714,7 @@ fn run(opt: Opt) -> Result<()> { println!("{}", eg.to_json_string()?); } Command::Status { json } => { - let status = api_client.status()?; + let status = ClientStatus::generate(&mut api_client)?; if json { println!("{}", serde_json::to_string(&status)?) } else { diff --git a/rust/fatcat-cli/src/specifier.rs b/rust/fatcat-cli/src/specifier.rs index c1d5b9f..c7a7b57 100644 --- a/rust/fatcat-cli/src/specifier.rs +++ b/rust/fatcat-cli/src/specifier.rs @@ -116,7 +116,8 @@ impl Specifier { ); // doi, wikidata, isbn13, pmid, pmcid, core, arxiv, jstor, ark, mag let result = api_client.rt.block_on(api_client.api.lookup_release( - doi, None, None, pmid, pmcid, None, arxiv, None, None, None, None, None, None, expand, hide, + doi, None, None, pmid, pmcid, None, arxiv, None, None, None, None, None, None, + expand, hide, ))?; match result { fatcat_openapi::LookupReleaseResponse::FoundEntity(model) => { @@ -355,6 +356,113 @@ impl Specifier { Err(_) => ret.with_context(|| format!("Failed to GET {:?}", self)), } } + + pub fn get_history( + &self, + api_client: &mut FatcatApiClient, + limit: Option, + ) -> Result> { + let limit: Option = limit.map(|v| v as i64); + use Specifier::*; + let ret: Result> = match self { + Release(fcid) => match api_client + .rt + .block_on(api_client.api.get_release_history(fcid.to_string(), limit))? + { + fatcat_openapi::GetReleaseHistoryResponse::FoundEntityHistory(entries) => { + Ok(entries) + } + fatcat_openapi::GetReleaseHistoryResponse::NotFound(err) => { + Err(anyhow!("Not Found: {}", err.message)) + } + resp => Err(anyhow!("{:?}", resp)) + .with_context(|| format!("API GET failed: {:?}", self)), + }, + Work(fcid) => match api_client + .rt + .block_on(api_client.api.get_work_history(fcid.to_string(), limit))? + { + fatcat_openapi::GetWorkHistoryResponse::FoundEntityHistory(entries) => { + Ok(entries) + } + fatcat_openapi::GetWorkHistoryResponse::NotFound(err) => { + Err(anyhow!("Not Found: {}", err.message)) + } + resp => Err(anyhow!("{:?}", resp)) + .with_context(|| format!("API GET failed: {:?}", self)), + }, + Container(fcid) => match api_client + .rt + .block_on(api_client.api.get_container_history(fcid.to_string(), limit))? + { + fatcat_openapi::GetContainerHistoryResponse::FoundEntityHistory(entries) => { + Ok(entries) + } + fatcat_openapi::GetContainerHistoryResponse::NotFound(err) => { + Err(anyhow!("Not Found: {}", err.message)) + } + resp => Err(anyhow!("{:?}", resp)) + .with_context(|| format!("API GET failed: {:?}", self)), + }, + Creator(fcid) => match api_client + .rt + .block_on(api_client.api.get_creator_history(fcid.to_string(), limit))? + { + fatcat_openapi::GetCreatorHistoryResponse::FoundEntityHistory(entries) => { + Ok(entries) + } + fatcat_openapi::GetCreatorHistoryResponse::NotFound(err) => { + Err(anyhow!("Not Found: {}", err.message)) + } + resp => Err(anyhow!("{:?}", resp)) + .with_context(|| format!("API GET failed: {:?}", self)), + }, + File(fcid) => match api_client + .rt + .block_on(api_client.api.get_file_history(fcid.to_string(), limit))? + { + fatcat_openapi::GetFileHistoryResponse::FoundEntityHistory(entries) => { + Ok(entries) + } + fatcat_openapi::GetFileHistoryResponse::NotFound(err) => { + Err(anyhow!("Not Found: {}", err.message)) + } + resp => Err(anyhow!("{:?}", resp)) + .with_context(|| format!("API GET failed: {:?}", self)), + }, + FileSet(fcid) => match api_client + .rt + .block_on(api_client.api.get_fileset_history(fcid.to_string(), limit))? + { + fatcat_openapi::GetFilesetHistoryResponse::FoundEntityHistory(entries) => { + Ok(entries) + } + fatcat_openapi::GetFilesetHistoryResponse::NotFound(err) => { + Err(anyhow!("Not Found: {}", err.message)) + } + resp => Err(anyhow!("{:?}", resp)) + .with_context(|| format!("API GET failed: {:?}", self)), + }, + WebCapture(fcid) => match api_client + .rt + .block_on(api_client.api.get_webcapture_history(fcid.to_string(), limit))? + { + fatcat_openapi::GetWebcaptureHistoryResponse::FoundEntityHistory(entries) => { + Ok(entries) + } + fatcat_openapi::GetWebcaptureHistoryResponse::NotFound(err) => { + Err(anyhow!("Not Found: {}", err.message)) + } + resp => Err(anyhow!("{:?}", resp)) + .with_context(|| format!("API GET failed: {:?}", self)), + }, + _ => Err(anyhow!("Don't know how to look up history for: {:?}", self)), + }; + match ret { + Ok(_) => ret, + Err(_) => ret.with_context(|| format!("Failed to GET history: {:?}", self)), + } + } } impl FromStr for Specifier { -- cgit v1.2.3