Move tunnel log rotation into tunnel monitoring module

2 files changed, 36 insertions, 46 deletions

diff --git a/talpid-core/src/tunnel/mod.rs b/talpid-core/src/tunnel/mod.rs
index c0f1abcde2..db73f2656d 100644
--- a/talpid-core/src/tunnel/mod.rs
+++ b/talpid-core/src/tunnel/mod.rs
@@ -5,7 +5,7 @@ use std::{
     net::IpAddr,
     path::{Path, PathBuf},
 };
-
+use crate::logging;
 #[cfg(unix)]
 use talpid_types::net::wireguard as wireguard_types;
 use talpid_types::net::{openvpn as openvpn_types, GenericTunnelOptions, TunnelParameters};
@@ -16,6 +16,9 @@ pub mod openvpn;
 #[cfg(unix)]
 mod wireguard;
 
+const OPENVPN_LOG_FILENAME: &str = "openvpn.log";
+const WIREGUARD_LOG_FILENAME: &str = "wireguard.log";
+
 
 error_chain! {
     errors {
@@ -35,6 +38,10 @@ error_chain! {
         UnsupportedPlatform {
             description("Tunnel type not supported on this operating system")
         }
+        /// Failed to rotate tunnel log file
+        RotateLogError {
+            description("Failed to rotate tunnel log file")
+        }
     }
 
     links {
@@ -117,7 +124,7 @@ impl TunnelMonitor {
     pub fn start<L>(
         tunnel_parameters: &TunnelParameters,
         tunnel_alias: Option<OsString>,
-        log: Option<PathBuf>,
+        log_dir: &Option<PathBuf>,
         resource_dir: &Path,
         on_event: L,
     ) -> Result<Self>
@@ -125,14 +132,15 @@ impl TunnelMonitor {
         L: Fn(TunnelEvent) + Send + Sync + 'static,
     {
         Self::ensure_ipv6_can_be_used_if_enabled(&tunnel_parameters.get_generic_options())?;
+        let log_file = Self::prepare_tunnel_log_file(&tunnel_parameters, log_dir)?;
 
         match tunnel_parameters {
             TunnelParameters::OpenVpn(config) => {
-                Self::start_openvpn_tunnel(&config, tunnel_alias, log, resource_dir, on_event)
+                Self::start_openvpn_tunnel(&config, tunnel_alias, log_file, resource_dir, on_event)
             }
             #[cfg(unix)]
             TunnelParameters::Wireguard(config) => {
-                Self::start_wireguard_tunnel(&config, log, on_event)
+                Self::start_wireguard_tunnel(&config, log_file, on_event)
             }
             #[cfg(windows)]
             TunnelParameters::Wireguard(_) => bail!(ErrorKind::UnsupportedPlatform),
@@ -187,6 +195,23 @@ impl TunnelMonitor {
         }
     }
 
+    fn prepare_tunnel_log_file(
+        parameters: &TunnelParameters,
+        log_dir: &Option<PathBuf>,
+    ) -> Result<Option<PathBuf>> {
+        if let Some(ref log_dir) = log_dir {
+            let filename = match parameters {
+                TunnelParameters::OpenVpn(_) => OPENVPN_LOG_FILENAME,
+                TunnelParameters::Wireguard(_) => WIREGUARD_LOG_FILENAME,
+            };
+            let tunnel_log = log_dir.join(filename);
+            logging::rotate_log(&tunnel_log).chain_err(|| ErrorKind::RotateLogError)?;
+            Ok(Some(tunnel_log))
+        } else {
+            Ok(None)
+        }
+    }
+
 
     /// Creates a handle to this monitor, allowing the tunnel to be closed while some other
     /// thread
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 0896fd18cf..f52a8f8e52 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -23,32 +23,18 @@ use super::{
 };
 use crate::{
     firewall::FirewallPolicy,
-    logging,
     tunnel::{self, CloseHandle, TunnelEvent, TunnelMetadata, TunnelMonitor},
 };
 
 
 const MIN_TUNNEL_ALIVE_TIME: Duration = Duration::from_millis(1000);
 
-const OPENVPN_LOG_FILENAME: &str = "openvpn.log";
-const WIREGUARD_LOG_FILENAME: &str = "wireguard.log";
-
 #[cfg(windows)]
 const TUNNEL_INTERFACE_ALIAS: Option<&str> = Some("Mullvad");
 #[cfg(not(windows))]
 const TUNNEL_INTERFACE_ALIAS: Option<&str> = None;
 
-error_chain! {
-    errors {
-        RotateLogError {
-            description("Failed to rotate tunnel log file")
-        }
-    }
-
-    links {
-        TunnelMonitorError(tunnel::Error, tunnel::ErrorKind);
-    }
-}
+error_chain! {}
 
 /// The tunnel has been started, but it is not established/functional.
 pub struct ConnectingState {
@@ -86,7 +72,7 @@ impl ConnectingState {
         log_dir: &Option<PathBuf>,
         resource_dir: &Path,
         retry_attempt: u32,
-    ) -> Result<Self> {
+    ) -> crate::tunnel::Result<Self> {
         let (event_tx, event_rx) = mpsc::unbounded();
         let monitor = Self::spawn_tunnel_monitor(&parameters, log_dir, resource_dir, event_tx)?;
         let close_handle = monitor.close_handle();
@@ -106,36 +92,17 @@ impl ConnectingState {
         log_dir: &Option<PathBuf>,
         resource_dir: &Path,
         events: mpsc::UnboundedSender<TunnelEvent>,
-    ) -> Result<TunnelMonitor> {
+    ) -> crate::tunnel::Result<TunnelMonitor> {
         let on_tunnel_event = move |event| {
             let _ = events.unbounded_send(event);
         };
-        let log_file = Self::prepare_tunnel_log_file(&parameters, log_dir)?;
-
-        Ok(TunnelMonitor::start(
+        TunnelMonitor::start(
             &parameters,
             TUNNEL_INTERFACE_ALIAS.to_owned().map(OsString::from),
-            log_file.clone(),
+            log_dir,
             resource_dir,
             on_tunnel_event,
-        )?)
-    }
-
-    fn prepare_tunnel_log_file(
-        parameters: &TunnelParameters,
-        log_dir: &Option<PathBuf>,
-    ) -> Result<Option<PathBuf>> {
-        if let Some(ref log_dir) = log_dir {
-            let filename = match parameters {
-                TunnelParameters::OpenVpn(_) => OPENVPN_LOG_FILENAME,
-                TunnelParameters::Wireguard(_) => WIREGUARD_LOG_FILENAME,
-            };
-            let tunnel_log = log_dir.join(filename);
-            logging::rotate_log(&tunnel_log).chain_err(|| ErrorKind::RotateLogError)?;
-            Ok(Some(tunnel_log))
-        } else {
-            Ok(None)
-        }
+        )
     }
 
     fn spawn_tunnel_monitor_wait_thread(
@@ -392,9 +359,7 @@ impl TunnelState for ConnectingState {
                         }
                         Err(error) => {
                             let block_reason = match *error.kind() {
-                                ErrorKind::TunnelMonitorError(
-                                    tunnel::ErrorKind::EnableIpv6Error,
-                                ) => BlockReason::Ipv6Unavailable,
+                                tunnel::ErrorKind::EnableIpv6Error => BlockReason::Ipv6Unavailable,
                                 _ => BlockReason::StartTunnelError,
                             };