[cli] Improve the error display from server and command errors, eliminate panics (#476)

* Remove didkey and didcomm

* Propagate errors back to runtime

* Complete error propagation

Author: tmarkovski

cli/src/main.rs

@@ -14,7 +14,6 @@ use parser::template;
 use prost::{DecodeError, Message};
 use serde_json::Value;
 use services::config::DefaultConfig;
-use std::fmt::Display;
 
 pub static mut DEBUG: bool = false;
 
@@ -55,18 +54,44 @@ fn main() {
     let config = DefaultConfig::from(&matches);
     let service = parser::parse(&matches);
 
-    match services::execute(&service, config) {
-        Ok(_) => {}
-        Err(err) => match err {
-            services::config::Error::IOError => println!("{}", format!("io error").red()),
-            services::config::Error::SerializationError => {
-                println!("{}", format!("serialization error").red())
-            }
-            services::config::Error::UnknownCommand => unimplemented!("should not be hit"),
-            Error::APIError(grpc_status) => {
-                println!("api error: {}", format!("{}", grpc_status).red())
-            }
+    match service {
+        Ok(service) => match services::execute(&service, config) {
+            Ok(_) => {}
+            Err(err) => match err {
+                Error::IOError => println!("{}", format!("io error").red()),
+                Error::SerializationError => {
+                    println!("{}", format!("serialization error").red())
+                }
+                Error::UnknownCommand => unimplemented!("should not be hit"),
+                Error::APIError { code, message } => {
+                    println!(
+                        "{}: {}: {}",
+                        format!("error").red().bold(),
+                        format!("{}", code.to_lowercase()).bold(),
+                        format!("{}", message.to_lowercase())
+                    );
+                }
+                Error::MissingArguments => todo!(),
+            },
         },
+        Err(err) => {
+            println!(
+                "{}: {}: {}",
+                format!("error").red().bold(),
+                format!("command error").bold(),
+                format!("{}", err)
+            );
+            println!();
+            println!(
+                "{}",
+                format!(
+                    "For more information try {} or {}",
+                    format!("-h").green(),
+                    format!("--help").green()
+                )
+                .italic()
+            )
+        }
     }
 }
 

cli/src/parser/account.rs

@@ -1,36 +1,38 @@
 use clap::ArgMatches;
 
-pub fn parse<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
+use crate::services::config::Error;
+
+pub(crate) fn parse<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
     if args.is_present("login") {
-        return sign_in(
+        sign_in(
             &args
                 .subcommand_matches("login")
                 .expect("Error parsing request"),
-        );
+        )
     } else if args.is_present("info") {
-        return info(
+        info(
             &args
                 .subcommand_matches("info")
                 .expect("Error parsing request"),
-        );
+        )
     } else {
-        panic!("Unrecognized command")
+        Err(Error::MissingArguments)
     }
 }
 
-fn sign_in<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::SignIn(SignInArgs {
+fn sign_in<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::SignIn(SignInArgs {
         name: args.value_of("name"),
         email: args.value_of("email"),
         sms: args.value_of("sms"),
         invitation_code: args.value_of("invitation-code"),
         alias: args.value_of("alias"),
         set_default: args.is_present("default"),
-    })
+    }))
 }
 
-fn info<'a>(_args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::Info(InfoArgs {})
+fn info<'a>(_args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::Info(InfoArgs {}))
 }
 
 #[derive(Debug, PartialEq)]

cli/src/parser/didcomm.rs

@@ -1,7 +1,7 @@
+use crate::services::config::Error;
 use clap::ArgMatches;
-use colored::Colorize;
 
-pub(crate) fn parse<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
+pub(crate) fn parse<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
     if args.is_present("issue") {
         issue(
             &args
@@ -27,72 +27,68 @@ pub(crate) fn parse<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
                 .expect("Error parsing request"),
         )
     } else if args.is_present("create-proof") {
-        return create_proof(
+        create_proof(
             &args
                 .subcommand_matches("create-proof")
                 .expect("Error parsing request"),
-        );
+        )
     } else if args.is_present("verify-proof") {
-        return verify_proof(
+        verify_proof(
             &args
                 .subcommand_matches("verify-proof")
                 .expect("Error parsing request"),
-        );
+        )
     } else {
-        println!(
-            "{}",
-            format!("invalid subcommand. see 'trinsic vc -h' for details").red()
-        );
-        panic!();
+        Err(Error::MissingArguments)
     }
 }
 
-fn issue<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::Issue(IssueArgs {
+fn issue<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::Issue(IssueArgs {
         document: args.value_of("document"),
         out: args.value_of("out"),
-    })
+    }))
 }
 
-fn issue_from_template<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::IssueFromTemplate(IssueFromTemplateArgs {
+fn issue_from_template<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::IssueFromTemplate(IssueFromTemplateArgs {
         template_id: args
             .value_of("template-id")
             .map_or(String::default(), |x| x.to_string()),
         values_json: args.value_of("values-data").map(|x| x.to_string()),
         values_file: args.value_of("values-file").map(|x| x.to_string()),
-    })
+    }))
 }
 
-fn get_status<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::GetStatus(GetStatusArgs {
+fn get_status<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::GetStatus(GetStatusArgs {
         credential_status_id: args
             .value_of("credential-status-id")
             .map_or(String::default(), |x| x.to_string()),
-    })
+    }))
 }
 
-fn update_status<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::UpdateStatus(UpdateStatusArgs {
+fn update_status<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::UpdateStatus(UpdateStatusArgs {
         credential_status_id: args
             .value_of("credential-status-id")
             .map_or(String::default(), |x| x.to_string()),
         revoked: args.is_present("revoked"),
-    })
+    }))
 }
 
-fn create_proof<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::CreateProof(CreateProofArgs {
+fn create_proof<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::CreateProof(CreateProofArgs {
         reveal_document: args.value_of("reveal-document"),
         document_id: args.value_of("document-id"),
         out: args.value_of("out"),
-    })
+    }))
 }
 
-fn verify_proof<'a>(args: &'a ArgMatches<'_>) -> Command<'a> {
-    Command::VerifyProof(VerifyProofArgs {
+fn verify_proof<'a>(args: &'a ArgMatches<'_>) -> Result<Command<'a>, Error> {
+    Ok(Command::VerifyProof(VerifyProofArgs {
         proof_document: args.value_of("proof-document"),
-    })
+    }))
 }
 
 #[derive(Debug, PartialEq)]