refactor: change message to cli-message

zellij-org · imsnif · Jan 17, 2024 · Dec 3, 2023 · Dec 5, 2023 · Dec 5, 2023
commit 54f75e1874839a22fbcfeb4d6aea5592edf40754
diff --git a/default-plugins/fixture-plugin-for-tests/src/main.rs b/default-plugins/fixture-plugin-for-tests/src/main.rs
@@ -60,7  60,7 @@ impl ZellijPlugin for State {
             EventType::FileSystemCreate,
             EventType::FileSystemUpdate,
             EventType::FileSystemDelete,
-            EventType::Message,
             EventType::CliMessage,
         ]);
     }
 
@@ -283,11  283,11 @@ impl ZellijPlugin for State {
                     self.received_payload = Some(payload.clone());
                 }
             },
-            Event::Message{name, payload, ..} => {
             Event::CliMessage{name, payload, ..} => {
                 if name == "message_name" && payload == &Some("message_payload".to_owned()) {
-                    unblock_pipe_input(name);
                     unblock_cli_pipe_input(name);
                 } else if name == "pipe_output" {
-                    pipe_output(name, "this_is_my_output");
                     cli_pipe_output(name, "this_is_my_output");
                 }
             },
             Event::SystemClipboardFailure => {

diff --git a/zellij-client/src/cli_client.rs b/zellij-client/src/cli_client.rs
@@ -27,7  27,7 @@ pub fn start_cli_client(mut os_input: Box<dyn ClientOsApi>, session_name: &str,
 
     for action in actions {
         match action {
-            Action::Message { name, payload, plugin, args } if payload.is_none() => {
             Action::CliMessage { name, payload, plugin, args } if payload.is_none() => {
                 pipe_client(&mut os_input, name, plugin, args, pane_id);
             },
             action => {
@@ -46,21  46,21 @@ fn pipe_client(os_input: &mut Box<dyn ClientOsApi>, mut pipe_name: Option<String
         let mut buffer = String::new();
         handle.read_line(&mut buffer).unwrap(); // TODO: no unwrap etc.
         if buffer.is_empty() {
-            let msg = ClientToServerMsg::Action(Action::Message{ name: name.clone(), payload: None, args: args.clone(), plugin: plugin.clone() }, pane_id, None);
             let msg = ClientToServerMsg::Action(Action::CliMessage{ name: name.clone(), payload: None, args: args.clone(), plugin: plugin.clone() }, pane_id, None);
             os_input.send_to_server(msg);
             break;
         } else {
-            let msg = ClientToServerMsg::Action(Action::Message{ name: name.clone(), payload: Some(buffer), args: args.clone(), plugin: plugin.clone() }, pane_id, None);
             let msg = ClientToServerMsg::Action(Action::CliMessage{ name: name.clone(), payload: Some(buffer), args: args.clone(), plugin: plugin.clone() }, pane_id, None);
             os_input.send_to_server(msg);
         }
         loop {
             match os_input.recv_from_server() {
-                Some((ServerToClientMsg::UnblockPipeInput(pipe_name), _)) => {
                 Some((ServerToClientMsg::UnblockCliPipeInput(pipe_name), _)) => {
                     if Some(pipe_name) == name {
                         break;
                     }
                 },
-                Some((ServerToClientMsg::PipeOutput(pipe_name, output), _)) => {
                 Some((ServerToClientMsg::CliPipeOutput(pipe_name, output), _)) => {
                     let err_context = "Failed to write to stdout";
                     if Some(pipe_name) == name {
                         let mut stdout = os_input.get_stdout_writer();

diff --git a/zellij-client/src/lib.rs b/zellij-client/src/lib.rs
@@ -49,8  49,8 @@ pub(crate) enum ClientInstruction {
     LogError(Vec<String>),
     SwitchSession(ConnectToSession),
     SetSynchronizedOutput(Option<SyncOutput>),
-    UnblockPipeInput(String), // String -> pipe name
-    PipeOutput(String, String), // String -> pipe name, String -> output
     UnblockCliPipeInput(String), // String -> pipe name
     CliPipeOutput(String, String), // String -> pipe name, String -> output
 }
 
 impl From<ServerToClientMsg> for ClientInstruction {
@@ -69,11  69,11 @@ impl From<ServerToClientMsg> for ClientInstruction {
             ServerToClientMsg::SwitchSession(connect_to_session) => {
                 ClientInstruction::SwitchSession(connect_to_session)
             },
-            ServerToClientMsg::UnblockPipeInput(pipe_name) => {
-                ClientInstruction::UnblockPipeInput(pipe_name)
             ServerToClientMsg::UnblockCliPipeInput(pipe_name) => {
                 ClientInstruction::UnblockCliPipeInput(pipe_name)
             },
-            ServerToClientMsg::PipeOutput(pipe_name, output) => {
-                ClientInstruction::PipeOutput(pipe_name, output)
             ServerToClientMsg::CliPipeOutput(pipe_name, output) => {
                 ClientInstruction::CliPipeOutput(pipe_name, output)
             },
         }
     }
@@ -95,8  95,8 @@ impl From<&ClientInstruction> for ClientContext {
             ClientInstruction::DoneParsingStdinQuery => ClientContext::DoneParsingStdinQuery,
             ClientInstruction::SwitchSession(..) => ClientContext::SwitchSession,
             ClientInstruction::SetSynchronizedOutput(..) => ClientContext::SetSynchronisedOutput,
-            ClientInstruction::UnblockPipeInput(..) => ClientContext::UnblockPipeInput,
-            ClientInstruction::PipeOutput(..) => ClientContext::PipeOutput,
             ClientInstruction::UnblockCliPipeInput(..) => ClientContext::UnblockCliPipeInput,
             ClientInstruction::CliPipeOutput(..) => ClientContext::CliPipeOutput,
         }
     }
 }

diff --git a/zellij-server/src/lib.rs b/zellij-server/src/lib.rs
@@ -86,8  86,8 @@ pub enum ServerInstruction {
     ActiveClients(ClientId),
     Log(Vec<String>, ClientId),
     SwitchSession(ConnectToSession, ClientId),
-    UnblockPipeInput(String), // String -> Pipe name
-    PipeOutput(String, String), // String -> Pipe name, String -> Output
     UnblockCliPipeInput(String), // String -> Pipe name
     CliPipeOutput(String, String), // String -> Pipe name, String -> Output
 }
 
 impl From<&ServerInstruction> for ServerContext {
@@ -106,8  106,8 @@ impl From<&ServerInstruction> for ServerContext {
             ServerInstruction::ActiveClients(_) => ServerContext::ActiveClients,
             ServerInstruction::Log(..) => ServerContext::Log,
             ServerInstruction::SwitchSession(..) => ServerContext::SwitchSession,
-            ServerInstruction::UnblockPipeInput(..) => ServerContext::UnblockPipeInput,
-            ServerInstruction::PipeOutput(..) => ServerContext::PipeOutput,
             ServerInstruction::UnblockCliPipeInput(..) => ServerContext::UnblockCliPipeInput,
             ServerInstruction::CliPipeOutput(..) => ServerContext::CliPipeOutput,
         }
     }
 }
@@ -494,22  494,22 @@ pub fn start_server(mut os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
                     );
                 }
             },
-            ServerInstruction::UnblockPipeInput(pipe_name) => {
             ServerInstruction::UnblockCliPipeInput(pipe_name) => {
                 for client_id in session_state.read().unwrap().clients.keys() {
                     send_to_client!(
                         *client_id,
                         os_input,
-                        ServerToClientMsg::UnblockPipeInput(pipe_name.clone()),
                         ServerToClientMsg::UnblockCliPipeInput(pipe_name.clone()),
                         session_state
                     );
                 }
             },
-            ServerInstruction::PipeOutput(pipe_name, output) => {
             ServerInstruction::CliPipeOutput(pipe_name, output) => {
                 for client_id in session_state.read().unwrap().clients.keys() {
                     send_to_client!(
                         *client_id,
                         os_input,
-                        ServerToClientMsg::PipeOutput(pipe_name.clone(), output.clone()),
                         ServerToClientMsg::CliPipeOutput(pipe_name.clone(), output.clone()),
                         session_state
                     );
                 }

diff --git a/zellij-server/src/plugins/mod.rs b/zellij-server/src/plugins/mod.rs
@@ -100,7  100,7 @@ pub enum PluginInstruction {
     ),
     DumpLayout(SessionLayoutMetadata, ClientId),
     LogLayoutToHd(SessionLayoutMetadata),
-    Message {
     CliMessage {
         name: String,
         payload: Option<String>,
         plugin: Option<String>,
@@ -138,7  138,7 @@ impl From<&PluginInstruction> for PluginContext {
             },
             PluginInstruction::DumpLayout(..) => PluginContext::DumpLayout,
             PluginInstruction::LogLayoutToHd(..) => PluginContext::LogLayoutToHd,
-            PluginInstruction::Message{..} => PluginContext::Message,
             PluginInstruction::CliMessage {..} => PluginContext::CliMessage,
             PluginInstruction::CachePluginEvents{..} => PluginContext::CachePluginEvents,
         }
     }
@@ -409,7  409,7 @@ pub(crate) fn plugin_thread_main(
                         .send_to_pty(PtyInstruction::LogLayoutToHd(session_layout_metadata)),
                 );
             },
-            PluginInstruction::Message{name, payload, plugin, args} => { // TODO: remove client_id,
             PluginInstruction::CliMessage {name, payload, plugin, args} => { // TODO: remove client_id,
                                                                       // it's from the cli
                 // TODO CONTINUE HERE(18/12):
                 // * make plugin pretty and make POC with pausing and filtering - DONE
@@ -426,6  426,10 @@ pub(crate) fn plugin_thread_main(
                 //  - test that we're not losing messages when we already have permission - DONE
                 //  - same plugin 2 different places in path (with/without permissions) - DONE
                 // * allow plugins to send/pipe messages to each other
                 //  - change Message (all the way) to CliMessage (also the unblock and pipeoutput
                 //  methods' names should reflect this change)
                 //  - create a send_message plugin api that would act like Message but without
                 //  backpressure
                 // * work on cli error messages, must be clearer
 
                 // TODO:
@@ -485,7  489,7 @@ pub(crate) fn plugin_thread_main(
                                 };
 
                                 for (plugin_id, client_id) in all_plugin_ids {
-                                    updates.push((Some(plugin_id), Some(client_id), Event::Message {name: name.clone(), payload: payload.clone(), args: args.clone() }));
                                     updates.push((Some(plugin_id), Some(client_id), Event::CliMessage {name: name.clone(), payload: payload.clone(), args: args.clone() }));
                                 }
                             },
                             Err(e) => {
@@ -498,7  502,7 @@ pub(crate) fn plugin_thread_main(
                         // send to all plugins
                         let all_plugin_ids = wasm_bridge.all_plugin_ids();
                         for (plugin_id, client_id) in all_plugin_ids {
-                            updates.push((Some(plugin_id), Some(client_id), Event::Message{ name: name.clone(), payload: payload.clone(), args: args.clone()}));
                             updates.push((Some(plugin_id), Some(client_id), Event::CliMessage{ name: name.clone(), payload: payload.clone(), args: args.clone()}));
                         }
                     }
                 }

diff --git a/zellij-server/src/plugins/wasm_bridge.rs b/zellij-server/src/plugins/wasm_bridge.rs
@@ -886,7  886,7 @@ fn check_event_permission(
         | Event::CopyToClipboard(..)
         | Event::SystemClipboardFailure
         | Event::InputReceived => PermissionType::ReadApplicationState,
-        Event::Message {..} => PermissionType::ReadCliMessages,
         Event::CliMessage {..} => PermissionType::ReadCliMessages,
         _ => return (PermissionStatus::Granted, None),
     };
 

diff --git a/zellij-server/src/plugins/zellij_exports.rs b/zellij-server/src/plugins/zellij_exports.rs
@@ -240,11  240,11 @@ fn host_run_plugin_command(env: FunctionEnvMut<ForeignFunctionEnv>) {
                     PluginCommand::RenameSession(new_session_name) => {
                         rename_session(env, new_session_name)
                     },
-                    PluginCommand::UnblockPipeInput(pipe_name) => {
-                        unblock_pipe_input(env, pipe_name)?
                     PluginCommand::UnblockCliPipeInput(pipe_name) => {
                         unblock_cli_pipe_input(env, pipe_name)?
                     },
-                    PluginCommand::PipeOutput(pipe_name, output) => {
-                        pipe_output(env, pipe_name, output)?
                     PluginCommand::CliPipeOutput(pipe_name, output) => {
                         cli_pipe_output(env, pipe_name, output)?
                     },
                 },
                 (PermissionStatus::Denied, permission) => {
@@ -278,15  278,15 @@ fn subscribe(env: &ForeignFunctionEnv, event_list: HashSet<EventType>) -> Result
         ))
 }
 
-fn unblock_pipe_input(env: &ForeignFunctionEnv, pipe_name: String) -> Result<()> {
 fn unblock_cli_pipe_input(env: &ForeignFunctionEnv, pipe_name: String) -> Result<()> {
     env.plugin_env.input_pipes_to_unblock.lock().unwrap().insert(pipe_name);
     Ok(()) // TODO: no result return
 }
 
-fn pipe_output(env: &ForeignFunctionEnv, pipe_name: String, output: String) -> Result<()> {
 fn cli_pipe_output(env: &ForeignFunctionEnv, pipe_name: String, output: String) -> Result<()> {
     env.plugin_env
         .senders
-        .send_to_server(ServerInstruction::PipeOutput(pipe_name, output))
         .send_to_server(ServerInstruction::CliPipeOutput(pipe_name, output))
         .context("failed to send pipe output")
 }
 
@@ -1379,8  1379,8 @@ fn check_command_permission(
         | PluginCommand::DeleteAllDeadSessions
         | PluginCommand::RenameSession(..)
         | PluginCommand::RenameTab(..) => PermissionType::ChangeApplicationState,
-        PluginCommand::UnblockPipeInput(..)
-        | PluginCommand::PipeOutput(..) => PermissionType::ReadCliMessages,
         PluginCommand::UnblockCliPipeInput(..)
         | PluginCommand::CliPipeOutput(..) => PermissionType::ReadCliMessages,
         _ => return (PermissionStatus::Granted, None),
     };
 

diff --git a/zellij-server/src/route.rs b/zellij-server/src/route.rs
@@ -803,10  803,10 @@ pub(crate) fn route_action(
                 .send_to_screen(ScreenInstruction::RenameSession(name, client_id))
                 .with_context(err_context)?;
         },
-        Action::Message{ mut name, payload, plugin, args } => {
         Action::CliMessage{ mut name, payload, plugin, args } => {
             if let Some(name) = name.take() {
                 senders
-                    .send_to_plugin(PluginInstruction::Message{ name, payload, plugin, args})
                     .send_to_plugin(PluginInstruction::CliMessage { name, payload, plugin, args})
                     .with_context(err_context)?;
             } else {
                 log::error!("Message must have a name");

diff --git a/zellij-server/src/screen.rs b/zellij-server/src/screen.rs
@@ -2174,7  2174,7 @@ pub(crate) fn screen_thread_main(
                     for pipe_name in input_pipes_to_unblock {
                         screen.bus
                             .senders
-                            .send_to_server(ServerInstruction::UnblockPipeInput(pipe_name))
                             .send_to_server(ServerInstruction::UnblockCliPipeInput(pipe_name))
                             .context("failed to unblock input pipe");
                         }
                     }

diff --git a/zellij-tile/src/shim.rs b/zellij-tile/src/shim.rs
@@ -695,16  695,16 @@ pub fn rename_session(name: &str) {
 }
 
 /// Unblock the input side of a pipe, requesting the next message be sent if there is one
-pub fn unblock_pipe_input(pipe_name: &str) {
-    let plugin_command = PluginCommand::UnblockPipeInput(pipe_name.to_owned());
 pub fn unblock_cli_pipe_input(pipe_name: &str) {
     let plugin_command = PluginCommand::UnblockCliPipeInput(pipe_name.to_owned());
     let protobuf_plugin_command: ProtobufPluginCommand = plugin_command.try_into().unwrap();
     object_to_stdout(&protobuf_plugin_command.encode_to_vec());
     unsafe { host_run_plugin_command() };
 }
 
 /// Send output to the output side of a pipe, ths does not affect the input side of same pipe
-pub fn pipe_output(pipe_name: &str, output: &str) {
-    let plugin_command = PluginCommand::PipeOutput(pipe_name.to_owned(), output.to_owned());
 pub fn cli_pipe_output(pipe_name: &str, output: &str) {
     let plugin_command = PluginCommand::CliPipeOutput(pipe_name.to_owned(), output.to_owned());
     let protobuf_plugin_command: ProtobufPluginCommand = plugin_command.try_into().unwrap();
     object_to_stdout(&protobuf_plugin_command.encode_to_vec());
     unsafe { host_run_plugin_command() };

diff --git a/zellij-utils/assets/prost/api.action.rs b/zellij-utils/assets/prost/api.action.rs
@@ -105,12  105,12 @@ pub mod action {
         #[prost(message, tag = "46")]
         LaunchPluginPayload(super::LaunchOrFocusPluginPayload),
         #[prost(message, tag = "47")]
-        MessagePayload(super::MessagePayload),
         MessagePayload(super::CliMessagePayload),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MessagePayload {
 pub struct CliMessagePayload {
     #[prost(string, optional, tag = "1")]
     pub name: ::core::option::Option<::prost::alloc::string::String>,
     #[prost(string, tag = "2")]
@@ -424,7  424,7 @@ pub enum ActionName {
     BreakPaneLeft = 79,
     RenameSession = 80,
     LaunchPlugin = 81,
-    Message = 82,
     CliMessage = 82,
 }
 impl ActionName {
     /// String value of the enum field names used in the ProtoBuf definition.
@@ -515,7  515,7 @@ impl ActionName {
             ActionName::BreakPaneLeft => "BreakPaneLeft",
             ActionName::RenameSession => "RenameSession",
             ActionName::LaunchPlugin => "LaunchPlugin",
-            ActionName::Message => "Message",
             ActionName::CliMessage => "CliMessage",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -603,7  603,7 @@ impl ActionName {
             "BreakPaneLeft" => Some(Self::BreakPaneLeft),
             "RenameSession" => Some(Self::RenameSession),
             "LaunchPlugin" => Some(Self::LaunchPlugin),
-            "Message" => Some(Self::Message),
             "CliMessage" => Some(Self::CliMessage),
             _ => None,
         }
     }

diff --git a/zellij-utils/assets/prost/api.event.rs b/zellij-utils/assets/prost/api.event.rs
@@ -49,7  49,7 @@ pub mod event {
         #[prost(message, tag = "15")]
         WebRequestResultPayload(super::WebRequestResultPayload),
         #[prost(message, tag = "16")]
-        MessagePayload(super::MessagePayload),
         CliMessagePayload(super::CliMessagePayload),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -122,7  122,7 @@ pub struct CustomMessagePayload {
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MessagePayload {
 pub struct CliMessagePayload {
     #[prost(string, tag = "1")]
     pub name: ::prost::alloc::string::String,
     #[prost(string, optional, tag = "2")]
@@ -332,7  332,7 @@ pub enum EventType {
     SessionUpdate = 16,
     RunCommandResult = 17,
     WebRequestResult = 18,
-    Message = 19,
     CliMessage = 19,
 }
 impl EventType {
     /// String value of the enum field names used in the ProtoBuf definition.
@@ -360,7  360,7 @@ impl EventType {
             EventType::SessionUpdate => "SessionUpdate",
             EventType::RunCommandResult => "RunCommandResult",
             EventType::WebRequestResult => "WebRequestResult",
-            EventType::Message => "Message",
             EventType::CliMessage => "CliMessage",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -385,7  385,7 @@ impl EventType {
             "SessionUpdate" => Some(Self::SessionUpdate),
             "RunCommandResult" => Some(Self::RunCommandResult),
             "WebRequestResult" => Some(Self::WebRequestResult),
-            "Message" => Some(Self::Message),
             "CliMessage" => Some(Self::CliMessage),
             _ => None,
         }
     }