Rewrite logging.

Cargo.toml

@@ -22,14 +22,13 @@ clap            = { version = "4", features = [ "wrap_help", "cargo", "derive" ]
 crossbeam-queue = "0.3.1"
 crossbeam-utils = "0.8.1"
 dirs            = "4.0.0"
-fern            = "0.6.0"
 form_urlencoded = "1.0"
 futures         = "0.3.4"
 hyper           = { version = "0.14", features = [ "server", "stream" ] }
 listenfd        = "1"
 log             = "0.4.8"
-log-reroute     = "0.1.5"
 num_cpus        = "1.12.0"
+once_cell       = "1"
 pin-project-lite = "0.2.4"
 rand            = "0.8.1"
 reqwest         = { version = "0.11.0", default-features = false, features = ["blocking", "rustls-tls" ] }

doc/manual/source/manual-page.rst

@@ -1534,6 +1534,10 @@ SIGUSR1: Reload TALs and restart validation
    that succeeds, restart validation. If loading the TALs fails, Routinator
    will exit.
 
+SIGUSR2: Re-open log file
+   When receiving SIGUSR2 and logging to a file is enabled, Routinator will
+   re-open the log file. If this fails, Routinator will exit.
+
 Exit Status
 -----------
 

doc/manual/source/prometheus-metrics.rst

@@ -69,7 +69,7 @@ file of the RRDP repository, or the base URI of the rsync repository.
         manifest’s own CRL is considered a *stray*.
       * ``ca_cert`` - The number of Certificate Authority (CA) certificates with 
         the state *valid*.
-      * ``router_cert`` - The number of End Entity (EE) certificates found to be
+      * ``router_cert`` - The number of router certificates found to be
         present and *valid*. This only refers to such certificates included as 
         stand-alone files which are BGPsec router certificates.
       * ``roa`` - The number of :term:`Route Origin Attestations <Route Origin 

src/operation.rs

@@ -19,7 +19,7 @@ use std::str::FromStr;
 use std::sync::mpsc;
 use std::sync::Arc;
 use std::sync::mpsc::RecvTimeoutError;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 #[cfg(feature = "rta")] use bytes::Bytes;
 use clap::{Arg, Args, ArgAction, ArgMatches, FromArgMatches, Parser};
 use log::{error, info};
@@ -275,25 +275,46 @@ impl Server {
                 if let Some(log) = log.as_ref() {
                     log.flush();
                 }
-                match sig_rx.recv_timeout(timeout) {
-                    Ok(UserSignal::ReloadTals) => {
-                        match validation.reload_tals() {
-                            Ok(_) => {
-                                info!("Reloaded TALs at user request.");
-                            },
-                            Err(_) => {
-                                error!(
-                                    "Fatal: Reloading TALs failed, \
-                                     shutting down."
-                                );
-                                break Err(Failed);
+
+                // Because we don’t want to restart validation upon
+                // log rotation, we need to loop here. But then we need
+                // to recalculate timeout.
+                let deadline = Instant::now() + timeout;
+                let end = loop {
+                    let timeout = deadline.saturating_duration_since(
+                        Instant::now()
+                    );
+                    match sig_rx.recv_timeout(timeout) {
+                        Ok(UserSignal::ReloadTals) => {
+                            match validation.reload_tals() {
+                                Ok(_) => {
+                                    info!("Reloaded TALs at user request.");
+                                    break None;
+                                },
+                                Err(_) => {
+                                    error!(
+                                        "Fatal: Reloading TALs failed, \
+                                         shutting down."
+                                    );
+                                    break Some(Err(Failed));
+                                }
                             }
                         }
+                        Ok(UserSignal::RotateLog) => {
+                            if process.rotate_log().is_err() {
+                                break Some(Err(Failed));
+                            }
+                        }
+                        Err(RecvTimeoutError::Timeout) => {
+                            break None;
+                        }
+                        Err(RecvTimeoutError::Disconnected) => {
+                            break Some(Ok(()));
+                        }
                     }
-                    Err(RecvTimeoutError::Timeout) => { }
-                    Err(RecvTimeoutError::Disconnected) => {
-                        break Ok(());
-                    }
+                };
+                if let Some(end) = end {
+                    break end;
                 }
             };
             // An error here means the receiver is gone which is fine.
@@ -1219,6 +1240,7 @@ impl Man {
 #[allow(dead_code)]
 enum UserSignal {
     ReloadTals,
+    RotateLog,
 }
 
 /// Wait for the next validation run or a user telling us to quit or reload.
@@ -1227,6 +1249,7 @@ enum UserSignal {
 #[cfg(unix)]
 struct SignalListener {
     usr1: Signal,
+    usr2: Signal,
 }
 
 #[cfg(unix)]
@@ -1239,16 +1262,25 @@ impl SignalListener {
                     error!("Attaching to signal USR1 failed: {}", err);
                     return Err(Failed)
                 }
-            }
+            },
+            usr2: match signal(SignalKind::user_defined2()) {
+                Ok(usr2) => usr2,
+                Err(err) => {
+                    error!("Attaching to signal USR2 failed: {}", err);
+                    return Err(Failed)
+                }
+            },
         })
     }
 
     /// Waits for the next thing to do.
     ///
     /// Returns what to do.
     pub async fn next(&mut self) -> UserSignal {
-        self.usr1.recv().await;
-        UserSignal::ReloadTals
+        tokio::select! {
+            _ = self.usr1.recv() => UserSignal::ReloadTals,
+            _ = self.usr2.recv() => UserSignal::RotateLog,
+        }
     }
 }