cli/node: Improve log rotation — heartwood

Only the latest log was kept as node.log.old. Now, log files are numbered (node.log.1, node.log.2 and so on). Also node.log is now a hard link to the current log file. rad node stop will delete node.log (note that node.log.x stays intact) and rad node start will delete node.log before it creates node.log.y in case the node crashed.

Also, when running in foreground mode, now a log file is created. It just contains the hint that the node was started in foreground mode, just to avoid confusion.

             control::status(&node, &profile)?;
         }
         Operation::Stop => {
             control::stop(node)?;
             control::stop(node, &profile);
         }
     }

 mod logs;
 use logs::{LogRotatorFileSystem, Rotated};
 use std::collections::HashMap;
 use std::ffi::OsString;
 use std::fs::{File, OpenOptions};
 use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
 use std::{fs, io, path::Path, process, thread, time};
 use std::fs::File;
 use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
 use std::{path::Path, process, thread, time};
 use anyhow::{anyhow, Context};
 use localtime::LocalTime;

 /// How long to wait for the node to start before returning an error.
 pub const NODE_START_TIMEOUT: time::Duration = time::Duration::from_secs(6);
 /// Node log file name.
 pub const NODE_LOG: &str = "node.log";
 /// Node log old file name, after rotation.
 pub const NODE_LOG_OLD: &str = "node.log.old";
 pub fn start(
     node: Node,

     if !options.contains(&OsString::from("--force")) {
         options.push(OsString::from("--force"));
     }
     let Rotated {
         path: log_path,
         log: log_file,
     } = LogRotatorFileSystem::from_profile(profile).rotate()?;
     if daemon {
         let log = log_rotate(profile)?;
         let child = process::Command::new(cmd)
             .args(options)
             .envs(envs)
             .stdin(process::Stdio::null())
             .stdout(process::Stdio::from(log.try_clone()?))
             .stderr(process::Stdio::from(log))
             .stdout(process::Stdio::from(log_file.try_clone()?))
             .stderr(process::Stdio::from(log_file))
             .spawn()
             .map_err(|e| anyhow!("failed to start node process {cmd:?}: {e}"))?;
         let pid = term::format::parens(term::format::dim(child.id()));

             }
         }
     } else {
         // Write a hint to the log file, but swallow any errors.
         let mut log_file = log_file;
         let _ = log_file.write_all(format!("radicle-node started in foreground, no futher log messages are written to '{}' (this file).\n", log_path.display()).as_bytes());
         let mut child = process::Command::new(cmd)
             .args(options)
             .envs(envs)

     Ok(())
 }
 pub fn stop(node: Node) -> anyhow::Result<()> {
 pub fn stop(node: Node, profile: &Profile) {
     let mut spinner = term::spinner("Stopping node...");
     if node.shutdown().is_err() {
         spinner.error("node is not running");

         spinner.message("Node stopped");
         spinner.finish();
     }
     Ok(())
     let rotator = LogRotatorFileSystem::from_profile(profile);
     rotator.remove().ok();
 }
 pub fn debug(node: &mut Node) -> anyhow::Result<()> {

     Ok(())
 }
 fn log_rotate(profile: &Profile) -> io::Result<File> {
     let base = profile.home.node();
     if base.join(NODE_LOG).exists() {
         // Let this fail, eg. if the file doesn't exist.
         fs::remove_file(base.join(NODE_LOG_OLD)).ok();
         fs::rename(base.join(NODE_LOG), base.join(NODE_LOG_OLD))?;
     }
     let log = OpenOptions::new()
         .write(true)
         .create_new(true)
         .open(base.join(NODE_LOG))?;
     Ok(log)
 }
 fn state_label() -> term::Paint<String> {
     term::Paint::from("?".to_string())
 }

 use std::collections::BinaryHeap;
 use std::fs::{File, OpenOptions};
 use std::path::PathBuf;
 use std::{fs, io};
 use radicle::Profile;
 /// [`LogRotator`] manages the rotation of the log files when the Radicle node
 /// is run in the background, without being managed by a service manager.
 pub struct LogRotator {
     /// The base path where the logs should live.
     base: PathBuf,
     /// All existing logs, identified by a suffix.
     existing_logs: BinaryHeap<u16>,
 }
 impl LogRotator {
     /// Node log file name.
     pub const NODE_LOG: &str = "node.log";
     /// Node log old file name, after rotation.
     pub const NODE_LOG_OLD_PREFIX: &str = "node.log.";
     /// Construct a new [`LogRotator`] with the give `base` path.
     pub fn new(base: PathBuf) -> Self {
         Self {
             base,
             existing_logs: BinaryHeap::new(),
         }
     }
     /// Add a set of existing suffixes to known logs.
     pub fn found_logs(&mut self, suffixes: impl Iterator<Item = u16>) {
         self.existing_logs.extend(suffixes);
     }
     /// Specify that the [`LogRotator::current`] log should be removed.
     ///
     /// Returns `None` if the file does not exist.
     pub fn remove_current(&self) -> Option<Remove> {
         let current = self.current();
         current.exists().then_some(Remove { current })
     }
     /// Specify that the logs should be rotated.
     pub fn rotate(&self) -> Rotate {
         let next = self.next_log();
         let remove = self.remove_current();
         Rotate {
             next,
             link: self.current(),
             remove,
         }
     }
     /// The current log file that should be logged to.
     pub fn current(&self) -> PathBuf {
         self.base.join(Self::NODE_LOG)
     }
     fn next_log(&self) -> PathBuf {
         let suffix = self
             .existing_logs
             .peek()
             .copied()
             .unwrap_or(0)
             .saturating_add(1);
         self.base
             .join(Self::NODE_LOG_OLD_PREFIX.to_owned() + suffix.to_string().as_str())
     }
 }
 /// A [`LogRotator`] that implements the removal and rotation by accessing the
 /// filesystem.
 pub struct LogRotatorFileSystem {
     rotator: LogRotator,
 }
 impl LogRotatorFileSystem {
     /// Create a new [`LogRotatorFileSystem`] from a [`Profile`].
     ///
     /// The [`LogRotator`]'s base path will be the node path.
     pub fn from_profile(profile: &Profile) -> Self {
         Self {
             rotator: LogRotator::new(profile.home.node()),
         }
     }
     /// Rotate the log files, returning [`Rotated`].
     pub fn rotate(mut self) -> io::Result<Rotated> {
         self.rotator.found_logs(self.existing_logs().into_iter());
         self.rotator.rotate().execute()
     }
     /// Remove the current log file, returning `true` if the file existed and
     /// was removed.
     pub fn remove(self) -> io::Result<bool> {
         self.rotator
             .remove_current()
             .map(|remove| remove.execute())
             .transpose()
             .map(|res| res.is_some())
     }
     fn parse_suffix(filename: String) -> Option<u16> {
         filename
             .strip_prefix(LogRotator::NODE_LOG_OLD_PREFIX)
             .and_then(|suffix| suffix.parse::<u16>().ok())
     }
     fn existing_logs(&self) -> BinaryHeap<u16> {
         self.rotator
             .base
             .read_dir()
             .ok()
             .map(|dir| {
                 dir.filter_map(Result::ok)
                     .filter_map(|entry| entry.file_name().into_string().ok())
                     .filter_map(Self::parse_suffix)
                     .collect()
             })
             .unwrap_or_default()
     }
 }
 /// Remove the path identified by [`Remove::current`].
 pub struct Remove {
     current: PathBuf,
 }
 impl Remove {
     /// Use [`fs::remove_file`] to remove the file.
     pub fn execute(self) -> io::Result<()> {
         fs::remove_file(self.current)
     }
 }
 /// Rotate the logs to the next log.
 pub struct Rotate {
     /// The next log that needs to be created
     next: PathBuf,
     /// The path to create a hard link to.
     link: PathBuf,
     /// If the current log exists, then we need to remove it
     remove: Option<Remove>,
 }
 impl Rotate {
     /// Remove the existing file, if it exists. Then create the next log, and
     /// create a hard link to it.
     pub fn execute(self) -> io::Result<Rotated> {
         if let Some(to_remove) = self.remove {
             if let Err(err) = to_remove.execute() {
                 log::warn!(target: "cli", "Failed to remove current log file: {err}");
             }
         }
         let log = OpenOptions::new()
             .write(true)
             .create_new(true)
             .open(&self.next)?;
         fs::hard_link(&self.next, &self.link)?;
         Ok(Rotated {
             path: self.next,
             log,
         })
     }
 }
 /// The result of rotating the logs.
 pub struct Rotated {
     /// The [`PathBuf`] to the new log file.
     pub path: PathBuf,
     /// The [`File`] handle for the log file.
     pub log: File,
 }