use alloc and core libs instead of std whenever possible

Author: ShoroukRamzy

BUILD

@@ -23,6 +23,7 @@ setup_starpls(
 copyright_checker(
     name = "copyright",
     srcs = [
+        "src",
         "tests",
         "//:BUILD",
         "//:MODULE.bazel",

examples/rust/mini-adas/Cargo.toml

@@ -33,7 +33,7 @@ com_iox2 = ["feo-com/ipc_iceoryx2"]
 com_linux_shm = ["feo-com/ipc_linux_shm"]
 default = ["com_iox2", "signalling_relayed_tcp"]
 signalling_direct_mpsc = []
-signalling_direct_tcp = ["com_iox2"]
+signalling_direct_tcp = []
 signalling_direct_unix = []
 signalling_relayed_tcp = []
 signalling_relayed_unix = []

feo/src/agent/direct/primary.rs

@@ -30,10 +30,6 @@ use core::sync::atomic::AtomicBool;
 use core::time::Duration;
 use feo_log::info;
 use std::collections::HashMap;
-<<<<<<< HEAD
-=======
-use std::sync::{atomic::AtomicBool, Arc};
->>>>>>> 999c8dd (ctrlc is not built after rebasing)
 use std::thread::{self, JoinHandle};
 
 /// Configuration of the primary agent
@@ -75,10 +71,7 @@ impl Primary {
             recorder_ids,
             endpoint,
             timeout,
-<<<<<<< HEAD
             connection_timeout,
-=======
->>>>>>> 999c8dd (ctrlc is not built after rebasing)
             activity_agent_map,
             ..
         } = config;

feo/src/scheduler.rs

@@ -390,7 +390,13 @@ impl Scheduler {
                     }
                     break id;
                 }
-                Some(Signal::TerminateAck(_)) => continue, // Ignore during normal operation
+                Some(Signal::TerminateAck(agent_id)) => {
+                    trace!(
+                        "Ignoring TerminateAck from agent {} during normal operation",
+                        agent_id
+                    );
+                    continue;
+                }
                 Some(other) => {
                     error!("Received unexpected signal {other:?} while waiting for ready signal");
                 }

feo/src/signalling/direct/scheduler.rs

@@ -135,7 +135,6 @@ where
         let start_time = Instant::now();
 
         while !missing_activities.is_empty() || !missing_recorders.is_empty() {
-<<<<<<< HEAD
             let elapsed = start_time.elapsed();
             if elapsed >= self.connection_timeout {
                 return Err(Error::Io((
@@ -147,11 +146,6 @@ where
             // Wait for a new connection, but no longer than the remaining overall timeout.
             if let Ok(Some((token, signal))) =
                 self.server.receive(&mut self.events, remaining_timeout)
-=======
-            if let Ok(Some((token, signal))) = self
-                .server
-                .receive(&mut self.events, Duration::from_secs(1))
->>>>>>> 999c8dd (ctrlc is not built after rebasing)
             {
                 match signal {
                     ProtocolSignal::ActivityHello(activity_id) => {

feo/src/signalling/relayed/connectors/relays.rs

@@ -53,12 +53,8 @@ impl<Inter: IsChannel, Intra: IsChannel> PrimaryReceiveRelay<Inter, Intra> {
         let inter_receiver_builder = self.inter_receiver_builder.take().unwrap();
         let intra_sender_builder = self.intra_sender_builder.take().unwrap();
         let timeout = self.timeout;
-<<<<<<< HEAD
 
         thread::spawn(move || {
-=======
-        let thread = thread::spawn(move || {
->>>>>>> 999c8dd (ctrlc is not built after rebasing)
             if let Err(e) = Self::thread_main(inter_receiver_builder, intra_sender_builder, timeout)
             {
                 // This error is expected during shutdown when the scheduler drops its receiver.
@@ -140,48 +136,6 @@ impl<Inter: IsChannel, Intra: IsChannel> PrimaryReceiveRelay<Inter, Intra> {
         trace!("PrimaryReceiveRelay connected");
         Ok((inter_receiver, intra_sender))
     }
-<<<<<<< HEAD
-=======
-
-    pub fn connect(&mut self) -> Result<(), Error> {
-        self.inter_sender.connect_receivers(self.timeout)?;
-        trace!("PrimarySendRelay connected");
-        Ok(())
-    }
-
-    pub fn get_remote_agents(&self) -> impl Iterator<Item = AgentId> + '_ {
-        self.remote_agents.iter().copied()
-    }
-
-    pub fn send_to_agent(
-        &mut self,
-        agent_id: AgentId,
-        signal: Inter::ProtocolSignal,
-    ) -> Result<(), Error> {
-        let channel_id = ChannelId::Agent(agent_id);
-        self.inter_sender.send(channel_id, signal)
-    }
-
-    pub fn sync_time(&mut self) -> Result<(), Error> {
-        let signal = Signal::StartupSync(sync_info());
-
-        // Send sync info to all remote agents
-        for id in self.remote_agents.iter() {
-            let channel_id = ChannelId::Agent(*id);
-            self.inter_sender.send(channel_id, signal.into())?;
-        }
-        Ok(())
-    }
-
-    pub fn broadcast(&mut self, signal: Inter::ProtocolSignal) -> Result<(), Error> {
-        // Send signal to all remote agents
-        for id in self.remote_agents.iter() {
-            let channel_id = ChannelId::Agent(*id);
-            self.inter_sender.send(channel_id, signal)?;
-        }
-        Ok(())
-    }
->>>>>>> 999c8dd (ctrlc is not built after rebasing)
 }
 
 /// Relay for a secondary to receive signals from the primary agent

feo/src/signalling/relayed/connectors/scheduler.rs

@@ -21,17 +21,10 @@ use crate::signalling::relayed::connectors::relays::{PrimaryReceiveRelay, Primar
 use crate::signalling::relayed::interface::{
     Builder, IsChannel, ProtocolMultiRecv, ProtocolMultiSend,
 };
-<<<<<<< HEAD
 use alloc::{collections::BTreeSet, vec::Vec};
 use core::time::Duration;
 use feo_log::debug;
 use std::collections::{HashMap, HashSet};
-=======
-use alloc::vec::Vec;
-use core::time::Duration;
-use feo_log::debug;
-use std::collections::{BTreeSet, HashMap, HashSet};
->>>>>>> 999c8dd (ctrlc is not built after rebasing)
 use std::thread::JoinHandle;
 
 pub(crate) struct SchedulerConnector<Inter: IsChannel, Intra: IsChannel> {