Bump to 1.4.2

Author: markcda

CHANGELOG.md

@@ -7,11 +7,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.2] - 2025-03-07
+
+### Added
+
+- Content placements to add to storage (no support of containered runs at this moment).
+- Support of crates inside workspaces (content example - `rust-crate-ver.py`; to know crate version of the package inside some workspace, just specify package's `Cargo.toml` path; works only with no `{ workspace = true }` versions).
+
+### Fixed
+
+- `auto_version_rule` deserialization from YAML/TOML (see the `MIGRATIONS.md`).
+
 ## [1.4.1] - 2025-03-05
 
-### Changed
+### Added
 
-- Added support of `daemon_wait_seconds` field in `CustomCommand`.
+- Support of `daemon_wait_seconds` field in `CustomCommand`.
 
 ## [1.4.0-beta-7] - 2025-02-20
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deployer"
-version = "1.4.1"
+version = "1.4.2"
 edition = "2024"
 
 [dependencies]

DOCS.en.md

@@ -386,14 +386,44 @@ Time after time, you will start to notice that some projects are overused in oth
     "type": "add_to_storage",
     "short_name": "my-project",
     "auto_version_rule": {
-      "plain_file": "file-with-current-version.txt"
+      "type": "plain_file",
+      "path": "file-with-current-version.txt"
     }
   }
 }
 ```
 
 - `short_name` - string designation of the content, which will be used to place it in the storage and each time it is used
-- `auto_version_rule` - a way to automatically determine the version of the content (either `plain_file` - a file that will contain only the version and nothing else, or `cmd_stdout` - a command that will display only the version and nothing else)
+- `auto_version_rule` - a way to automatically determine the version of the content (either `plain_file` with `path` field - a file that will contain only the version and nothing else, or `cmd_stdout` with `cmd` field - a command that will display only the version and nothing else)
+- `content` - you may not specify it in case when you need to push all your artifacts in the storage, or you can write this way:
+
+```json
+{
+  "title": "Add content",
+  "desc": "",
+  "info": "content-add@0.1.0",
+  "tags": [],
+  "action": {
+    "type": "add_to_storage",
+    "short_name": "my-project",
+    "auto_version_rule": {
+      "type": "plain_file",
+      "path": "file-with-current-version.txt"
+    },
+    "content": {
+      "type": "fixed_files",
+      "placements": [
+        {
+          "from": "target/release/my-project",
+          "to": "my-project"
+        }
+      ]
+    }
+  }
+}
+```
+
+In this example you may see that you can specify only needed to you files from Deployer's run directory (relative `from` path) to push at content's folder (relative `to` path).
 
 However, sometimes the file needs to be edited in some way - and not so much even the added content from the Deployer repository, but, for example, various files in the build dependencies, e.g. manually forking Python libraries to add the desired functionality, etc., etc. And, as a rule, you want to do it without creating forks and synchronizing changes with the main repository! You can't do it with `git` patches alone.
 

DOCS.ru.md

@@ -386,14 +386,44 @@ deployer new content
     "type": "add_to_storage",
     "short_name": "my-project",
     "auto_version_rule": {
-      "plain_file": "file-with-current-version.txt"
+      "type": "plain_file",
+      "path": "file-with-current-version.txt"
     }
   }
 }
 ```
 
 - `short_name` - строковое обозначение контента, которое будет использовано для размещения в хранилище и каждый раз при использовании
