feat: config.rs

src/main.rs

@@ -3,17 +3,22 @@ extern crate lazy_static;
 #[macro_use]
 extern crate rust_util;
 
+mod config;
+
 use rust_util::XResult;
 use acme_lib::{DirectoryUrl, Directory};
 use acme_lib::{create_p384_key, create_p256_key, create_rsa_key};
 use acme_lib::persist::FilePersist;
 use clap::{App, Arg};
+use std::fs;
 use std::sync::RwLock;
 use std::collections::BTreeMap;
 use tide::Request;
 use std::process::exit;
 use std::time::Duration;
 use async_std::channel::Sender;
+use config::AcmeAlgo;
+use config::AcmeMode;
 
 const NAME: &str = env!("CARGO_PKG_NAME");
 const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -24,26 +29,13 @@ lazy_static! {
     static ref TOKEN_MAP: RwLock<BTreeMap<String, String>> = RwLock::new(BTreeMap::new());
 }
 
-#[derive(Debug, Clone, Copy)]
-enum Algo {
-    Ec256,
-    Ec384,
-    Rsa(u32),
-}
-
-#[derive(Debug, Clone, Copy)]
-enum Mode {
-    Prod,
-    Test,
-}
-
 #[derive(Debug)]
 struct AcmeRequest<'a> {
     contract_email: &'a str,
     primary_name: &'a str,
     alt_names: &'a [&'a str],
-    algo: Algo,
-    mode: Mode,
+    algo: AcmeAlgo,
+    mode: AcmeMode,
     dir: &'a str,
     timeout: u64,
 }
@@ -103,21 +95,22 @@ async fn main() -> tide::Result<()> {
         }
     };
     let algo = match matches.value_of("algo") {
-        Some("ec256") => Algo::Ec256,
-        Some("ec384") => Algo::Ec384,
-        Some("rsa2048") => Algo::Rsa(2048),
-        Some("rsa3072") => Algo::Rsa(3072),
-        Some("rsa4096") => Algo::Rsa(4096),
+        Some(a) => AcmeAlgo::parse(a).unwrap_or_else(|e| {
+            failure!("{}", e);
+            exit(1);
+        }),
         _ => {
-            failure!("Algo is not assigned, or wrong, should be: ec256, ec384, rsa2048, rsa3073 or rsa4096.");
+            failure!("Algo is not assigned, should be: ec256, ec384, rsa2048, rsa3073 or rsa4096.");
             exit(1);
         }
     };
     let mode = match matches.value_of("mode") {
-        Some("prod") => Mode::Prod,
-        Some("test") => Mode::Test,
+        Some(m) => AcmeMode::parse(m).unwrap_or_else(|e| {
+            failure!("{}", e);
+            exit(1);
+        }),
         _ => {
-            failure!("Mode is not assigned, or wrong, should be: prod or test");
+            failure!("AcmeMode is not assigned, should be: prod or test");
             exit(1);
         }
     };
@@ -155,12 +148,9 @@ async fn main() -> tide::Result<()> {
 
 fn request_domains(acme_request: AcmeRequest) -> XResult<()> {
     information!("Acme mode: {:?}", acme_request.mode);
-    let url = match acme_request.mode {
-        Mode::Prod => DirectoryUrl::LetsEncrypt,
-        Mode::Test => DirectoryUrl::LetsEncryptStaging,
-    };
+    let url = acme_request.mode.directory_url();
     information!("Acme dir: {}", acme_request.dir);
-    std::fs::create_dir(acme_request.dir).ok();
+    fs::create_dir_all(acme_request.dir).ok();
     let persist = FilePersist::new(acme_request.dir);
     let dir = opt_result!(Directory::from_url(persist, url), "Create directory from url failed: {}");
     let acc = opt_result!(dir.account(acme_request.contract_email), "Directory set account failed: {}");
@@ -194,16 +184,16 @@ fn request_domains(acme_request: AcmeRequest) -> XResult<()> {
 
     information!("Generate private key, type: {:?}", acme_request.algo);
     let pkey_pri = match acme_request.algo {
-        Algo::Ec256 => create_p256_key(),
-        Algo::Ec384 => create_p384_key(),
-        Algo::Rsa(bits) => create_rsa_key(bits),
+        AcmeAlgo::Ec256 => create_p256_key(),
+        AcmeAlgo::Ec384 => create_p384_key(),
+        AcmeAlgo::Rsa(bits) => create_rsa_key(bits),
     };
-    information!("Created private key: {:?}", pkey_pri);
 
     let ord_cert = opt_result!( ord_csr.finalize_pkey(pkey_pri, acme_request.timeout), "Submit CSR failed: {}");
     let cert = opt_result!( ord_cert.download_and_save_cert(), "Download and save certificate failed: {}");
 
-    information!("Created certificate: {:?}", cert);
+    information!("Certificate key: {}",  cert.private_key());
+    information!("Certificate pem: {}",  cert.certificate());
 
     Ok(())
 }