rename ExecCommand to Edge

Author: squell

src/exec/use_pty/backchannel.rs

@@ -199,31 +199,31 @@ impl AsFd for ParentBackchannel {
 /// Different messages exchanged between the monitor and the parent process using a [`ParentBackchannel`].
 #[derive(PartialEq, Eq)]
 pub(super) enum MonitorMessage {
-    ExecCommand,
+    Edge,
     Signal(c_int),
 }
 
 impl MonitorMessage {
     const LEN: usize = PREFIX_LEN + MONITOR_DATA_LEN;
-    const EXEC_CMD: Prefix = 0;
+    const EDGE_CMD: Prefix = 0;
     const SIGNAL: Prefix = 1;
 
     fn from_parts(prefix: Prefix, data: MonitorData) -> Self {
         match prefix {
-            Self::EXEC_CMD => Self::ExecCommand,
+            Self::EDGE_CMD => Self::Edge,
             Self::SIGNAL => Self::Signal(data),
             _ => unreachable!(),
         }
     }
 
     fn to_parts(&self) -> (Prefix, MonitorData) {
         let prefix = match self {
-            MonitorMessage::ExecCommand => Self::EXEC_CMD,
+            MonitorMessage::Edge => Self::EDGE_CMD,
             MonitorMessage::Signal(_) => Self::SIGNAL,
         };
 
         let data = match self {
-            MonitorMessage::ExecCommand => 0,
+            MonitorMessage::Edge => 0,
             MonitorMessage::Signal(data) => *data,
         };
 
@@ -234,7 +234,7 @@ impl MonitorMessage {
 impl std::fmt::Debug for MonitorMessage {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::ExecCommand => "ExecCommand".fmt(f),
+            Self::Edge => "Edge".fmt(f),
             &Self::Signal(signal) => write!(f, "Signal({})", signal_fmt(signal)),
         }
     }

src/exec/use_pty/monitor.rs

@@ -80,8 +80,8 @@ pub(super) fn exec_monitor(
         err
     })?;
     // Given that `UnixStream` delivers messages in order it shouldn't be possible to
-    // receive an event different to `ExecCommand` at the beginning.
-    debug_assert_eq!(event, MonitorMessage::ExecCommand);
+    // receive an event different to `Edge` at the beginning.
+    debug_assert_eq!(event, MonitorMessage::Edge);
 
     // FIXME (ogsudo): Some extra config happens here if selinux is available.
 
@@ -188,7 +188,7 @@ pub(super) fn exec_monitor(
         dev_warn!("cannot receive red light from parent: {err}");
         err
     })?;
-    debug_assert_eq!(event, MonitorMessage::ExecCommand);
+    debug_assert_eq!(event, MonitorMessage::Edge);
 
     // FIXME (ogsudo): The tty is restored here if selinux is available.
 
@@ -332,8 +332,8 @@ impl<'a> MonitorClosure<'a> {
             }
             Ok(event) => {
                 match event {
-                    // We shouldn't receive this event more than once.
-                    MonitorMessage::ExecCommand => unreachable!(),
+                    // We shouldn't receive this event at this point in the protocol
+                    MonitorMessage::Edge => unreachable!(),
                     // Forward signal to the command.
                     MonitorMessage::Signal(signal) => {
                         if let Some(command_pid) = self.command_pid {

src/exec/use_pty/parent.rs

@@ -211,12 +211,10 @@ pub(in crate::exec) fn exec_pty(
     drop(backchannels.monitor);
 
     // Send green light to the monitor after closing the follower.
-    retry_while_interrupted(|| backchannels.parent.send(&MonitorMessage::ExecCommand)).map_err(
-        |err| {
-            dev_error!("cannot send green light to monitor: {err}");
-            err
-        },
-    )?;
+    retry_while_interrupted(|| backchannels.parent.send(&MonitorMessage::Edge)).map_err(|err| {
+        dev_error!("cannot send green light to monitor: {err}");
+        err
+    })?;
 
     let mut closure = ParentClosure::new(
         monitor_pid,
@@ -358,7 +356,7 @@ impl ParentClosure {
             StopReason::Exit(ParentExit::Command(exit_reason)) => Ok(exit_reason),
         };
         // Send red light to the monitor after processing all events
-        retry_while_interrupted(|| self.backchannel.send(&MonitorMessage::ExecCommand)).map_err(
+        retry_while_interrupted(|| self.backchannel.send(&MonitorMessage::Edge)).map_err(
             |err| {
                 dev_error!("cannot send red light to monitor: {err}");
                 err