mock all methods on non-linux platforms

src/controller.rs

@@ -7,16 +7,18 @@ use std::{
     time::Duration,
 };
 
+#[cfg(target_os = "linux")]
+use crate::suicide;
 use crate::{
     critical,
     hub::Hub,
-    suicide,
     supervisor::Supervisor,
     thread_rt::{Builder, RTParams, Scheduling},
     Error, Result,
 };
 pub use roboplc_derive::WorkerOpts;
 use rtsc::data_policy::DataDeliveryPolicy;
+#[cfg(target_os = "linux")]
 use signal_hook::{
     consts::{SIGINT, SIGTERM},
     iterator::Signals,
@@ -203,7 +205,7 @@ where
     pub fn register_signals_with_shutdown_handler<H>(
         &mut self,
         handle_fn: H,
-        shutdown_timeout: Duration,
+        #[allow(unused_variables)] shutdown_timeout: Duration,
     ) -> Result<()>
     where
         H: Fn(&Context<D, V>) + Send + Sync + 'static,
@@ -218,22 +220,30 @@ where
         builder.park_on_errors = true;
         macro_rules! sig_handler {
             ($handler: expr) => {{
-                let context = self.context();
-                let mut signals = Signals::new([SIGTERM, SIGINT])?;
-                move || {
-                    if let Some(sig) = signals.forever().next() {
-                        match sig {
-                            SIGTERM | SIGINT => {
-                                suicide(shutdown_timeout, true);
-                                $handler(&context);
-                                context.terminate();
+                #[cfg(target_os = "linux")]
+                {
+                    let context = self.context();
+                    let mut signals = Signals::new([SIGTERM, SIGINT])?;
+                    move || {
+                        if let Some(sig) = signals.forever().next() {
+                            match sig {
+                                SIGTERM | SIGINT => {
+                                    suicide(shutdown_timeout, true);
+                                    $handler(&context);
+                                    context.terminate();
+                                }
+                                _ => unreachable!(),
                             }
-                            _ => unreachable!(),
                         }
                     }
                 }
+                #[cfg(not(target_os = "linux"))]
+                {
+                    move || {}
+                }
             }};
         }
+        #[allow(unused_variables)]
         let h = handler.clone();
         if let Err(e) = self.supervisor.spawn(builder.clone(), sig_handler!(h)) {
             if !matches!(e, Error::RTSchedSetSchduler(_)) {

src/lib.rs

@@ -6,7 +6,6 @@ use std::panic::PanicInfo;
 use std::{env, sync::Arc, time::Duration};
 
 use colored::Colorize as _;
-#[cfg(target_os = "linux")]
 use thread_rt::{RTParams, Scheduling};
 
 pub use log::LevelFilter;
@@ -90,7 +89,6 @@ pub use rtsc::data_policy::{DataDeliveryPolicy, DeliveryPolicy};
 /// Reliable TCP/Serial communications
 pub mod comm;
 /// Controller and workers
-#[cfg(target_os = "linux")]
 pub mod controller;
 /// In-process data communication pub/sub hub, synchronous edition
 pub mod hub;
@@ -100,10 +98,8 @@ pub mod hub_async;
 /// I/O
 pub mod io;
 /// Task supervisor to manage real-time threads
-#[cfg(target_os = "linux")]
 pub mod supervisor;
-/// Real-time thread functions to work with [`supervisor::Supervisor`] and standalone
-#[cfg(target_os = "linux")]
+/// Real-time thread functions to work with [`supervisor::Supervisor`] and standalone, Linux only
 pub mod thread_rt;
 
 /// The crate result type
@@ -245,7 +241,6 @@ impl Error {
 }
 
 /// Immediately kills the current process and all its subprocesses with a message to stderr
-#[cfg(target_os = "linux")]
 pub fn critical(msg: &str) -> ! {
     eprintln!("{}", msg.red().bold());
     thread_rt::suicide_myself(Duration::from_secs(0), false);
@@ -257,7 +252,6 @@ pub fn critical(msg: &str) -> ! {
 /// period of time.
 ///
 /// Prints warnings to STDOUT if warn is true
-#[cfg(target_os = "linux")]
 pub fn suicide(delay: Duration, warn: bool) {
     let mut builder = thread_rt::Builder::new().name("suicide").rt_params(
         RTParams::new()
@@ -336,14 +330,12 @@ pub fn metrics_exporter_install(
 
 /// Sets panic handler to immediately kill the process and its childs with SIGKILL. The process is
 /// killed when panic happens in ANY thread
-#[cfg(target_os = "linux")]
 pub fn setup_panic() {
     std::panic::set_hook(Box::new(move |info: &PanicInfo| {
         panic(info);
     }));
 }
 
-#[cfg(target_os = "linux")]
 fn panic(info: &PanicInfo) -> ! {
     eprintln!("{}", info.to_string().red().bold());
     thread_rt::suicide_myself(Duration::from_secs(0), false);
@@ -372,13 +364,10 @@ pub fn configure_logger(filter: LevelFilter) {
 
 /// Prelude module
 pub mod prelude {
-    #[cfg(target_os = "linux")]
     pub use super::suicide;
-    #[cfg(target_os = "linux")]
     pub use crate::controller::*;
     pub use crate::hub::prelude::*;
     pub use crate::io::prelude::*;
-    #[cfg(target_os = "linux")]
     pub use crate::supervisor::prelude::*;
     pub use crate::time::DurationRT;
     pub use bma_ts::{Monotonic, Timestamp};

src/supervisor.rs

@@ -29,8 +29,12 @@ impl<T> Default for Supervisor<T> {
 
 macro_rules! vacant_entry {
     ($self:ident, $builder:ident) => {{
-        let Some(name) = $builder.name.clone() else { return Err(Error::SupervisorNameNotSpecified); };
-        let btree_map::Entry::Vacant(entry) = $self.tasks.entry(name.clone()) else { return Err(Error::SupervisorDuplicateTask(name)); };
+        let Some(name) = $builder.name.clone() else {
+                return Err(Error::SupervisorNameNotSpecified);
+            };
+        let btree_map::Entry::Vacant(entry) = $self.tasks.entry(name.clone()) else {
+                return Err(Error::SupervisorDuplicateTask(name));
+            };
         entry
     }};
 }

src/thread_rt.rs

@@ -2,19 +2,22 @@ use crate::{time::Interval, Error, Result};
 use bma_ts::{Monotonic, Timestamp};
 use colored::Colorize;
 use core::fmt;
+#[cfg(target_os = "linux")]
 use libc::cpu_set_t;
+#[cfg(target_os = "linux")]
 use nix::{sys::signal, unistd};
 use serde::{Deserialize, Serialize, Serializer};
 use std::{
     collections::{BTreeMap, BTreeSet},
     fs,
     io::BufRead,
-    mem,
     sync::atomic::{AtomicBool, Ordering},
     thread::{self, JoinHandle, Scope, ScopedJoinHandle},
     time::Duration,
 };
-use sysinfo::{Pid, PidExt, ProcessExt, System, SystemExt};
+#[cfg(target_os = "linux")]
+use sysinfo::PidExt;
+use sysinfo::{Pid, ProcessExt, System, SystemExt};
 use tracing::warn;
 
 static REALTIME_MODE: AtomicBool = AtomicBool::new(true);
@@ -29,6 +32,12 @@ fn is_realtime() -> bool {
     REALTIME_MODE.load(Ordering::Relaxed)
 }
 
+macro_rules! panic_os {
+    () => {
+        panic!("The function is not supported on this OS");
+    };
+}
+
 /// The method preallocates a heap memory region with the given size. The method is useful to
 /// prevent memory fragmentation and speed up memory allocation. It is highly recommended to call
 /// the method at the beginning of the program.
@@ -38,31 +47,39 @@ fn is_realtime() -> bool {
 /// # Panics
 ///
 /// Will panic if the page size is too large (more than usize)
+#[allow(unused_variables)]
 pub fn prealloc_heap(size: usize) -> Result<()> {
     if !is_realtime() {
         return Ok(());
     }
-    let page_size = unsafe {
-        if libc::mallopt(libc::M_MMAP_MAX, 0) != 1 {
-            return Err(Error::failed(
-                "unable to disable mmap for allocation of large mem regions",
-            ));
-        }
-        if libc::mallopt(libc::M_TRIM_THRESHOLD, -1) != 1 {
-            return Err(Error::failed("unable to disable trimming"));
-        }
-        if libc::mlockall(libc::MCL_FUTURE) == -1 {
-            return Err(Error::failed("unable to lock memory pages"));
+    #[cfg(target_os = "linux")]
+    {
+        let page_size = unsafe {
+            if libc::mallopt(libc::M_MMAP_MAX, 0) != 1 {
+                return Err(Error::failed(
+                    "unable to disable mmap for allocation of large mem regions",
+                ));
+            }
+            if libc::mallopt(libc::M_TRIM_THRESHOLD, -1) != 1 {
+                return Err(Error::failed("unable to disable trimming"));
+            }
+            if libc::mlockall(libc::MCL_FUTURE) == -1 {
+                return Err(Error::failed("unable to lock memory pages"));
+            };
+            usize::try_from(libc::sysconf(libc::_SC_PAGESIZE)).expect("Page size too large")
         };
-        usize::try_from(libc::sysconf(libc::_SC_PAGESIZE)).expect("Page size too large")
-    };
-    let mut heap_mem = vec![0_u8; size];
-    std::hint::black_box(move || {
-        for i in (0..size).step_by(page_size) {
-            heap_mem[i] = 0xff;
-        }
-    })();
-    Ok(())
+        let mut heap_mem = vec![0_u8; size];
+        std::hint::black_box(move || {
+            for i in (0..size).step_by(page_size) {
+                heap_mem[i] = 0xff;
+            }
+        })();
+        Ok(())
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        panic_os!();
+    }
 }
 
 /// A thread builder object, similar to [`thread::Builder`] but with real-time capabilities
@@ -100,6 +117,7 @@ pub enum Scheduling {
     Other,
 }
 
+#[cfg(target_os = "linux")]
 impl From<Scheduling> for libc::c_int {
     fn from(value: Scheduling) -> Self {
         match value {
@@ -113,6 +131,7 @@ impl From<Scheduling> for libc::c_int {
     }
 }
 
+#[cfg(target_os = "linux")]
 impl From<libc::c_int> for Scheduling {
     fn from(value: libc::c_int) -> Self {
         match value {
@@ -488,27 +507,36 @@ impl RTParams {
     }
 }
 
+#[allow(unused_variables)]
 fn thread_init_internal(
     tx_tid: oneshot::Sender<(libc::c_int, oneshot::Sender<bool>)>,
     park_on_errors: bool,
 ) {
-    let tid = unsafe { i32::try_from(libc::syscall(libc::SYS_gettid)).unwrap_or(-200) };
-    let (tx_ok, rx_ok) = oneshot::channel::<bool>();
-    tx_tid.send((tid, tx_ok)).unwrap();
-    if !rx_ok.recv().unwrap() {
-        if park_on_errors {
-            loop {
-                thread::park();
+    #[cfg(target_os = "linux")]
+    {
+        let tid = unsafe { i32::try_from(libc::syscall(libc::SYS_gettid)).unwrap_or(-200) };
+        let (tx_ok, rx_ok) = oneshot::channel::<bool>();
+        tx_tid.send((tid, tx_ok)).unwrap();
+        if !rx_ok.recv().unwrap() {
+            if park_on_errors {
+                loop {
+                    thread::park();
+                }
+            } else {
+                panic!(
+                    "THREAD SETUP FAILED FOR `{}`",
+                    thread::current().name().unwrap_or_default()
+                );
             }
-        } else {
-            panic!(
-                "THREAD SETUP FAILED FOR `{}`",
-                thread::current().name().unwrap_or_default()
-            );
         }
     }
+    #[cfg(not(target_os = "linux"))]
+    {
+        panic_os!();
+    }
 }
 
+#[allow(unused_variables)]
 fn thread_init_external(
     rx_tid: oneshot::Receiver<(libc::c_int, oneshot::Sender<bool>)>,
     params: &RTParams,
@@ -527,49 +555,58 @@ fn thread_init_external(
     Ok(tid)
 }
 
+#[allow(unused_variables)]
 fn apply_thread_params(tid: libc::c_int, params: &RTParams, quiet: bool) -> Result<()> {
     if !is_realtime() {
         return Ok(());
     }
-    if !params.cpu_ids.is_empty() {
-        unsafe {
-            let mut cpuset: cpu_set_t = mem::zeroed();
-            for cpu in &params.cpu_ids {
-                libc::CPU_SET(*cpu, &mut cpuset);
+    #[cfg(target_os = "linux")]
+    {
+        if !params.cpu_ids.is_empty() {
+            unsafe {
+                let mut cpuset: cpu_set_t = std::mem::zeroed();
+                for cpu in &params.cpu_ids {
+                    libc::CPU_SET(*cpu, &mut cpuset);
+                }
+                let res =
+                    libc::sched_setaffinity(tid, std::mem::size_of::<libc::cpu_set_t>(), &cpuset);
+                if res != 0 {
+                    if !quiet {
+                        eprintln!(
+                            "Error setting CPU affinity: {}",
+                            std::io::Error::last_os_error()
+                        );
+                    }
+                    return Err(Error::RTSchedSetAffinity(res));
+                }
             }
-            let res = libc::sched_setaffinity(tid, std::mem::size_of::<libc::cpu_set_t>(), &cpuset);
+        }
+        if let Some(priority) = params.priority {
+            let res = unsafe {
+                libc::sched_setscheduler(
+                    tid,
+                    params.scheduling.into(),
+                    &libc::sched_param {
+                        sched_priority: priority,
+                    },
+                )
+            };
             if res != 0 {
                 if !quiet {
                     eprintln!(
-                        "Error setting CPU affinity: {}",
+                        "Error setting scheduler: {}",
                         std::io::Error::last_os_error()
                     );
                 }
-                return Err(Error::RTSchedSetAffinity(res));
+                return Err(Error::RTSchedSetSchduler(res));
             }
         }
+        Ok(())
     }
-    if let Some(priority) = params.priority {
-        let res = unsafe {
-            libc::sched_setscheduler(
-                tid,
-                params.scheduling.into(),
-                &libc::sched_param {
-                    sched_priority: priority,
-                },
-            )
-        };
-        if res != 0 {
-            if !quiet {
-                eprintln!(
-                    "Error setting scheduler: {}",
-                    std::io::Error::last_os_error()
-                );
-            }
-            return Err(Error::RTSchedSetSchduler(res));
-        }
+    #[cfg(not(target_os = "linux"))]
+    {
+        panic_os!();
     }
-    Ok(())
 }
 
 macro_rules! impl_serialize_join_handle {
@@ -597,19 +634,36 @@ pub(crate) fn suicide_myself(delay: Duration, warn: bool) {
         eprintln!("{}", "KILLING THE PROCESS".red().bold());
     }
     kill_pstree(pid as i32, false, None);
+    #[cfg(target_os = "linux")]
     let _ = signal::kill(unistd::Pid::from_raw(pid as i32), signal::Signal::SIGKILL);
+    #[cfg(not(target_os = "linux"))]
+    {
+        panic_os!();
+    }
 }
 
 /// Terminates a process tree with SIGTERM, waits "term_kill_interval" and repeats the opeation
 /// with SIGKILL
 ///
 /// If "term_kill_interval" is not set, SIGKILL is used immediately.
-#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
+#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss, unused_variables)]
 pub fn kill_pstree(pid: i32, kill_parent: bool, term_kill_interval: Option<Duration>) {
-    let mut sys = System::new();
-    sys.refresh_processes();
-    let mut pids = BTreeSet::new();
-    if let Some(delay) = term_kill_interval {
+    #[cfg(target_os = "linux")]
+    {
+        let mut sys = System::new();
+        sys.refresh_processes();
+        let mut pids = BTreeSet::new();
+        if let Some(delay) = term_kill_interval {
+            kill_process_tree(
+                Pid::from_u32(pid as u32),
+                &mut sys,
+                &mut pids,
+                signal::Signal::SIGTERM,
+                kill_parent,
+            );
+            thread::sleep(delay);
+            sys.refresh_processes();
+        }
         kill_process_tree(
             Pid::from_u32(pid as u32),
             &mut sys,
@@ -617,18 +671,14 @@ pub fn kill_pstree(pid: i32, kill_parent: bool, term_kill_interval: Option<Durat
             signal::Signal::SIGTERM,
             kill_parent,
         );
-        thread::sleep(delay);
-        sys.refresh_processes();
     }
-    kill_process_tree(
-        Pid::from_u32(pid as u32),
-        &mut sys,
-        &mut pids,
-        signal::Signal::SIGTERM,
-        kill_parent,
-    );
+    #[cfg(not(target_os = "linux"))]
+    {
+        panic_os!();
+    }
 }
 
+#[cfg(target_os = "linux")]
 fn kill_process_tree(
     pid: Pid,
     sys: &mut sysinfo::System,
@@ -647,6 +697,7 @@ fn kill_process_tree(
     }
 }
 
+#[allow(dead_code)]
 fn get_child_pids_recursive(pid: Pid, sys: &System, to: &mut BTreeSet<Pid>) {
     for (i, p) in sys.processes() {
         if let Some(parent) = p.parent() {