From 40b19c5e67b05216fdf60ad4ad1b1c2553d8308a Mon Sep 17 00:00:00 2001 From: J H <2364004+Blu-J@users.noreply.github.com> Date: Wed, 8 Nov 2023 15:35:08 -0700 Subject: [PATCH] chore: Remove the long running from the docker --- backend/src/manager/manager_container.rs | 30 ++---- backend/src/manager/mod.rs | 100 +++++++------------- backend/src/manager/persistent_container.rs | 8 +- backend/src/procedure/mod.rs | 2 +- 4 files changed, 44 insertions(+), 96 deletions(-) diff --git a/backend/src/manager/manager_container.rs b/backend/src/manager/manager_container.rs index 32e11c2e5..ba13a652d 100644 --- a/backend/src/manager/manager_container.rs +++ b/backend/src/manager/manager_container.rs @@ -138,7 +138,7 @@ async fn create_service_manager( desired_state: Arc>, seed: Arc, current_state: Arc>, - persistent_container: Arc>, + persistent_container: Arc, ) { let mut desired_state_receiver = desired_state.subscribe(); let mut running_service: Option> = None; @@ -149,23 +149,12 @@ async fn create_service_manager( match (current, desired) { (StartStop::Start, StartStop::Start) => (), (StartStop::Start, StartStop::Stop) => { - if persistent_container.is_none() { - if let Err(err) = seed.stop_container().await { - tracing::error!("Could not stop container"); - tracing::debug!("{:?}", err) - } - running_service = None; - } else if let Some(current_service) = running_service.take() { - tokio::select! { - _ = current_service => (), - _ = tokio::time::sleep(Duration::from_secs_f64(seed.manifest - .containers - .as_ref() - .and_then(|c| c.main.sigterm_timeout).map(|x| x.as_secs_f64()).unwrap_or_default())) => { - tracing::error!("Could not stop service"); - } - } + if let Err(err) = seed.stop_container().await { + tracing::error!("Could not stop container"); + tracing::debug!("{:?}", err) } + running_service = None; + current_state.send_modify(|x| *x = StartStop::Stop); } (StartStop::Stop, StartStop::Start) => starting_service( @@ -243,12 +232,7 @@ fn starting_service( let set_stopped = { move || current_state.send_modify(|x| *x = StartStop::Stop) }; let running_main_loop = async move { while desired_state.borrow().is_start() { - let result = run_main( - seed.clone(), - persistent_container.clone(), - set_running.clone(), - ) - .await; + let result = run_main(seed.clone()).await; set_stopped(); run_main_log_result(result, seed.clone()).await; } diff --git a/backend/src/manager/mod.rs b/backend/src/manager/mod.rs index cf4457b9f..b34e29efb 100644 --- a/backend/src/manager/mod.rs +++ b/backend/src/manager/mod.rs @@ -40,7 +40,7 @@ use crate::procedure::docker::{DockerContainer, DockerProcedure, LongRunning}; use crate::procedure::{NoOutput, ProcedureName}; use crate::s9pk::manifest::Manifest; use crate::status::MainStatus; -use crate::util::docker::{get_container_ip, kill_container}; +use crate::util::docker::get_container_ip; use crate::util::NonDetachingJoinHandle; use crate::volume::Volume; use crate::Error; @@ -61,7 +61,7 @@ use self::manager_seed::ManagerSeed; pub const HEALTH_CHECK_COOLDOWN_SECONDS: u64 = 15; pub const HEALTH_CHECK_GRACE_PERIOD_SECONDS: u64 = 5; -type ManagerPersistentContainer = Arc>; +type ManagerPersistentContainer = Arc; type BackupGuard = Arc>>; pub enum BackupReturn { Error(Error), @@ -221,10 +221,8 @@ impl Manager { } /// Used as a getter, but also used in procedure - pub fn rpc_client(&self) -> Option> { - (*self.persistent_container) - .as_ref() - .map(|x| x.rpc_client()) + pub fn rpc_client(&self) -> Arc { + self.persistent_container.rpc_client() } async fn _transition_abort(&self) { @@ -428,7 +426,7 @@ async fn configure( if !configure_context.dry_run { // run config action let res = action - .set(ctx, id, version, &dependencies, volumes, &config) + .set(ctx, id, version, dependencies, volumes, &config) .await?; // track dependencies with no pointers @@ -462,7 +460,7 @@ async fn configure( } let dependency_config_errs = - compute_dependency_config_errs(&ctx, &db, &manifest, ¤t_dependencies, overrides) + compute_dependency_config_errs(ctx, &db, &manifest, ¤t_dependencies, overrides) .await?; // cache current config for dependents @@ -650,37 +648,14 @@ pub enum OnStop { type RunMainResult = Result, Error>; #[instrument(skip_all)] -async fn run_main( - seed: Arc, - persistent_container: ManagerPersistentContainer, - started: Arc, -) -> RunMainResult { - let mut runtime = NonDetachingJoinHandle::from(tokio::spawn(start_up_image(seed.clone()))); - let ip = match persistent_container.is_some() { - false => Some(match get_running_ip(&seed, &mut runtime).await { - GetRunningIp::Ip(x) => x, - GetRunningIp::Error(e) => return Err(e), - GetRunningIp::EarlyExit(x) => return Ok(x), - }), - true => None, - }; - - let svc = if let Some(ip) = ip { - let net = add_network_for_main(&seed, ip).await?; - started(); - Some(net) - } else { - None - }; +async fn run_main(seed: Arc) -> RunMainResult { + let runtime = NonDetachingJoinHandle::from(tokio::spawn(start_up_image(seed.clone()))); let health = main_health_check_daemon(seed.clone()); let res = tokio::select! { a = runtime => a.map_err(|_| Error::new(eyre!("Manager runtime panicked!"), crate::ErrorKind::Docker)).and_then(|a| a), _ = health => Err(Error::new(eyre!("Health check daemon exited!"), crate::ErrorKind::Unknown)) }; - if let Some(svc) = svc { - remove_network_for_main(svc).await?; - } res } @@ -847,41 +822,30 @@ async fn send_signal(manager: &Manager, gid: Arc, signal: Signal) -> Result // .commit_health_check_results // .store(false, Ordering::SeqCst); - if let Some(rpc_client) = manager.rpc_client() { - let main_gid = *gid.main_gid.0.borrow(); - let next_gid = gid.new_gid(); - #[cfg(feature = "js_engine")] - if let Err(e) = crate::procedure::js_scripts::JsProcedure::default() - .execute::<_, NoOutput>( - &manager.seed.ctx.datadir, - &manager.seed.manifest.id, - &manager.seed.manifest.version, - ProcedureName::Signal, - &manager.seed.manifest.volumes, - Some(embassy_container_init::SignalGroupParams { - gid: main_gid, - signal: signal as u32, - }), - None, // TODO - next_gid, - Some(rpc_client), - ) - .await? - { - tracing::error!("Failed to send js signal: {}", e.1); - tracing::debug!("{:?}", e); - } - } else { - // send signal to container - kill_container(&manager.seed.container_name, Some(signal)) - .await - .or_else(|e| { - if e.kind == ErrorKind::NotFound { - Ok(()) - } else { - Err(e) - } - })?; + let rpc_client = manager.rpc_client(); + + let main_gid = *gid.main_gid.0.borrow(); + let next_gid = gid.new_gid(); + #[cfg(feature = "js_engine")] + if let Err(e) = crate::procedure::js_scripts::JsProcedure::default() + .execute::<_, NoOutput>( + &manager.seed.ctx.datadir, + &manager.seed.manifest.id, + &manager.seed.manifest.version, + ProcedureName::Signal, + &manager.seed.manifest.volumes, + Some(embassy_container_init::SignalGroupParams { + gid: main_gid, + signal: signal as u32, + }), + None, // TODO + next_gid, + Some(rpc_client), + ) + .await? + { + tracing::error!("Failed to send js signal: {}", e.1); + tracing::debug!("{:?}", e); } Ok(()) diff --git a/backend/src/manager/persistent_container.rs b/backend/src/manager/persistent_container.rs index d9868a622..da51f6ea0 100644 --- a/backend/src/manager/persistent_container.rs +++ b/backend/src/manager/persistent_container.rs @@ -25,16 +25,16 @@ pub struct PersistentContainer { impl PersistentContainer { #[instrument(skip_all)] - pub async fn init(seed: &Arc) -> Result, Error> { + pub async fn init(seed: &Arc) -> Result { Ok(if let Some(containers) = &seed.manifest.containers { let (running_docker, rpc_client) = spawn_persistent_container(seed.clone(), containers.main.clone()).await?; - Some(Self { + Self { _running_docker: running_docker, rpc_client, - }) + } } else { - None + todo!("No containers in manifest") }) } diff --git a/backend/src/procedure/mod.rs b/backend/src/procedure/mod.rs index 62f4de9cf..02449a076 100644 --- a/backend/src/procedure/mod.rs +++ b/backend/src/procedure/mod.rs @@ -109,7 +109,7 @@ impl PackageProcedure { input, timeout, gid, - rpc_client, + Some(rpc_client), ) .await }