rename ActionImplementation to PackageProcedure

backend/src/action.rs

@@ -21,10 +21,6 @@ use crate::util::Version;
 use crate::volume::Volumes;
 use crate::{Error, ResultExt};
 
-pub mod docker;
-
-// TODO: create RPC endpoint that looks up the appropriate action and calls `execute`
-
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
 pub struct ActionId<S: AsRef<str> = String>(Id<S>);
 impl FromStr for ActionId {
@@ -103,7 +99,7 @@ pub struct Action {
     pub description: String,
     #[serde(default)]
     pub warning: Option<String>,
-    pub implementation: ActionImplementation,
+    pub implementation: PackageProcedure,
     pub allowed_statuses: IndexSet<DockerStatus>,
     #[serde(default)]
     pub input_spec: ConfigSpec,
@@ -152,76 +148,6 @@ impl Action {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize, HasModel)]
-#[serde(rename_all = "kebab-case")]
-#[serde(tag = "type")]
-pub enum ActionImplementation {
-    Docker(DockerAction),
-}
-impl ActionImplementation {
-    #[instrument]
-    pub fn validate(
-        &self,
-        volumes: &Volumes,
-        image_ids: &BTreeSet<ImageId>,
-        expected_io: bool,
-    ) -> Result<(), color_eyre::eyre::Report> {
-        match self {
-            ActionImplementation::Docker(action) => {
-                action.validate(volumes, image_ids, expected_io)
-            }
-        }
-    }
-
-    #[instrument(skip(ctx, input))]
-    pub async fn execute<I: Serialize, O: for<'de> Deserialize<'de>>(
-        &self,
-        ctx: &RpcContext,
-        pkg_id: &PackageId,
-        pkg_version: &Version,
-        name: Option<&str>,
-        volumes: &Volumes,
-        input: Option<I>,
-        allow_inject: bool,
-        timeout: Option<Duration>,
-    ) -> Result<Result<O, (i32, String)>, Error> {
-        match self {
-            ActionImplementation::Docker(action) => {
-                action
-                    .execute(
-                        ctx,
-                        pkg_id,
-                        pkg_version,
-                        name,
-                        volumes,
-                        input,
-                        allow_inject,
-                        timeout,
-                    )
-                    .await
-            }
-        }
-    }
-    #[instrument(skip(ctx, input))]
-    pub async fn sandboxed<I: Serialize, O: for<'de> Deserialize<'de>>(
-        &self,
-        ctx: &RpcContext,
-        pkg_id: &PackageId,
-        pkg_version: &Version,
-        volumes: &Volumes,
-        input: Option<I>,
-        timeout: Option<Duration>,
-    ) -> Result<Result<O, (i32, String)>, Error> {
-        match self {
-            ActionImplementation::Docker(action) => {
-                action
-                    .sandboxed(ctx, pkg_id, pkg_version, volumes, input, timeout)
-                    .await
-            }
-        }
-    }
-}
-
 fn display_action_result(action_result: ActionResult, matches: &ArgMatches<'_>) {
     if matches.is_present("format") {
         return display_serializable(action_result, matches);
@@ -278,13 +204,3 @@ pub async fn action(
         ))
     }
 }
-
-pub struct NoOutput;
-impl<'de> Deserialize<'de> for NoOutput {
-    fn deserialize<D>(_: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        Ok(NoOutput)
-    }
-}

backend/src/backup/mod.rs

@@ -12,12 +12,12 @@ use tokio::io::AsyncWriteExt;
 use tracing::instrument;
 
 use self::target::PackageBackupInfo;
-use crate::action::{ActionImplementation, NoOutput};
 use crate::context::RpcContext;
 use crate::dependencies::reconfigure_dependents_with_live_pointers;
 use crate::id::ImageId;
 use crate::install::PKG_ARCHIVE_DIR;
 use crate::net::interface::{InterfaceId, Interfaces};
+use crate::procedure::{NoOutput, PackageProcedure};
 use crate::s9pk::manifest::PackageId;
 use crate::util::serde::IoFormat;
 use crate::util::{AtomicFile, Version};
