From 894b5b5ec7bf7cb027ba31bf83c40f27e0ab51bd Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Thu, 30 Apr 2015 15:15:44 +0200 Subject: [PATCH] feat(CLI): adjust to serde usage in `yup-oauth` * More detailed error type for JsonTokenStorage * removed all traces of rustc_serialize * use pretty-printers everywhere to allow writing human-readable json files for secretes and for tokens Fixes #93 --- etc/api/type-cli.yaml | 1 - src/mako/api/lib/schema.mako | 2 -- src/mako/cli/lib/engine.mako | 2 +- src/mako/cli/main.rs.mako | 1 - src/rust/cli/cmn.rs | 68 +++++++++++++++++++----------------- 5 files changed, 36 insertions(+), 38 deletions(-) diff --git a/etc/api/type-cli.yaml b/etc/api/type-cli.yaml index 06abe608b0..9383d8052d 100644 --- a/etc/api/type-cli.yaml +++ b/etc/api/type-cli.yaml @@ -27,7 +27,6 @@ cargo: is_executable: YES dependencies: - clap = "*" - - rustc-serialize = "*" - yup-hyper-mock = "*" - serde = ">= 0.3.0" - serde_macros = "*" diff --git a/src/mako/api/lib/schema.mako b/src/mako/api/lib/schema.mako index 2920f441f1..521740999e 100644 --- a/src/mako/api/lib/schema.mako +++ b/src/mako/api/lib/schema.mako @@ -3,8 +3,6 @@ IO_TYPES, activity_split, enclose_in, REQUEST_MARKER_TRAIT, mb_type, indent_all_but_first_by, NESTED_TYPE_SUFFIX, RESPONSE_MARKER_TRAIT, split_camelcase_s, METHODS_RESOURCE, unique_type_name, PART_MARKER_TRAIT, canonical_type_name, TO_PARTS_MARKER, UNUSED_TYPE_MARKER, is_schema_with_optionals) - - default_traits = ('RustcEncodable', 'Clone', 'Default') %>\ ## Build a schema which must be an object ################################################################################################################### diff --git a/src/mako/cli/lib/engine.mako b/src/mako/cli/lib/engine.mako index 9de33d29ad..10deae767f 100644 --- a/src/mako/cli/lib/engine.mako +++ b/src/mako/cli/lib/engine.mako @@ -33,7 +33,7 @@ use std::default::Default; use std::str::FromStr; use oauth2::{Authenticator, DefaultAuthenticatorDelegate}; -use rustc_serialize::json; +use serde::json; use clap::ArgMatches; struct Engine<'n, 'a> { diff --git a/src/mako/cli/main.rs.mako b/src/mako/cli/main.rs.mako index 71f672c9b9..30a6689f12 100644 --- a/src/mako/cli/main.rs.mako +++ b/src/mako/cli/main.rs.mako @@ -18,7 +18,6 @@ extern crate clap; extern crate yup_oauth2 as oauth2; extern crate yup_hyper_mock as mock; -extern crate rustc_serialize; extern crate serde; extern crate hyper; extern crate mime; diff --git a/src/rust/cli/cmn.rs b/src/rust/cli/cmn.rs index 5ba16d6846..c5ead901c3 100644 --- a/src/rust/cli/cmn.rs +++ b/src/rust/cli/cmn.rs @@ -1,5 +1,5 @@ use oauth2::{ApplicationSecret, ConsoleApplicationSecret, TokenStorage, Token}; -use rustc_serialize::json; +use serde::json; use mime::Mime; use clap::{App, SubCommand}; @@ -208,49 +208,47 @@ impl JsonTokenStorage { } impl TokenStorage for JsonTokenStorage { - type Error = io::Error; + type Error = json::Error; // NOTE: logging might be interesting, currently we swallow all errors - fn set(&mut self, scope_hash: u64, _: &Vec<&str>, token: Option) -> Option { + fn set(&mut self, scope_hash: u64, _: &Vec<&str>, token: Option) -> Option { match token { None => { match fs::remove_file(self.path(scope_hash)) { Err(err) => match err.kind() { io::ErrorKind::NotFound => None, - _ => Some(err) + _ => Some(json::Error::IoError(err)) }, Ok(_) => None } } Some(token) => { - let json_token = json::encode(&token).unwrap(); match fs::OpenOptions::new().create(true).write(true).open(&self.path(scope_hash)) { Ok(mut f) => { - match f.write(json_token.as_bytes()) { + match json::to_writer_pretty(&mut f, &token) { Ok(_) => None, - Err(io_err) => Some(io_err), + Err(io_err) => Some(json::Error::IoError(io_err)), } }, - Err(io_err) => Some(io_err) + Err(io_err) => Some(json::Error::IoError(io_err)) } } } } - fn get(&self, scope_hash: u64, _: &Vec<&str>) -> Result, io::Error> { + fn get(&self, scope_hash: u64, _: &Vec<&str>) -> Result, json::Error> { match fs::File::open(&self.path(scope_hash)) { Ok(mut f) => { - let mut json_string = String::new(); - match f.read_to_string(&mut json_string) { - Ok(_) => Ok(Some(json::decode::(&json_string).unwrap())), - Err(io_err) => Err(io_err), + match json::de::from_reader(f) { + Ok(token) => Ok(Some(token)), + Err(err) => Err(err), } }, Err(io_err) => { match io_err.kind() { io::ErrorKind::NotFound => Ok(None), - _ => Err(io_err) + _ => Err(json::Error::IoError(io_err)) } } } @@ -260,7 +258,7 @@ impl TokenStorage for JsonTokenStorage { #[derive(Debug)] pub enum ApplicationSecretError { - DecoderError((String, json::DecoderError)), + DecoderError((String, json::Error)), FormatError(String), } @@ -440,7 +438,7 @@ pub fn assure_config_dir_exists(dir: &str) -> Result { pub fn application_secret_from_directory(dir: &str, secret_basename: &str, - json_app_secret: &str) + json_console_secret: &str) -> Result { let secret_path = Path::new(dir).join(secret_basename); let secret_str = || secret_path.as_path().to_str().unwrap().to_string(); @@ -459,7 +457,10 @@ pub fn application_secret_from_directory(dir: &str, err = match fs::OpenOptions::new().create(true).write(true).open(&secret_path) { Err(cfe) => cfe, Ok(mut f) => { - match f.write(json_app_secret.as_bytes()) { + // Assure we convert 'ugly' json string into pretty one + let console_secret: ConsoleApplicationSecret + = json::from_str(json_console_secret).unwrap(); + match json::to_writer_pretty(&mut f, &console_secret) { Err(io_err) => io_err, Ok(_) => continue, } @@ -470,23 +471,24 @@ pub fn application_secret_from_directory(dir: &str, return secret_io_error(err) }, Ok(mut f) => { - let mut json_encoded_secret = String::new(); - if let Err(io_err) = f.read_to_string(&mut json_encoded_secret) { - return secret_io_error(io_err) - } - match json::decode::(&json_encoded_secret) { - Err(json_decode_error) => return Err(CLIError::Configuration( - ConfigurationError::Secret(ApplicationSecretError::DecoderError( - (secret_str(), json_decode_error) + match json::de::from_reader::<_, ConsoleApplicationSecret>(f) { + Err(json::Error::IoError(err)) => + return secret_io_error(err), + Err(json_err) => + return Err(CLIError::Configuration( + ConfigurationError::Secret( + ApplicationSecretError::DecoderError( + (secret_str(), json_err) )))), - Ok(console_secret) => match console_secret.installed { - Some(secret) => return Ok(secret), - None => return Err( - CLIError::Configuration( - ConfigurationError::Secret( - ApplicationSecretError::FormatError(secret_str()) - ))) - }, + Ok(console_secret) => + match console_secret.installed { + Some(secret) => return Ok(secret), + None => return Err( + CLIError::Configuration( + ConfigurationError::Secret( + ApplicationSecretError::FormatError(secret_str()) + ))) + }, } } }