move target_to_backend to sozu-command-lib

bin/src/logging.rs

@@ -1,14 +1,6 @@
 use std::env;
 use std::sync::{Arc, Mutex};
-use std::io::{stdout};
-use std::path::Path;
-use std::fs::OpenOptions;
-use rand::{Rng,thread_rng};
-use mio::net::UnixDatagram;
-use std::net::{TcpStream,UdpSocket,ToSocketAddrs};
-use sozu_command::logging::{Logger,LoggerBackend};
-use rand::distributions::Alphanumeric;
-
+use sozu_command::logging::{Logger,LoggerBackend,target_to_backend};
 
 lazy_static! {
   pub static ref MAIN_LOGGER: Arc<Mutex<Logger>> = Arc::new(Mutex::new(Logger::new()));
@@ -88,57 +80,3 @@ pub fn setup(tag: String, level: &str, target: &str, access_target: Option<&str>
   let _ = &*TAG;
 }
 
-pub fn target_to_backend(target: &str) -> LoggerBackend {
-  if target == "stdout" {
-    LoggerBackend::Stdout(stdout())
-  } else if target.starts_with("udp://") {
-    let addr_res = (&target[6..]).to_socket_addrs();
-    match addr_res {
-      Err(e) => {
-        println!("invalid log target configuration ({:?}): {}", e, target);
-        LoggerBackend::Stdout(stdout())
-      },
-      Ok(mut addrs) => {
-        let socket = UdpSocket::bind(("0.0.0.0", 0)).unwrap();
-        LoggerBackend::Udp(socket, addrs.next().unwrap())
-      }
-    }
-  } else if target.starts_with("tcp://") {
-    let addr_res = (&target[6..]).to_socket_addrs();
-    match addr_res {
-      Err(e) => {
-        println!("invalid log target configuration ({:?}): {}", e, target);
-        LoggerBackend::Stdout(stdout())
-      },
-      Ok(mut addrs) => {
-        LoggerBackend::Tcp(TcpStream::connect(addrs.next().unwrap()).unwrap())
-      }
-    }
-  } else if target.starts_with("unix://") {
-    let path = Path::new(&target[7..]);
-    if !path.exists() {
-      println!("invalid log target configuration: {} is not a file", &target[7..]);
-      LoggerBackend::Stdout(stdout())
-    } else {
-      let mut dir = env::temp_dir();
-      let s: String = thread_rng().sample_iter(&Alphanumeric).take(12).map(|c| c as char).collect();
-      dir.push(s);
-      let socket = UnixDatagram::bind(dir).unwrap();
-      socket.connect(path).unwrap();
-      LoggerBackend::Unix(socket)
-    }
-  } else if target.starts_with("file://") {
-    let path = Path::new(&target[7..]);
-    match OpenOptions::new().create(true).append(true).open(path) {
-      Ok(file) => LoggerBackend::File(sozu_command::writer::MultiLineWriter::new(file)),
-      Err(e)   => {
-        println!("invalid log target configuration: could not open file at {} (error: {:?})", &target[7..], e);
-        LoggerBackend::Stdout(stdout())
-      }
-    }
-  } else {
-    println!("invalid log target configuration: {}", target);
-    LoggerBackend::Stdout(stdout())
-  }
-}
-

bin/src/worker.rs

@@ -34,6 +34,7 @@ use sozu_command::state::ConfigState;
 use sozu_command::scm_socket::{Listeners,ScmSocket};
 use sozu_command::proxy::{ProxyRequest,ProxyResponse,ProxyRequestData};
 use sozu_command::ready::Ready;
+use sozu_command::logging::target_to_backend;
 use sozu::server::Server;
 use sozu::metrics;
 
@@ -97,8 +98,8 @@ pub fn begin_worker_process(fd: i32, scm: i32, configuration_state_fd: i32, id:
   let worker_id = format!("{}-{:02}", "WRK", id);
   logging::setup(worker_id.clone(), &worker_config.log_level,
     &worker_config.log_target, worker_config.log_access_target.as_ref().map(|s| s.as_str()));
-  let backend = logging::target_to_backend(&worker_config.log_target);
-  let access_backend = worker_config.log_access_target.as_deref().map(logging::target_to_backend);
+  let backend = target_to_backend(&worker_config.log_target);
+  let access_backend = worker_config.log_access_target.as_deref().map(target_to_backend);
   sozu_command_lib::logging::Logger::init(worker_id.clone(), &worker_config.log_level,
     backend, access_backend);
   info!("worker {} starting...", id);

command/Cargo.toml

@@ -34,6 +34,7 @@ toml = "^0.5"
 sha2 = "^0.9"
 memchr = "2.3"
 regex = "1.1"
+rand = "^0.7"
 serde = "^1.0.34"
 serde_json = "^1.0.34"
 serde_derive = "^1.0.34"

command/src/logging.rs

@@ -1,13 +1,17 @@
 use libc;
+use std::env;
 use std::fs::File;
 use std::str::FromStr;
 use std::cell::RefCell;
 use std::cmp::{self,Ord};
 use std::fmt::{Arguments,format};
 use std::io::{stdout,Stdout,Write};
-use std::net::{SocketAddr,UdpSocket};
-use std::net::TcpStream;
+use std::path::Path;
+use std::fs::OpenOptions;
+use std::net::{SocketAddr, ToSocketAddrs, UdpSocket,TcpStream};
 use mio::net::UnixDatagram;
+use rand::{Rng,thread_rng};
+use rand::distributions::Alphanumeric;
 
 thread_local! {
   pub static LOGGER: RefCell<Logger> = RefCell::new(Logger::new());
@@ -447,6 +451,60 @@ pub fn parse_logging_spec(spec: &str) -> Vec<LogDirective> {
     dirs
 }
 
+pub fn target_to_backend(target: &str) -> LoggerBackend {
+  if target == "stdout" {
+    LoggerBackend::Stdout(stdout())
+  } else if target.starts_with("udp://") {
+    let addr_res = (&target[6..]).to_socket_addrs();
+    match addr_res {
+      Err(e) => {
+        println!("invalid log target configuration ({:?}): {}", e, target);
+        LoggerBackend::Stdout(stdout())
+      },
+      Ok(mut addrs) => {
+        let socket = UdpSocket::bind(("0.0.0.0", 0)).unwrap();
+        LoggerBackend::Udp(socket, addrs.next().unwrap())
+      }
+    }
+  } else if target.starts_with("tcp://") {
+    let addr_res = (&target[6..]).to_socket_addrs();
+    match addr_res {
+      Err(e) => {
+        println!("invalid log target configuration ({:?}): {}", e, target);
+        LoggerBackend::Stdout(stdout())
+      },
+      Ok(mut addrs) => {
+        LoggerBackend::Tcp(TcpStream::connect(addrs.next().unwrap()).unwrap())
+      }
+    }
+  } else if target.starts_with("unix://") {
+    let path = Path::new(&target[7..]);
+    if !path.exists() {
+      println!("invalid log target configuration: {} is not a file", &target[7..]);
+      LoggerBackend::Stdout(stdout())
+    } else {
+      let mut dir = env::temp_dir();
+      let s: String = thread_rng().sample_iter(&Alphanumeric).take(12).collect();
+      dir.push(s);
+      let socket = UnixDatagram::bind(dir).unwrap();
+      socket.connect(path).unwrap();
+      LoggerBackend::Unix(socket)
+    }
+  } else if target.starts_with("file://") {
+    let path = Path::new(&target[7..]);
+    match OpenOptions::new().create(true).append(true).open(path) {
+      Ok(file) => LoggerBackend::File(crate::writer::MultiLineWriter::new(file)),
+      Err(e)   => {
+        println!("invalid log target configuration: could not open file at {} (error: {:?})", &target[7..], e);
+        LoggerBackend::Stdout(stdout())
+      }
+    }
+  } else {
+    println!("invalid log target configuration: {}", target);
+    LoggerBackend::Stdout(stdout())
+  }
+}
+
 #[macro_export]
 macro_rules! log {
     (__inner__ $target:expr, $lvl:expr, $format:expr, $level_tag:expr,