pogmommy/zellij
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(ux): reload config at runtime (#3558)

Browse source 
* feat(ux): reload config at runtime

* style(fmt): rustfmt
This commit is contained in:
Aram Drevekenin 2024-08-19 19:02:52 +02:00 • committed by GitHub
parent d76c4e5e49
commit cfbc0ff490
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
3 changed files with 107 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
zellij-client/src/lib.rs
View file

@ -12,12 +12,14 @@ use log::info;
use std::env::current_exe;
use std::io::{self, Write};
use std::path::Path;
use std::path::PathBuf;
use std::process::Command;
use std::sync::{Arc, Mutex};
use std::thread;
use zellij_utils::errors::FatalError;
use zellij_utils::notify_debouncer_full::notify::{self, Event, RecursiveMode, Watcher};
use zellij_utils::setup::Setup;
use crate::stdin_ansi_parser::{AnsiStdinInstruction, StdinAnsiParser, SyncOutput};
use crate::{
command_is_executing::CommandIsExecuting, input_handler::input_loop,
@ -357,7 +359,13 @@ pub fn start_client(
.name("signal_listener".to_string())
.spawn({
let os_input = os_input.clone();
let opts = opts.clone();
move || {
// we keep the config_file_watcher here so that it is only dropped when this thread
// exits (which is when the client disconnects/detaches), once it's dropped it
// stops watching and we want it to keep watching the config file path for changes
// as long as the client is alive
let _config_file_watcher = report_changes_in_config_file(&opts, &os_input);
os_input.handle_signals(
Box::new({
let os_api = os_input.clone();
@ -660,3 +668,57 @@ pub fn start_server_detached(
os_input.connect_to_server(&*ipc_pipe);
os_input.send_to_server(first_msg);
}
fn report_changes_in_config_file(
opts: &CliArgs,
os_input: &Box<dyn ClientOsApi>,
) -> Option<Box<dyn Watcher>> {
match Config::config_file_path(&opts) {
Some(config_file_path) => {
let mut watcher = notify::recommended_watcher({
let os_input = os_input.clone();
let opts = opts.clone();
let config_file_path = config_file_path.clone();
move |res: Result<Event, _>| match res {
Ok(event)
if (event.kind.is_create() || event.kind.is_modify())
&& event.paths.contains(&config_file_path) =>
{
match Setup::from_cli_args(&opts) {
Ok((
new_config,
_layout,
_config_options,
_config_without_layout,
_config_options_without_layout,
)) => {
os_input.send_to_server(ClientToServerMsg::ConfigWrittenToDisk(
new_config,
));
},
Err(e) => {
log::error!("Failed to reload config: {}", e);
},
}
},
Err(e) => log::error!("watch error: {:?}", e),
_ => {},
}
})
.unwrap();
if let Some(config_file_parent_folder) = config_file_path.parent() {
watcher
.watch(&config_file_parent_folder, RecursiveMode::Recursive)
.unwrap();
Some(Box::new(watcher))
} else {
log::error!("Could not find config parent folder");
None
}
},
None => {
log::error!("Failed to find config path");
None
},
}
}

75
zellij-server/src/lib.rs
View file

@ -157,24 +157,29 @@ impl ErrorInstruction for ServerInstruction {
#[derive(Debug, Clone, Default)]
pub(crate) struct SessionConfiguration {
runtime_config: HashMap<ClientId, Config>, // if present, overrides the saved_config
saved_config: HashMap<ClientId, Config>, // config guaranteed to have been saved to disk
saved_config: HashMap<ClientId, Config>, // the config as it is on disk (not guaranteed),
// when changed, this resets the runtime config to
// be identical to it and override any previous
// changes
}
impl SessionConfiguration {
pub fn new_saved_config(&mut self, client_id: ClientId, mut new_saved_config: Config) {
pub fn new_saved_config(
&mut self,
client_id: ClientId,
new_saved_config: Config,
) -> Vec<(ClientId, Config)> {
self.saved_config
.insert(client_id, new_saved_config.clone());
if let Some(runtime_config) = self.runtime_config.get_mut(&client_id) {
match new_saved_config.merge(runtime_config.clone()) {
Ok(_) => {
*runtime_config = new_saved_config;
},
Err(e) => {
log::error!("Failed to update runtime config: {}", e);
},
let mut config_changes = vec![];
for (client_id, current_runtime_config) in self.runtime_config.iter_mut() {
if *current_runtime_config != new_saved_config {
*current_runtime_config = new_saved_config.clone();
config_changes.push((*client_id, new_saved_config.clone()))
}
}
// TODO: handle change by propagating to all the relevant places
config_changes
}
pub fn set_client_saved_configuration(&mut self, client_id: ClientId, client_config: Config) {
self.saved_config.insert(client_id, client_config);
@ -255,6 +260,24 @@ impl SessionMetaData {
self.current_input_modes.insert(client_id, input_mode);
}
}
pub fn propagate_configuration_changes(&mut self, config_changes: Vec<(ClientId, Config)>) {
for (client_id, new_config) in config_changes {
self.senders
.send_to_screen(ScreenInstruction::Reconfigure {
client_id,
keybinds: Some(new_config.keybinds.clone()),
default_mode: new_config.options.default_mode,
})
.unwrap();
self.senders
.send_to_plugin(PluginInstruction::Reconfigure {
client_id,
keybinds: Some(new_config.keybinds),
default_mode: new_config.options.default_mode,
})
.unwrap();
}
}
}
impl Drop for SessionMetaData {
@ -1032,38 +1055,26 @@ pub fn start_server(mut os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
session_data
.write()
.unwrap()
.as_ref()
.as_mut()
.unwrap()
.senders
.send_to_screen(ScreenInstruction::Reconfigure {
client_id,
keybinds: Some(new_config.keybinds.clone()),
default_mode: new_config.options.default_mode,
})
.unwrap();
session_data
.write()
.unwrap()
.as_ref()
.unwrap()
.senders
.send_to_plugin(PluginInstruction::Reconfigure {
client_id,
keybinds: Some(new_config.keybinds),
default_mode: new_config.options.default_mode,
})
.unwrap();
.propagate_configuration_changes(vec![(client_id, new_config)]);
}
}
},
ServerInstruction::ConfigWrittenToDisk(client_id, new_config) => {
session_data
let changes = session_data
.write()
.unwrap()
.as_mut()
.unwrap()
.session_configuration
.new_saved_config(client_id, new_config);
session_data
.write()
.unwrap()
.as_mut()
.unwrap()
.propagate_configuration_changes(changes);
},
ServerInstruction::FailedToWriteConfigToDisk(client_id, file_path) => {
session_data

2
zellij-utils/src/input/config.rs
View file

@ -234,7 +234,7 @@ impl Config {
self.env = self.env.merge(other.env);
Ok(())
}
fn config_file_path(opts: &CliArgs) -> Option<PathBuf> {
pub fn config_file_path(opts: &CliArgs) -> Option<PathBuf> {
opts.config_dir
.clone()
.or_else(home::find_default_config_dir)