refactor with derive_builder

src/backend/mod.rs

@@ -5,9 +5,11 @@ use crate::{
   log::*,
   utils::{BytesName, PathNameBytesExp, ServerNameBytesExp},
 };
+use derive_builder::Builder;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 use rustls::{OwnedTrustAnchor, RootCertStore};
 use std::{
+  borrow::Cow,
   fs::File,
   io::{self, BufReader, Cursor, Read},
   path::PathBuf,
@@ -18,22 +20,51 @@ use tokio_rustls::rustls::{
   sign::{any_supported_type, CertifiedKey},
   Certificate, PrivateKey, ServerConfig,
 };
-pub use upstream::{ReverseProxy, Upstream, UpstreamGroup};
+pub use upstream::{ReverseProxy, Upstream, UpstreamGroup, UpstreamGroupBuilder};
 pub use upstream_opts::UpstreamOption;
 use x509_parser::prelude::*;
 
 /// Struct serving information to route incoming connections, like server name to be handled and tls certs/keys settings.
+#[derive(Builder)]
 pub struct Backend {
+  #[builder(setter(into))]
   pub app_name: String,
+  #[builder(setter(custom))]
   pub server_name: String,
   pub reverse_proxy: ReverseProxy,
 
   // tls settings
+  #[builder(setter(custom), default)]
   pub tls_cert_path: Option<PathBuf>,
+  #[builder(setter(custom), default)]
   pub tls_cert_key_path: Option<PathBuf>,
+  #[builder(default)]
   pub https_redirection: Option<bool>,
+  #[builder(setter(custom), default)]
   pub client_ca_cert_path: Option<PathBuf>,
 }
+impl<'a> BackendBuilder {
+  pub fn server_name(&mut self, server_name: impl Into<Cow<'a, str>>) -> &mut Self {
+    self.server_name = Some(server_name.into().to_ascii_lowercase());
+    self
+  }
+  pub fn tls_cert_path(&mut self, v: &Option<String>) -> &mut Self {
+    self.tls_cert_path = Some(opt_string_to_opt_pathbuf(v));
+    self
+  }
+  pub fn tls_cert_key_path(&mut self, v: &Option<String>) -> &mut Self {
+    self.tls_cert_key_path = Some(opt_string_to_opt_pathbuf(v));
+    self
+  }
+  pub fn client_ca_cert_path(&mut self, v: &Option<String>) -> &mut Self {
+    self.client_ca_cert_path = Some(opt_string_to_opt_pathbuf(v));
+    self
+  }
+}
+
+fn opt_string_to_opt_pathbuf(input: &Option<String>) -> Option<PathBuf> {
+  input.to_owned().as_ref().map(PathBuf::from)
+}
 
 impl Backend {
   pub fn read_certs_and_key(&self) -> io::Result<CertifiedKey> {

src/backend/upstream.rs

@@ -1,5 +1,6 @@
 use super::{BytesName, PathNameBytesExp, UpstreamOption};
 use crate::log::*;
+use derive_builder::Builder;
 use rand::Rng;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 use std::{
@@ -66,15 +67,50 @@ pub struct Upstream {
   pub uri: hyper::Uri, // base uri without specific path
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Builder)]
 pub struct UpstreamGroup {
   pub upstream: Vec<Upstream>,
+  #[builder(setter(custom), default)]
   pub path: PathNameBytesExp,
+  #[builder(setter(custom), default)]
   pub replace_path: Option<PathNameBytesExp>,
+  #[builder(default)]
   pub lb: LoadBalance,
+  #[builder(default)]
   pub cnt: UpstreamCount, // counter for load balancing
+  #[builder(setter(custom), default)]
   pub opts: HashSet<UpstreamOption>,
 }
+impl UpstreamGroupBuilder {
+  pub fn path(&mut self, v: &Option<String>) -> &mut Self {
+    let path = match v {
+      Some(p) => p.to_path_name_vec(),
+      None => "/".to_path_name_vec(),
+    };
+    self.path = Some(path);
+    self
+  }
+  pub fn replace_path(&mut self, v: &Option<String>) -> &mut Self {
+    self.replace_path = Some(
+      v.to_owned()
+        .as_ref()
+        .map_or_else(|| None, |v| Some(v.to_path_name_vec())),
+    );
+    self
+  }
+  pub fn opts(&mut self, v: &Option<Vec<String>>) -> &mut Self {
+    let opts = if let Some(opts) = v {
+      opts
+        .iter()
+        .filter_map(|str| UpstreamOption::try_from(str.as_str()).ok())
+        .collect::<HashSet<UpstreamOption>>()
+    } else {
+      Default::default()
+    };
+    self.opts = Some(opts);
+    self
+  }
+}
 
 #[derive(Debug, Clone, Default)]
 pub struct UpstreamCount(Arc<AtomicUsize>);