@@ -64,8 +64,8 @@ struct BackupMetadata {
 
 #[derive(Clone, Debug, Deserialize, Serialize, HasModel)]
 pub struct BackupActions {
-    pub create: ActionImplementation,
+    pub create: PackageProcedure,
-    pub restore: ActionImplementation,
+    pub restore: PackageProcedure,
 }
 impl BackupActions {
     pub fn validate(&self, volumes: &Volumes, image_ids: &BTreeSet<ImageId>) -> Result<(), Error> {

backend/src/config/action.rs

@@ -7,10 +7,10 @@ use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
 use super::{Config, ConfigSpec};
-use crate::action::ActionImplementation;
 use crate::context::RpcContext;
 use crate::dependencies::Dependencies;
 use crate::id::ImageId;
+use crate::procedure::PackageProcedure;
 use crate::s9pk::manifest::PackageId;
 use crate::status::health_check::HealthCheckId;
 use crate::util::Version;
@@ -26,8 +26,8 @@ pub struct ConfigRes {
 
 #[derive(Clone, Debug, Deserialize, Serialize, HasModel)]
 pub struct ConfigActions {
-    pub get: ActionImplementation,
+    pub get: PackageProcedure,
-    pub set: ActionImplementation,
+    pub set: PackageProcedure,
 }
 impl ConfigActions {
     #[instrument]

backend/src/dependencies.rs

@@ -14,10 +14,10 @@ use rpc_toolkit::command;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
-use crate::action::{ActionImplementation, NoOutput};
+use crate::action::{NoOutput, PackageProcedure};
+use crate::config::action::{ConfigActions, ConfigRes};
 use crate::config::spec::PackagePointerSpec;
-use crate::config::{action::ConfigActions, Config, ConfigSpec};
+use crate::config::{not_found, Config, ConfigReceipts, ConfigSpec};
-use crate::config::{action::ConfigRes, not_found, ConfigReceipts};
 use crate::context::RpcContext;
 use crate::db::model::{CurrentDependencyInfo, InstalledPackageDataEntry};
 use crate::s9pk::manifest::{Manifest, PackageId};
@@ -486,8 +486,8 @@ impl DepInfo {
 #[derive(Clone, Debug, Deserialize, Serialize, HasModel)]
 #[serde(rename_all = "kebab-case")]
 pub struct DependencyConfig {
-    check: ActionImplementation,
+    check: PackageProcedure,
-    auto_configure: ActionImplementation,
+    auto_configure: PackageProcedure,
 }
 impl DependencyConfig {
     pub async fn check(

backend/src/lib.rs

@@ -31,6 +31,7 @@ pub mod middleware;
 pub mod migration;
 pub mod net;
 pub mod notifications;
+pub mod procedure;
 pub mod properties;
 pub mod s9pk;
 pub mod setup;

backend/src/manager/mod.rs

@@ -19,13 +19,13 @@ use tokio::sync::{Notify, RwLock};
 use torut::onion::TorSecretKeyV3;
 use tracing::instrument;
 
-use crate::action::docker::DockerAction;
-use crate::action::{ActionImplementation, NoOutput};
 use crate::context::RpcContext;
 use crate::manager::sync::synchronizer;
 use crate::net::interface::InterfaceId;
 use crate::net::GeneratedCertificateMountPoint;
 use crate::notifications::NotificationLevel;
+use crate::procedure::docker::DockerProcedure;
+use crate::procedure::{NoOutput, PackageProcedure};
 use crate::s9pk::manifest::{Manifest, PackageId};
 use crate::status::MainStatus;
 use crate::util::{Container, NonDetachingJoinHandle, Version};
@@ -333,7 +333,7 @@ impl Manager {
             ctx,
             status: AtomicUsize::new(Status::Stopped as usize),
             on_stop,
-            container_name: DockerAction::container_name(&manifest.id, None),
+            container_name: DockerProcedure::container_name(&manifest.id, None),
             manifest,
             tor_keys,
             synchronized: Notify::new(),
@@ -399,7 +399,7 @@ impl Manager {
                 &self.shared.container_name,
                 Some(StopContainerOptions {
                     t: match &self.shared.manifest.main {
-                        ActionImplementation::Docker(a) => a,
+                        PackageProcedure::Docker(a) => a,
                     }
                     .sigterm_timeout
                     .map(|a| *a)
@@ -549,7 +549,7 @@ async fn stop(shared: &ManagerSharedState) -> Result<(), Error> {
             &shared.container_name,
             Some(StopContainerOptions {
                 t: match &shared.manifest.main {
-                    ActionImplementation::Docker(a) => a,
+                    PackageProcedure::Docker(a) => a,
                 }
                 .sigterm_timeout
                 .map(|a| *a)

backend/src/migration.rs

@@ -8,9 +8,9 @@ use patch_db::HasModel;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
-use crate::action::ActionImplementation;
 use crate::context::RpcContext;
 use crate::id::ImageId;
+use crate::procedure::PackageProcedure;
 use crate::s9pk::manifest::PackageId;
 use crate::util::Version;
 use crate::volume::Volumes;
@@ -19,8 +19,8 @@ use crate::{Error, ResultExt};
 #[derive(Clone, Debug, Default, Deserialize, Serialize, HasModel)]
 #[serde(rename_all = "kebab-case")]
 pub struct Migrations {
-    pub from: IndexMap<VersionRange, ActionImplementation>,
+    pub from: IndexMap<VersionRange, PackageProcedure>,
-    pub to: IndexMap<VersionRange, ActionImplementation>,
+    pub to: IndexMap<VersionRange, PackageProcedure>,
 }
 impl Migrations {
     #[instrument]

backend/src/procedure/docker.rs

@@ -36,7 +36,7 @@ lazy_static::lazy_static! {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
-pub struct DockerAction {
+pub struct DockerProcedure {
     pub image: ImageId,
     #[serde(default)]
     pub system: bool,
@@ -54,7 +54,7 @@ pub struct DockerAction {
     #[serde(default)]
     pub sigterm_timeout: Option<SerdeDuration>,
 }
-impl DockerAction {
+impl DockerProcedure {
     pub fn validate(
         &self,
         volumes: &Volumes,

backend/src/procedure/mod.rs

@@ -0,0 +1,104 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::Path;
+use std::str::FromStr;
+use std::time::Duration;
+
+use clap::ArgMatches;
+use color_eyre::eyre::eyre;
+use indexmap::IndexSet;
+use patch_db::HasModel;
+use rpc_toolkit::command;
+use serde::{Deserialize, Serialize};
+use tracing::instrument;
+
+use self::docker::DockerProcedure;
+use crate::config::{Config, ConfigSpec};
+use crate::context::RpcContext;
+use crate::id::{Id, ImageId, InvalidId};
+use crate::s9pk::manifest::PackageId;
+use crate::util::serde::{display_serializable, parse_stdin_deserializable, IoFormat};
+use crate::util::Version;
+use crate::volume::Volumes;
+use crate::{Error, ResultExt};
+
+pub mod docker;
+
+// TODO: create RPC endpoint that looks up the appropriate action and calls `execute`
+
+#[derive(Clone, Debug, Deserialize, Serialize, HasModel)]
+#[serde(rename_all = "kebab-case")]
+#[serde(tag = "type")]
+pub enum PackageProcedure {
+    Docker(DockerProcedure),
+}
+impl PackageProcedure {
+    #[instrument]
+    pub fn validate(
+        &self,
+        volumes: &Volumes,
+        image_ids: &BTreeSet<ImageId>,
+        expected_io: bool,
+    ) -> Result<(), color_eyre::eyre::Report> {
+        match self {
+            PackageProcedure::Docker(action) => action.validate(volumes, image_ids, expected_io),
+        }
+    }
+
+    #[instrument(skip(ctx, input))]
+    pub async fn execute<I: Serialize, O: for<'de> Deserialize<'de>>(
+        &self,
+        ctx: &RpcContext,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        name: Option<&str>,
+        volumes: &Volumes,
+        input: Option<I>,
+        allow_inject: bool,
+        timeout: Option<Duration>,
+    ) -> Result<Result<O, (i32, String)>, Error> {
+        match self {
+            PackageProcedure::Docker(action) => {
+                action
+                    .execute(
+                        ctx,
+                        pkg_id,
+                        pkg_version,
+                        name,
+                        volumes,
+                        input,
+                        allow_inject,
+                        timeout,
+                    )
+                    .await
+            }
+        }
+    }
+    #[instrument(skip(ctx, input))]
+    pub async fn sandboxed<I: Serialize, O: for<'de> Deserialize<'de>>(
+        &self,
+        ctx: &RpcContext,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        volumes: &Volumes,
+        input: Option<I>,
+        timeout: Option<Duration>,
+    ) -> Result<Result<O, (i32, String)>, Error> {
+        match self {
+            PackageProcedure::Docker(action) => {
+                action
+                    .sandboxed(ctx, pkg_id, pkg_version, volumes, input, timeout)
+                    .await
+            }
+        }
+    }
+}
+
+pub struct NoOutput;
+impl<'de> Deserialize<'de> for NoOutput {
+    fn deserialize<D>(_: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        Ok(NoOutput)
+    }
+}

backend/src/s9pk/manifest.rs

@@ -7,7 +7,7 @@ use patch_db::HasModel;
 use serde::{Deserialize, Serialize, Serializer};
 use url::Url;
 
-use crate::action::{ActionImplementation, Actions};
+use crate::action::{Actions, PackageProcedure};
 use crate::backup::BackupActions;
 use crate::config::action::ConfigActions;
 use crate::dependencies::Dependencies;
@@ -128,12 +128,12 @@ pub struct Manifest {
     #[serde(default)]
     pub alerts: Alerts,
     #[model]
-    pub main: ActionImplementation,
+    pub main: PackageProcedure,
     pub health_checks: HealthChecks,
     #[model]
     pub config: Option<ConfigActions>,
     #[model]
-    pub properties: Option<ActionImplementation>,
+    pub properties: Option<PackageProcedure>,
     #[model]
     pub volumes: Volumes,
     // #[serde(default)]

backend/src/status/health_check.rs

@@ -5,7 +5,7 @@ use chrono::{DateTime, Utc};
 use serde::{Deserialize, Deserializer, Serialize};
 use tracing::instrument;
 
-use crate::action::{ActionImplementation, NoOutput};
+use crate::action::{NoOutput, PackageProcedure};
 use crate::context::RpcContext;
 use crate::id::{Id, ImageId};
 use crate::s9pk::manifest::PackageId;
@@ -89,7 +89,7 @@ pub struct HealthCheck {
     pub name: String,
     pub success_message: Option<String>,
     #[serde(flatten)]
-    implementation: ActionImplementation,
+    implementation: PackageProcedure,
     pub timeout: Option<Duration>,
 }
 impl HealthCheck {