-- `auto_version_rule` - способ автоматического определения версии контента (либо `plain_file` - файл, в котором будет указана только версия и больше ничего, либо `cmd_stdout` - команда, которая выведет на экран только версию и больше ничего)
+- `auto_version_rule` - способ автоматического определения версии контента (либо `plain_file` с полем `path` - файл, в котором будет указана только версия и больше ничего, либо `cmd_stdout` c полем `cmd` - команда, которая выведет на экран только версию и больше ничего)
+- `content` - вы можете ничего не указывать в случае, если вам нужно поместить в хранилище все ваши артефакты, иначе вы можете написать следующим образом:
+
+```json
+{
+  "title": "Add content",
+  "desc": "",
+  "info": "content-add@0.1.0",
+  "tags": [],
+  "action": {
+    "type": "add_to_storage",
+    "short_name": "my-project",
+    "auto_version_rule": {
+      "type": "plain_file",
+      "path": "file-with-current-version.txt"
+    },
+    "content": {
+      "type": "fixed_files",
+      "placements": [
+        {
+          "from": "target/release/my-project",
+          "to": "my-project"
+        }
+      ]
+    }
+  }
+}
+```
+
+В этом примере видно, что вы можете указать только нужные вам файлы из папки запусков Деплойера (относительный путь `from`), чтобы поместить их в папку с контентом (относительный путь `to`).
 
 Однако иногда файл нужно каким-то образом редактировать - и не столько даже добавляемый контент из хранилища Деплойера, сколько, например, различные файлы в зависимостях сборки, например, вручную делать форки библиотек Python для добавления нужной функциональности и т.д. и т.п. Причём, как правило, хочется делать это без создания форков и синхронизации изменений с `main`-репозиторием! Одними патчами `git`'а не обойтись.
 

MIGRATIONS.md

@@ -2,6 +2,33 @@
 
 > Actual configs' version: `4`.
 
+## From `1.4.1` to `1.4.2`
+
+1. Manually check all your `add_to_storage` Actions (`AutoVersionExtractFromRule`): them now look like this:
+
+```json
+[
+  {
+    "type": "add_to_storage",
+    "short_name": "my-project",
+    "auto_version_rule": {
+      "type": "plain_file",
+      "path": "file-with-current-version.txt"
+    }
+  },
+  {
+    "type": "add_to_storage",
+    "short_name": "my-project-2",
+    "auto_version_rule": {
+      "type": "cmd_stdout",
+      "cmd": <!-- {custom command} -->
+    }
+  }
+]
+```
+
+Formally, you should now specify `type` field of `auto_version_rule` object.
+
 ## From `1.4.0-beta-3` to `1.4.0-beta-4`
 
 1. Manually check all your configuration files for programming languages and targets' OSes. Replace `null` values with strings in the lower register (for example, `"rust"`, `"linux"`, etc.).

content-examples/get-know-rust-package-version/.depl/rust-crate-ver.py

@@ -1,7 +1,13 @@
 #!/usr/bin/env python
 
 import tomllib
+import sys
 
-with open('Cargo.toml', 'rb') as f:
-  data = tomllib.load(f)
-  print(data['package']['version'])
+if len(sys.argv) == 1:
+  with open('Cargo.toml', 'rb') as f:
+    data = tomllib.load(f)
+    print(data['package']['version'])
+else:
+  with open(sys.argv[1], 'rb') as f:
+    data = tomllib.load(f)
+    print(data['package']['version'])

src/actions/storage_add.rs

@@ -6,11 +6,12 @@
 use serde::{Deserialize, Serialize};
 use std::io::Read;
 
+use crate::configs::Placement;
 use crate::entities::auto_version::AutoVersionExtractFromRule;
 use crate::entities::environment::RunEnvironment;
 use crate::entities::info::ContentInfo;
 use crate::entities::traits::Execute;
-use crate::storage::add_to_storage;
+use crate::storage::{add_single_to_storage, add_to_storage};
 
 /// AddToStorage Action.
 #[derive(Deserialize, Serialize, PartialEq, Clone)]
@@ -19,40 +20,62 @@ pub struct AddToStorageAction {
   pub short_name: String,
   /// Automatic rule to extract version from project.
   pub auto_version_rule: AutoVersionExtractFromRule,
+  /// What to put in the storage?
+  pub content: Option<PutContentRule>,
+}
+
+#[derive(Deserialize, Serialize, PartialEq, Clone)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum PutContentRule {
+  Artifacts,
+  FixedFiles { placements: Vec<Placement> },
 }
 
 impl Execute for AddToStorageAction {
   /// Adds content to storage from given run environment.
   fn execute(&self, env: &RunEnvironment) -> anyhow::Result<(bool, Vec<String>)> {
-    Ok(match &self.auto_version_rule {
-      AutoVersionExtractFromRule::CmdStdout(cmd) => {
+    let version = match &self.auto_version_rule {
+      AutoVersionExtractFromRule::CmdStdout { cmd } => {
         let (succ, out) = cmd.execute(env)?;
         if !succ || out.is_empty() {
-          (false, out)
-        } else {
-          let version = out.last().unwrap().trim().replace(">>> ", "");
-          let info = ContentInfo::new(self.short_name.as_str(), version.as_str())?;
-          if let Err(e) = add_to_storage(env.storage_dir, env.artifacts_dir, &info) {
-            (false, vec![e.to_string()])
-          } else {
-            (true, vec![])
-          }
+          return Ok((false, out));
         }
+        out.last().unwrap().trim().replace(">>> ", "")
       }
-      AutoVersionExtractFromRule::PlainFile(path) => {
+      AutoVersionExtractFromRule::PlainFile { path } => {
         let mut file = std::fs::File::open(path)?;
         let version = {
           let mut ver = String::new();
           file.read_to_string(&mut ver)?;
           ver.trim().to_string()
         };
-        let info = ContentInfo::new(self.short_name.as_str(), version.as_str())?;
+        version
+      }
+    };
+
+    let info = ContentInfo::new(self.short_name.as_str(), version.as_str())?;
+
+    Ok(match &self.content {
+      Some(PutContentRule::Artifacts) | None => {
         if let Err(e) = add_to_storage(env.storage_dir, env.artifacts_dir, &info) {
           (false, vec![e.to_string()])
         } else {
           (true, vec![])
         }
       }
+      Some(PutContentRule::FixedFiles { placements }) => {
+        for placement in placements {
+          if let Err(e) = add_single_to_storage(
+            env.storage_dir,
+            &env.run_dir.join(&placement.from),
+            &placement.to,
+            &info,
+          ) {
+            return Ok((false, vec![e.to_string()]));
+          }
+        }
+        (true, vec![])
+      }
     })
   }
 }

src/configs/migrate.rs

@@ -6,11 +6,13 @@ use crate::actions::buildlike::{BuildAction, PostBuildAction, PreBuildAction};
 use crate::actions::deploylike::{ConfigureDeployAction, DeployAction, PostDeployAction};
 use crate::actions::observe::ObserveAction;
 use crate::actions::packlike::{DeliveryAction, InstallAction, PackAction};
+use crate::actions::storage_add::AddToStorageAction;
 use crate::actions::test::TestAction;
 use crate::actions::{Action, DescribedAction};
 use crate::configs::migrations::project_config_v2_to_v3_migrations::*;
 use crate::configs::migrations::project_config_v3_to_v4_migrations::*;
 use crate::configs::{DeployerGlobalConfig, DeployerProjectOptions};
+use crate::entities::auto_version::AutoVersionExtractFromRule;
 use crate::entities::custom_command::{CustomCommand, Replacement, ReplacementGroup};
 use crate::entities::programming_languages::ProgrammingLanguage;
 use crate::entities::requirements::Requirement;
@@ -119,7 +121,18 @@ fn migrate_var_v3_to_v4(prev_var: &VariableV3) -> Variable {
 fn migrate_action_v3_to_v4(action: &DescribedActionV3) -> DescribedAction {
   DescribedAction {
     action: match &action.action {
-      ActionV3::AddToStorage(a) => Action::AddToStorage(a.to_owned()),
+      ActionV3::AddToStorage(a) => Action::AddToStorage(AddToStorageAction {
+        short_name: a.short_name.to_owned(),
+        auto_version_rule: match &a.auto_version_rule {
+          AutoVersionExtractFromRuleV3::CmdStdout(cmd) => AutoVersionExtractFromRule::CmdStdout {
+            cmd: migrate_custom_v3_to_v4(cmd),
+          },
+          AutoVersionExtractFromRuleV3::PlainFile(plain) => {
+            AutoVersionExtractFromRule::PlainFile { path: plain.to_owned() }
+          }
+        },
+        content: None,
+      }),
       ActionV3::Build(b) => Action::Build(BuildAction {
         supported_langs: {
           let mut langs = vec![];

src/configs/migrations.rs

@@ -7,7 +7,7 @@ pub(crate) mod project_config_v2_to_v3_migrations {
   use std::path::PathBuf;
 
   use super::project_config_v3_to_v4_migrations::*;
-  use crate::actions::{patch::PatchAction, storage_add::AddToStorageAction};
+  use crate::actions::patch::PatchAction;
   use crate::entities::{
     info::{ActionInfo, ContentInfo, Info, PipelineInfo, ShortName, info2str, str2info, str2info_wl},
     remote_host::RemoteHost,
@@ -100,7 +100,7 @@ pub(crate) mod project_config_v2_to_v3_migrations {
     Observe(ObserveActionV3),
     #[serde(serialize_with = "info2str", deserialize_with = "str2info_wl")]
     UseFromStorage(ContentInfo),
-    AddToStorage(AddToStorageAction),
+    AddToStorage(AddToStorageActionV3),
     Patch(PatchAction),
   }
 
@@ -141,7 +141,7 @@ pub(crate) mod project_config_v3_to_v4_migrations {
   use std::collections::{HashMap, HashSet};
   use std::path::PathBuf;
 
-  use crate::actions::{patch::PatchAction, storage_add::AddToStorageAction};
+  use crate::actions::patch::PatchAction;
   use crate::entities::{
     containered_opts::ContaineredOpts,
     info::{ActionInfo, ContentInfo, Info, PipelineInfo, ShortName, info2str, str2info, str2info_wl},
@@ -274,7 +274,7 @@ pub(crate) mod project_config_v3_to_v4_migrations {
       #[serde(serialize_with = "info2str", deserialize_with = "str2info_wl")]
       content_info: ContentInfo,
     },
-    AddToStorage(AddToStorageAction),
+    AddToStorage(AddToStorageActionV3),
     Patch(PatchAction),
     SubPipeline(Box<DescribedPipelineV3>),
   }
@@ -355,6 +355,19 @@ pub(crate) mod project_config_v3_to_v4_migrations {
     pub command: CustomCommandV3,
   }
 
+  #[derive(Deserialize, Serialize, PartialEq, Clone)]
+  pub struct AddToStorageActionV3 {
+    pub short_name: String,
+    pub auto_version_rule: AutoVersionExtractFromRuleV3,
+  }
+
+  #[derive(Deserialize, Serialize, PartialEq, Clone)]
+  #[serde(rename_all = "snake_case")]
+  pub enum AutoVersionExtractFromRuleV3 {
+    CmdStdout(CustomCommandV3),
+    PlainFile(PathBuf),
+  }
+
   #[derive(Deserialize, Serialize, PartialEq, Eq, Hash, Clone)]
   pub struct CustomCommandV3 {
     pub bash_c: String,

src/entities/auto_version.rs

@@ -8,20 +8,20 @@ use crate::i18n;
 
 /// Rule to extract version from the project automatically.
 #[derive(Deserialize, Serialize, PartialEq, Clone)]
-#[serde(rename_all = "snake_case")]
+#[serde(tag = "type", rename_all = "snake_case")]
 pub enum AutoVersionExtractFromRule {
   /// Extract from `stdout` of command.
-  CmdStdout(CustomCommand),
+  CmdStdout { cmd: CustomCommand },
   /// Extract from plain file.
-  PlainFile(PathBuf),
+  PlainFile { path: PathBuf },
 }
 
 impl AutoVersionExtractFromRule {
   /// Returns rule type as `&str`.
   pub fn type_str(&self) -> &str {
     match self {
-      Self::CmdStdout(_) => i18n::AUTO_VER_CMD_STDOUT,
-      Self::PlainFile(_) => i18n::AUTO_VER_PLAIN_FILE,
+      Self::CmdStdout { cmd: _ } => i18n::AUTO_VER_CMD_STDOUT,
+      Self::PlainFile { path: _ } => i18n::AUTO_VER_PLAIN_FILE,
     }
   }
 }