feat: add bare
Signed-off-by: kjuulh <contact@kjuulh.io>
This commit is contained in:
parent
bf7a7db868
commit
a4213ea61f
GPG Key ID:
D85D7535F18F35FA
56
.drone.yml
56
.drone.yml
@ -1,54 +1,2 @@
|
||||
kind: pipeline
|
||||
name: default
|
||||
type: docker
|
||||
|
||||
steps:
|
||||
- name: load_secret
|
||||
image: debian:buster-slim
|
||||
volumes:
|
||||
- name: ssh
|
||||
path: /root/.ssh/
|
||||
environment:
|
||||
SSH_KEY:
|
||||
from_secret: gitea_id_ed25519
|
||||
commands:
|
||||
- mkdir -p $HOME/.ssh/
|
||||
- echo "$SSH_KEY" | base64 -d > $HOME/.ssh/id_ed25519
|
||||
|
||||
- name: build
|
||||
image: kasperhermansen/cuddle:latest
|
||||
pull: always
|
||||
volumes:
|
||||
- name: ssh
|
||||
path: /root/.ssh/
|
||||
- name: dockersock
|
||||
path: /var/run
|
||||
commands:
|
||||
- eval `ssh-agent`
|
||||
- chmod -R 600 ~/.ssh
|
||||
- ssh-add
|
||||
- cuddle x build_cuddle_image
|
||||
environment:
|
||||
DOCKER_BUILDKIT: 1
|
||||
CUDDLE_SECRETS_PROVIDER: 1password
|
||||
CUDDLE_ONE_PASSWORD_DOT_ENV: ".env.ci"
|
||||
CUDDLE_SSH_AGENT: "true"
|
||||
OP_SERVICE_ACCOUNT_TOKEN:
|
||||
from_secret: op_service_account_token
|
||||
|
||||
depends_on:
|
||||
- "load_secret"
|
||||
|
||||
services:
|
||||
- name: docker
|
||||
image: docker:dind
|
||||
privileged: true
|
||||
volumes:
|
||||
- name: dockersock
|
||||
path: /var/run
|
||||
|
||||
volumes:
|
||||
- name: ssh
|
||||
temp: {}
|
||||
- name: dockersock
|
||||
temp: {}
|
||||
kind: template
|
||||
load: cuddle-rust-cli-plan.yaml
|
||||
|
||||
2
.env.ci
2
.env.ci
@ -1,2 +0,0 @@
|
||||
DOCKER_USERNAME={{ op://application/docker_hub_credentials/username }}
|
||||
DOCKER_PASSWORD={{ op://application/docker_hub_credentials/password }}
|
||||
3
.gitignore
vendored
3
.gitignore
vendored
@ -1,3 +1,2 @@
|
||||
/target
|
||||
target/
|
||||
.cuddle/
|
||||
.env
|
||||
|
||||
2505
Cargo.lock
generated
2505
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
16
Cargo.toml
16
Cargo.toml
@ -1,3 +1,17 @@
|
||||
[workspace]
|
||||
members = ["cuddle", "examples/base", "ci"]
|
||||
members = ["crates/*"]
|
||||
resolver = "2"
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.0"
|
||||
|
||||
[workspace.dependencies]
|
||||
cuddle = { path = "crates/cuddle" }
|
||||
|
||||
anyhow = { version = "1" }
|
||||
tokio = { version = "1", features = ["full"] }
|
||||
tracing = { version = "0.1", features = ["log"] }
|
||||
tracing-subscriber = { version = "0.3.18" }
|
||||
clap = { version = "4", features = ["derive", "env"] }
|
||||
dotenv = { version = "0.15" }
|
||||
axum = { version = "0.7" }
|
||||
|
||||
7
LICENSE
7
LICENSE
@ -1,7 +0,0 @@
|
||||
Copyright 2023 Kasper J. Hermansen
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
71
README.md
71
README.md
@ -1,71 +1,2 @@
|
||||
# Cuddle - Configuration and Script Manager
|
||||
# cuddle
|
||||
|
||||
Cuddle CLI is a Rust command-line interface application designed to manage
|
||||
configuration variables and scripts across projects. It simplifies sharing of
|
||||
code and workflows, making development and collaboration smoother and more
|
||||
efficient. This project is published on crates.io as `cuddle`.
|
||||
|
||||
## Table of Contents
|
||||
|
||||
1. [Installation](#installation)
|
||||
2. [Usage](#usage)
|
||||
3. [Commands](#commands)
|
||||
4. [Configuration](#configuration)
|
||||
5. [Contributing](#contributing)
|
||||
6. [License](#license)
|
||||
|
||||
## Installation
|
||||
|
||||
Make sure you have Rust and Cargo installed. You can install Rust and Cargo from
|
||||
[https://rustup.rs/](https://rustup.rs/).
|
||||
|
||||
To install Cuddle CLI, run:
|
||||
|
||||
```sh
|
||||
cargo install cuddle
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
After successful installation, you can run the CLI using the `cuddle` command:
|
||||
|
||||
```sh
|
||||
cuddle [command] [options]
|
||||
```
|
||||
|
||||
## Commands
|
||||
|
||||
Detailed documentation of the commands and options can be found in our
|
||||
[official documentation (tbd)](LINK_TO_DOCUMENTATION).
|
||||
|
||||
## Configuration
|
||||
|
||||
You can manage your configurations in a file called `cuddle.yaml`. For details
|
||||
on how to format this file, check our
|
||||
[Configuration Guide (tbd)](LINK_TO_CONFIGURATION_GUIDE).
|
||||
|
||||
## Contributing
|
||||
|
||||
Contributions are what make the open-source community such an amazing place to
|
||||
learn, inspire, and create. Any contributions you make are **greatly
|
||||
appreciated**.
|
||||
|
||||
1. Fork the Project
|
||||
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
|
||||
3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
|
||||
4. Push to the Branch (`git push origin feature/AmazingFeature`)
|
||||
5. Open a Pull Request
|
||||
|
||||
Please read our [Contributing Guide](LINK_TO_CONTRIBUTING_GUIDE) for more
|
||||
information.
|
||||
|
||||
## License
|
||||
|
||||
Distributed under the MIT License. See `LICENSE` for more information.
|
||||
|
||||
## Contact
|
||||
|
||||
You can reach out to us at our
|
||||
[official contact page (tbd)](LINK_TO_CONTACT_PAGE). Please ensure to follow our
|
||||
[Code of Conduct (tbd)](LINK_TO_CONDUCT_PAGE) when interacting with our
|
||||
community.
|
||||
|
||||
@ -1,11 +0,0 @@
|
||||
[package]
|
||||
name = "ci"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
dagger-sdk = "0.9.8"
|
||||
eyre = "0.6.12"
|
||||
tokio = { version = "1.36.0", features = ["full"] }
|
||||
112
ci/src/main.rs
112
ci/src/main.rs
@ -1,112 +0,0 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use dagger_sdk::{
|
||||
Container, ContainerPublishOptsBuilder, Directory, HostDirectoryOptsBuilder, Query,
|
||||
QueryContainerOptsBuilder,
|
||||
};
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> eyre::Result<()> {
|
||||
let client = dagger_sdk::connect().await?;
|
||||
|
||||
let src = client.host().directory_opts(
|
||||
".",
|
||||
HostDirectoryOptsBuilder::default()
|
||||
.include(vec![
|
||||
"ci/",
|
||||
"cuddle/",
|
||||
"examples",
|
||||
"Cargo.lock",
|
||||
"Cargo.toml",
|
||||
])
|
||||
.build()?,
|
||||
);
|
||||
|
||||
client
|
||||
.container()
|
||||
.publish_opts(
|
||||
"kasperhermansen/cuddle:dev",
|
||||
ContainerPublishOptsBuilder::default()
|
||||
.platform_variants(vec![
|
||||
dind_image(client.clone(), src.clone(), "x86_64", "linux/amd64")
|
||||
.await?
|
||||
.id()
|
||||
.await?,
|
||||
dind_image(client.clone(), src.clone(), "aarch64", "linux/arm64/v8")
|
||||
.await?
|
||||
.id()
|
||||
.await?,
|
||||
])
|
||||
.build()?,
|
||||
)
|
||||
.await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn dind_image(
|
||||
client: Arc<Query>,
|
||||
src: Directory,
|
||||
architecture: &str,
|
||||
platform: &str,
|
||||
) -> eyre::Result<Container> {
|
||||
let rust_bin = client
|
||||
.container_opts(
|
||||
QueryContainerOptsBuilder::default()
|
||||
.platform(platform)
|
||||
.build()?,
|
||||
)
|
||||
.from("rustlang/rust:nightly")
|
||||
.with_exec(vec![
|
||||
"rustup",
|
||||
"target",
|
||||
"add",
|
||||
&format!("{architecture}-unknown-linux-musl"),
|
||||
])
|
||||
.with_exec(vec!["update-ca-certificates"])
|
||||
.with_exec(vec!["apt-get", "update"])
|
||||
.with_exec(vec!["apt-get", "upgrade", "-y"])
|
||||
.with_exec(vec![
|
||||
"apt-get",
|
||||
"install",
|
||||
"-y",
|
||||
"-q",
|
||||
"build-essential",
|
||||
"curl",
|
||||
"git",
|
||||
"musl-tools",
|
||||
"musl-dev",
|
||||
"libz-dev",
|
||||
])
|
||||
.with_workdir("/app/cuddle/")
|
||||
.with_directory(".", src)
|
||||
.with_exec(vec![
|
||||
"cargo",
|
||||
"install",
|
||||
"--target",
|
||||
&format!("{architecture}-unknown-linux-musl"),
|
||||
"--path",
|
||||
"cuddle",
|
||||
"--profile=release",
|
||||
]);
|
||||
|
||||
let final_image = client
|
||||
.container_opts(
|
||||
QueryContainerOptsBuilder::default()
|
||||
.platform(platform)
|
||||
.build()?,
|
||||
)
|
||||
.from("docker:dind")
|
||||
.with_directory(
|
||||
"/usr/local/cargo/bin/",
|
||||
rust_bin.directory("/usr/local/cargo/bin/"),
|
||||
);
|
||||
|
||||
let path_env = final_image.env_variable("PATH").await?;
|
||||
|
||||
let final_image = final_image
|
||||
.with_env_variable("PATH", format!("{path_env}:/usr/local/cargo/bin"))
|
||||
.with_exec(vec![""]);
|
||||
|
||||
Ok(final_image)
|
||||
}
|
||||
1
crates/cuddle/.gitignore
vendored
Normal file
1
crates/cuddle/.gitignore
vendored
Normal file
@ -0,0 +1 @@
|
||||
/target
|
||||
19
crates/cuddle/Cargo.toml
Normal file
19
crates/cuddle/Cargo.toml
Normal file
@ -0,0 +1,19 @@
|
||||
[package]
|
||||
name = "cuddle"
|
||||
edition = "2021"
|
||||
|
||||
version.workspace = true
|
||||
|
||||
[dependencies]
|
||||
anyhow.workspace = true
|
||||
tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
tracing-subscriber.workspace = true
|
||||
clap.workspace = true
|
||||
dotenv.workspace = true
|
||||
axum.workspace = true
|
||||
|
||||
serde = { version = "1.0.197", features = ["derive"] }
|
||||
sqlx = { version = "0.7.3", features = ["runtime-tokio", "tls-rustls", "postgres", "uuid", "time"] }
|
||||
uuid = { version = "1.7.0", features = ["v4"] }
|
||||
tower-http = { version = "0.5.2", features = ["cors", "trace"] }
|
||||
29
crates/cuddle/src/main.rs
Normal file
29
crates/cuddle/src/main.rs
Normal file
@ -0,0 +1,29 @@
|
||||
use anyhow::Context;
|
||||
use clap::{Parser, Subcommand};
|
||||
|
||||
#[derive(Parser)]
|
||||
#[command(author, version, about, long_about = None, subcommand_required = true)]
|
||||
struct Command {
|
||||
#[command(subcommand)]
|
||||
command: Option<Commands>,
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
enum Commands {
|
||||
Hello {},
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
dotenv::dotenv().ok();
|
||||
tracing_subscriber::fmt::init();
|
||||
|
||||
let cli = Command::parse();
|
||||
tracing::debug!("Starting cli");
|
||||
|
||||
if let Some(Commands::Hello { }) = cli.command {
|
||||
println!("Hello!")
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
21
cuddle.yaml
21
cuddle.yaml
@ -1,20 +1,15 @@
|
||||
# yaml-language-server: $schema=https://git.front.kjuulh.io/kjuulh/cuddle/raw/branch/main/schemas/base.json
|
||||
|
||||
base: "git@git.front.kjuulh.io:kjuulh/cuddle-base.git"
|
||||
base: "git@git.front.kjuulh.io:kjuulh/cuddle-rust-cli-plan.git"
|
||||
|
||||
vars:
|
||||
service: "cuddle"
|
||||
registry: kasperhermansen
|
||||
|
||||
scripts:
|
||||
install:
|
||||
type: shell
|
||||
build_cuddle_image:
|
||||
type: shell
|
||||
args:
|
||||
docker_username:
|
||||
key: "DOCKER_USERNAME"
|
||||
type: env
|
||||
docker_password:
|
||||
key: "DOCKER_PASSWORD"
|
||||
type: env
|
||||
please:
|
||||
project:
|
||||
owner: kjuulh
|
||||
repository: "cuddle"
|
||||
branch: "main"
|
||||
settings:
|
||||
api_url: "https://git.front.kjuulh.io"
|
||||
|
||||
@ -1,51 +0,0 @@
|
||||
[package]
|
||||
name = "cuddle"
|
||||
description = "cuddle is a shuttle inspired script and configuration management tool. It enables sharing of workflows on developers workstations and ci"
|
||||
repository = "https://git.front.kjuulh.io/kjuulh/cuddle"
|
||||
readme = "../README.md"
|
||||
license-file = "../LICENSE"
|
||||
publish = true
|
||||
version = "0.2.0"
|
||||
edition = "2021"
|
||||
|
||||
[[bin]]
|
||||
name = "cuddle"
|
||||
path = "src/main.rs"
|
||||
|
||||
[dependencies]
|
||||
anyhow = { version = "1.0.79", features = ["backtrace"] }
|
||||
serde = { version = "1.0.196", features = ["derive"] }
|
||||
serde_yaml = "0.9.31"
|
||||
walkdir = "2.4.0"
|
||||
git2 = { version = "0.18.2", default-features = false, features = [
|
||||
"vendored-libgit2",
|
||||
"vendored-openssl",
|
||||
"ssh",
|
||||
] }
|
||||
clap = { version = "4.4.18", features = ["env", "string"] }
|
||||
envconfig = "0.10.0"
|
||||
dirs = "5.0.1"
|
||||
tracing = "0.1.40"
|
||||
tracing-subscriber = { version = "0.3.18", features = ["json", "env-filter"] }
|
||||
log = { version = "0.4.20", features = ["std", "kv_unstable"] }
|
||||
tera = "1.19.1"
|
||||
openssl = { version = "0.10.63", features = ["vendored"] }
|
||||
libz-sys = { version = "1.1.15", default-features = false, features = [
|
||||
"libc",
|
||||
"static",
|
||||
] }
|
||||
inquire = { version = "0.6.2", features = ["console"] }
|
||||
tempfile = { version = "3.10.0" }
|
||||
serde_json = "1.0.113"
|
||||
rlua = "0.19.8"
|
||||
rlua-searcher = "0.1.0"
|
||||
dotenv = { version = "0.15.0", features = ["clap"] }
|
||||
blake3 = "1.5.0"
|
||||
tokio = { version = "1.36.0", features = ["full"] }
|
||||
futures-util = "0.3.30"
|
||||
fs_extra = "1.3.0"
|
||||
|
||||
[dependencies.reqwest]
|
||||
version = "0.11"
|
||||
default-features = false
|
||||
features = ["rustls-tls", "json"]
|
||||
@ -1,366 +0,0 @@
|
||||
use std::{collections::HashMap, path::PathBuf};
|
||||
|
||||
use anyhow::Context;
|
||||
use clap::ArgMatches;
|
||||
use rlua::Lua;
|
||||
use rlua_searcher::AddSearcher;
|
||||
|
||||
use crate::{
|
||||
actions::shell::ShellAction,
|
||||
model::{CuddleScript, CuddleShellScriptArg, CuddleVariable},
|
||||
};
|
||||
|
||||
pub mod shell;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
#[allow(dead_code)]
|
||||
pub struct CuddleAction {
|
||||
pub script: CuddleScript,
|
||||
pub path: PathBuf,
|
||||
pub description: Option<String>,
|
||||
pub name: String,
|
||||
}
|
||||
#[allow(dead_code)]
|
||||
impl CuddleAction {
|
||||
pub fn new(
|
||||
script: CuddleScript,
|
||||
path: PathBuf,
|
||||
name: String,
|
||||
description: Option<String>,
|
||||
) -> Self {
|
||||
Self {
|
||||
script,
|
||||
path,
|
||||
name,
|
||||
description,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn execute(
|
||||
self,
|
||||
matches: &ArgMatches,
|
||||
variables: Vec<CuddleVariable>,
|
||||
) -> anyhow::Result<()> {
|
||||
match self.script {
|
||||
CuddleScript::Shell(s) => {
|
||||
let mut arg_variables: Vec<CuddleVariable> = vec![];
|
||||
if let Some(args) = s.args {
|
||||
for (k, v) in args {
|
||||
let var = match v {
|
||||
CuddleShellScriptArg::Env(e) => {
|
||||
let env_var = matches.get_one::<String>(&k).cloned().ok_or(
|
||||
anyhow::anyhow!(
|
||||
"failed to find env variable with key: {}",
|
||||
&e.key
|
||||
),
|
||||
)?;
|
||||
|
||||
CuddleVariable::new(k.clone(), env_var)
|
||||
}
|
||||
CuddleShellScriptArg::Flag(flag) => {
|
||||
match matches.get_one::<String>(&flag.name) {
|
||||
Some(flag_var) => {
|
||||
CuddleVariable::new(k.clone(), flag_var.clone())
|
||||
}
|
||||
None => continue,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
arg_variables.push(var);
|
||||
}
|
||||
} else {
|
||||
arg_variables = vec![]
|
||||
};
|
||||
|
||||
let mut vars = variables.clone();
|
||||
vars.append(&mut arg_variables);
|
||||
|
||||
log::trace!("preparing to run action");
|
||||
|
||||
match ShellAction::new(
|
||||
self.name.clone(),
|
||||
format!(
|
||||
"{}/scripts/{}.sh",
|
||||
self.path
|
||||
.to_str()
|
||||
.expect("action doesn't have a name, this should never happen"),
|
||||
self.name
|
||||
),
|
||||
)
|
||||
.execute(vars)
|
||||
{
|
||||
Ok(()) => {
|
||||
log::trace!("finished running action");
|
||||
Ok(())
|
||||
}
|
||||
Err(e) => {
|
||||
log::error!("{}", e);
|
||||
Err(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
CuddleScript::Dagger(_d) => Err(anyhow::anyhow!("not implemented yet!")),
|
||||
CuddleScript::Lua(l) => {
|
||||
let lua = Lua::new();
|
||||
|
||||
let mut map = HashMap::new();
|
||||
//map.insert("init".into(), "print(\"something\")".into());
|
||||
|
||||
let lua_dir = PathBuf::new().join(&self.path).join("scripts").join("lua");
|
||||
if lua_dir.exists() {
|
||||
let absolute_lua_dir = lua_dir.canonicalize()?;
|
||||
for entry in walkdir::WalkDir::new(&lua_dir)
|
||||
.into_iter()
|
||||
.filter_map(|e| e.ok())
|
||||
{
|
||||
if entry.metadata()?.is_file() {
|
||||
let full_file_path = entry.path().canonicalize()?;
|
||||
let relative_module_path =
|
||||
full_file_path.strip_prefix(&absolute_lua_dir)?;
|
||||
let module_path = relative_module_path
|
||||
.to_string_lossy()
|
||||
.to_string()
|
||||
.trim_end_matches("/init.lua")
|
||||
.trim_end_matches(".lua")
|
||||
.replace("/", ".");
|
||||
let contents = std::fs::read_to_string(entry.path())?;
|
||||
tracing::trace!(module_path = &module_path, "adding lua file");
|
||||
|
||||
map.insert(module_path.into(), contents.into());
|
||||
}
|
||||
}
|
||||
}
|
||||
let lua_rocks_dir = PathBuf::new()
|
||||
.join(&self.path)
|
||||
.join("lua_modules")
|
||||
.join("share")
|
||||
.join("lua")
|
||||
.join("5.4");
|
||||
if lua_rocks_dir.exists() {
|
||||
let absolute_lua_dir = lua_rocks_dir.canonicalize()?;
|
||||
for entry in walkdir::WalkDir::new(&lua_rocks_dir)
|
||||
.into_iter()
|
||||
.filter_map(|e| e.ok())
|
||||
{
|
||||
if entry.metadata()?.is_file() {
|
||||
let full_file_path = entry.path().canonicalize()?;
|
||||
let relative_module_path =
|
||||
full_file_path.strip_prefix(&absolute_lua_dir)?;
|
||||
let module_path = relative_module_path
|
||||
.to_string_lossy()
|
||||
.to_string()
|
||||
.trim_end_matches("/init.lua")
|
||||
.trim_end_matches(".lua")
|
||||
.replace("/", ".");
|
||||
let contents = std::fs::read_to_string(entry.path())?;
|
||||
tracing::trace!(module_path = &module_path, "adding lua file");
|
||||
|
||||
map.insert(module_path.into(), contents.into());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lua.context::<_, anyhow::Result<()>>(|lua_ctx| {
|
||||
lua_ctx.add_searcher(map)?;
|
||||
let globals = lua_ctx.globals();
|
||||
|
||||
let lua_script_entry = std::fs::read_to_string(
|
||||
PathBuf::new()
|
||||
.join(&self.path)
|
||||
.join("scripts")
|
||||
.join(format!("{}.lua", &self.name)),
|
||||
)
|
||||
.context("failed to find lua script")?;
|
||||
|
||||
lua_ctx
|
||||
.load(&lua_script_entry)
|
||||
.set_name(&self.name)?
|
||||
.exec()?;
|
||||
|
||||
Ok(())
|
||||
})?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
CuddleScript::Rust(script) => Ok(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub mod rust_action {
|
||||
use std::{path::PathBuf, time::Duration};
|
||||
|
||||
use anyhow::Context;
|
||||
use futures_util::StreamExt;
|
||||
use reqwest::Method;
|
||||
use tokio::{fs::File, io::AsyncWriteExt};
|
||||
|
||||
use crate::model::{CuddleRustScript, CuddleRustUpstream, CuddleVariable};
|
||||
|
||||
pub struct RustActionConfig {
|
||||
pub config_dir: PathBuf,
|
||||
pub cache_dir: PathBuf,
|
||||
}
|
||||
|
||||
impl Default for RustActionConfig {
|
||||
fn default() -> Self {
|
||||
let config = dirs::config_dir().expect("to be able to find a valid .config dir");
|
||||
let cache = dirs::cache_dir().expect("to be able to find a valid .cache dir");
|
||||
|
||||
Self {
|
||||
config_dir: config,
|
||||
cache_dir: cache,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct RustAction {
|
||||
pub config: RustActionConfig,
|
||||
pub plan: String,
|
||||
pub binary_name: String,
|
||||
}
|
||||
|
||||
impl RustAction {
|
||||
pub fn new(plan: String, binary_name: String) -> Self {
|
||||
Self {
|
||||
plan,
|
||||
binary_name,
|
||||
config: RustActionConfig::default(),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn execute(
|
||||
&self,
|
||||
script: CuddleRustScript,
|
||||
variables: impl IntoIterator<Item = CuddleVariable>,
|
||||
) -> anyhow::Result<()> {
|
||||
let commit_sha = self
|
||||
.get_commit_sha()
|
||||
.await
|
||||
.context("failed to find a valid commit sha on the inferred path: .cuddle/plan")?;
|
||||
|
||||
let binary_hash = self.calculate_hash(commit_sha)?;
|
||||
|
||||
// Get cached binary
|
||||
// let binary = match self.get_binary(&binary_hash).await? {
|
||||
// Some(binary) => binary,
|
||||
// None => self.fetch_binary(&script, &binary_hash).await?,
|
||||
// };
|
||||
|
||||
// Execute binary
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn get_binary(
|
||||
&self,
|
||||
binary_hash: impl Into<String>,
|
||||
) -> anyhow::Result<Option<RustBinary>> {
|
||||
let binary_path = self.get_cached_binary_path(binary_hash);
|
||||
if !binary_path.exists() {
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
Ok(Some(RustBinary {}))
|
||||
}
|
||||
|
||||
fn get_cached_binary_path(&self, binary_hash: impl Into<String>) -> PathBuf {
|
||||
let cached_binary_name = self.get_cached_binary_name(binary_hash);
|
||||
let binary_path = self
|
||||
.config
|
||||
.cache_dir
|
||||
.join("binaries")
|
||||
.join(cached_binary_name);
|
||||
binary_path
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_cached_binary_name(&self, binary_hash: impl Into<String>) -> String {
|
||||
format!("{}-{}", binary_hash.into(), self.binary_name)
|
||||
}
|
||||
|
||||
async fn get_commit_sha(&self) -> anyhow::Result<String> {
|
||||
let repo = git2::Repository::open(".cuddle/plan")?;
|
||||
let head = repo.head()?;
|
||||
let commit = head.peel_to_commit()?;
|
||||
|
||||
let commit_sha = commit.id();
|
||||
|
||||
Ok(commit_sha.to_string())
|
||||
}
|
||||
|
||||
// async fn fetch_binary(
|
||||
// &self,
|
||||
// script: &CuddleRustScript,
|
||||
// binary_hash: impl Into<String>,
|
||||
// ) -> anyhow::Result<RustBinary> {
|
||||
//let upstream = &script.upstream;
|
||||
|
||||
//TODO: we should interpret some template variables in the upstream string. Ignore for now though
|
||||
|
||||
// match UpstreamRustBinary::from(upstream) {
|
||||
// UpstreamRustBinary::HttpBased { url } => {
|
||||
// let client = reqwest::ClientBuilder::new()
|
||||
// .user_agent(concat!(
|
||||
// env!("CARGO_PKG_NAME"),
|
||||
// "/",
|
||||
// env!("CARGO_PKG_VERSION")
|
||||
// ))
|
||||
// .connect_timeout(Duration::from_secs(5))
|
||||
// .build()?;
|
||||
|
||||
// let resp = client.request(Method::GET, url).send().await?;
|
||||
|
||||
// let mut stream = resp.bytes_stream();
|
||||
|
||||
// let mut file = File::create(self.get_cached_binary_name(binary_hash)).await?;
|
||||
|
||||
// while let Some(item) = stream.next().await {
|
||||
// let chunk = item?;
|
||||
|
||||
// file.write_all(&chunk).await?;
|
||||
// }
|
||||
|
||||
// // Make sure the entire file is written before we execute it
|
||||
// file.flush().await?;
|
||||
|
||||
// todo!()
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
fn calculate_hash(&self, commit_sha: impl Into<Vec<u8>>) -> anyhow::Result<String> {
|
||||
let mut contents: Vec<u8> = Vec::new();
|
||||
contents.append(&mut self.plan.clone().into_bytes());
|
||||
contents.append(&mut commit_sha.into());
|
||||
|
||||
let hash = blake3::hash(&contents);
|
||||
|
||||
let hex = hash.to_hex();
|
||||
|
||||
Ok(hex.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct RustBinary {}
|
||||
|
||||
pub enum UpstreamRustBinary {
|
||||
HttpBased { url: String },
|
||||
}
|
||||
|
||||
impl From<CuddleRustUpstream> for UpstreamRustBinary {
|
||||
fn from(value: CuddleRustUpstream) -> Self {
|
||||
match value {
|
||||
CuddleRustUpstream::Gitea { url } => Self::HttpBased { url },
|
||||
}
|
||||
}
|
||||
}
|
||||
impl From<&CuddleRustUpstream> for UpstreamRustBinary {
|
||||
fn from(value: &CuddleRustUpstream) -> Self {
|
||||
match value {
|
||||
CuddleRustUpstream::Gitea { url } => Self::HttpBased { url: url.clone() },
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,62 +0,0 @@
|
||||
use std::io::{BufRead, BufReader};
|
||||
use std::process::Stdio;
|
||||
use std::{env::current_dir, path::PathBuf, process::Command};
|
||||
|
||||
use crate::model::CuddleVariable;
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub struct ShellAction {
|
||||
path: String,
|
||||
name: String,
|
||||
}
|
||||
|
||||
impl ShellAction {
|
||||
pub fn new(name: String, path: String) -> Self {
|
||||
Self { path, name }
|
||||
}
|
||||
|
||||
pub fn execute(self, variables: Vec<CuddleVariable>) -> anyhow::Result<()> {
|
||||
log::debug!("executing shell action: {}", self.path.clone());
|
||||
|
||||
log::info!("Starting running shell action: {}", self.path.clone());
|
||||
|
||||
let path = PathBuf::from(self.path.clone());
|
||||
if !path.exists() {
|
||||
log::info!("script='{}' not found, aborting", path.to_string_lossy());
|
||||
return Err(anyhow::anyhow!("file not found aborting"));
|
||||
}
|
||||
|
||||
let current_dir = current_dir()?;
|
||||
log::trace!("current executable dir={}", current_dir.to_string_lossy());
|
||||
|
||||
let mut process = Command::new(&path)
|
||||
.current_dir(current_dir)
|
||||
.envs(variables.iter().rev().map(|v| {
|
||||
log::trace!("{:?}", v);
|
||||
|
||||
(v.name.to_uppercase(), v.value.clone())
|
||||
}))
|
||||
.spawn()?;
|
||||
|
||||
let status = process.wait()?;
|
||||
|
||||
match status.code() {
|
||||
None => {
|
||||
log::warn!("process exited without code")
|
||||
}
|
||||
Some(n) => {
|
||||
if n > 0 {
|
||||
return Err(anyhow::anyhow!(
|
||||
"{} exited with: {}",
|
||||
path.clone().to_string_lossy(),
|
||||
n
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log::info!("Finished running shell action");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -1,413 +0,0 @@
|
||||
mod subcommands;
|
||||
|
||||
use std::{
|
||||
path::PathBuf,
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
use clap::Command;
|
||||
|
||||
use crate::{
|
||||
actions::CuddleAction,
|
||||
config::{CuddleConfig, CuddleFetchPolicy},
|
||||
context::{CuddleContext, CuddleTreeType},
|
||||
model::*,
|
||||
util::git::GitCommit,
|
||||
};
|
||||
|
||||
use self::subcommands::{
|
||||
render::RenderCommand, render_kustomize::RenderKustomizeCommand,
|
||||
render_template::RenderTemplateCommand,
|
||||
};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct CuddleCli {
|
||||
scripts: Vec<CuddleAction>,
|
||||
variables: Vec<CuddleVariable>,
|
||||
context: Option<Arc<Mutex<Vec<CuddleContext>>>>,
|
||||
command: Option<Command>,
|
||||
tmp_dir: Option<PathBuf>,
|
||||
config: CuddleConfig,
|
||||
}
|
||||
|
||||
impl CuddleCli {
|
||||
pub fn new(
|
||||
context: Option<Arc<Mutex<Vec<CuddleContext>>>>,
|
||||
config: CuddleConfig,
|
||||
) -> anyhow::Result<CuddleCli> {
|
||||
let mut cli = CuddleCli {
|
||||
scripts: vec![],
|
||||
variables: vec![],
|
||||
context: context.clone(),
|
||||
command: None,
|
||||
tmp_dir: None,
|
||||
config,
|
||||
};
|
||||
|
||||
if let Ok(provider) = std::env::var("CUDDLE_SECRETS_PROVIDER") {
|
||||
let provider = provider
|
||||
.split(",")
|
||||
.map(|p| p.to_string())
|
||||
.collect::<Vec<_>>();
|
||||
tracing::trace!("secrets-provider enabled, handling for each entry");
|
||||
handle_providers(provider)?;
|
||||
std::thread::sleep(std::time::Duration::from_millis(100));
|
||||
}
|
||||
|
||||
match context {
|
||||
Some(_) => {
|
||||
tracing::debug!("build full cli");
|
||||
cli = cli
|
||||
.process_variables()
|
||||
.process_scripts()
|
||||
.process_templates()?
|
||||
.build_cli();
|
||||
}
|
||||
None => {
|
||||
tracing::debug!("build bare cli");
|
||||
cli = cli.build_bare_cli();
|
||||
}
|
||||
}
|
||||
|
||||
Ok(cli)
|
||||
}
|
||||
|
||||
fn process_variables(mut self) -> Self {
|
||||
if let Ok(context_iter) = self.context.clone().unwrap().lock() {
|
||||
for ctx in context_iter.iter() {
|
||||
if let Some(variables) = ctx.plan.vars.clone() {
|
||||
let mut variables: Vec<CuddleVariable> = variables.into();
|
||||
self.variables.append(&mut variables);
|
||||
}
|
||||
|
||||
if let CuddleTreeType::Root = ctx.node_type {
|
||||
let mut temp_path = ctx.path.clone();
|
||||
temp_path.push(".cuddle/tmp");
|
||||
|
||||
self.variables.push(CuddleVariable::new(
|
||||
"tmp",
|
||||
temp_path.clone().to_string_lossy().to_string(),
|
||||
));
|
||||
|
||||
self.tmp_dir = Some(temp_path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match GitCommit::new() {
|
||||
Ok(commit) => self
|
||||
.variables
|
||||
.push(CuddleVariable::new("commit_sha", commit.commit_sha.clone())),
|
||||
Err(e) => {
|
||||
log::debug!("{}", e);
|
||||
}
|
||||
}
|
||||
|
||||
self
|
||||
}
|
||||
|
||||
fn process_scripts(mut self) -> Self {
|
||||
if let Ok(context_iter) = self.context.clone().unwrap().lock() {
|
||||
for ctx in context_iter.iter() {
|
||||
if let Some(scripts) = ctx.plan.scripts.clone() {
|
||||
for (name, script) in scripts {
|
||||
match &script {
|
||||
CuddleScript::Shell(shell_script) => {
|
||||
self.scripts.push(CuddleAction::new(
|
||||
script.clone(),
|
||||
ctx.path.clone(),
|
||||
name,
|
||||
shell_script.description.clone(),
|
||||
))
|
||||
}
|
||||
CuddleScript::Dagger(_) => todo!(),
|
||||
CuddleScript::Lua(l) => self.scripts.push(CuddleAction::new(
|
||||
script.clone(),
|
||||
ctx.path.clone(),
|
||||
name,
|
||||
l.description.clone(),
|
||||
)),
|
||||
CuddleScript::Rust(_) => todo!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self
|
||||
}
|
||||
|
||||
fn process_templates(self) -> anyhow::Result<Self> {
|
||||
if self.tmp_dir.is_none() {
|
||||
log::debug!("cannot process template as bare bones cli");
|
||||
return Ok(self);
|
||||
}
|
||||
|
||||
// Make sure tmp_dir exists and clean it up first
|
||||
let tmp_dir = self
|
||||
.tmp_dir
|
||||
.clone()
|
||||
.ok_or(anyhow::anyhow!("tmp_dir does not exist aborting"))?;
|
||||
match self.config.get_fetch_policy()? {
|
||||
CuddleFetchPolicy::Always if tmp_dir.exists() && tmp_dir.ends_with("tmp") => {
|
||||
std::fs::remove_dir_all(tmp_dir.clone())?;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
std::fs::create_dir_all(tmp_dir.clone())?;
|
||||
// Handle all templating with variables and such.
|
||||
// TODO: use actual templating engine, for new we just copy templates to the final folder
|
||||
|
||||
if let Ok(context_iter) = self.context.clone().unwrap().lock() {
|
||||
for ctx in context_iter.iter() {
|
||||
let mut template_path = ctx.path.clone();
|
||||
template_path.push("templates");
|
||||
|
||||
log::trace!("template path: {}", template_path.clone().to_string_lossy());
|
||||
|
||||
if !template_path.exists() {
|
||||
continue;
|
||||
}
|
||||
|
||||
for file in std::fs::read_dir(&template_path)? {
|
||||
let f = file?;
|
||||
let mut dest_file = tmp_dir.clone();
|
||||
dest_file.push(f.path().strip_prefix(&template_path)?.parent().unwrap());
|
||||
|
||||
tracing::trace!(
|
||||
"moving from: {} to {}",
|
||||
f.path().display(),
|
||||
dest_file.display()
|
||||
);
|
||||
|
||||
if f.path().is_dir() {
|
||||
std::fs::create_dir_all(&dest_file)?;
|
||||
}
|
||||
|
||||
fs_extra::copy_items(
|
||||
&[f.path()],
|
||||
&dest_file,
|
||||
&fs_extra::dir::CopyOptions {
|
||||
overwrite: true,
|
||||
skip_exist: false,
|
||||
..Default::default()
|
||||
},
|
||||
)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(self)
|
||||
}
|
||||
|
||||
fn build_cli(mut self) -> Self {
|
||||
let mut root_cmd = Command::new("cuddle")
|
||||
.version("1.0")
|
||||
.author("kjuulh <contact@kasperhermansen.com>")
|
||||
.about("cuddle is your domain specific organization tool. It enabled widespread sharing through repositories, as well as collaborating while maintaining speed and integrity")
|
||||
.subcommand_required(true)
|
||||
.arg_required_else_help(true)
|
||||
.propagate_version(true)
|
||||
.arg(clap::Arg::new("secrets-provider").long("secrets-provider").env("CUDDLE_SECRETS_PROVIDER"));
|
||||
|
||||
root_cmd = subcommands::x::build_command(root_cmd, self.clone());
|
||||
root_cmd = subcommands::render_template::build_command(root_cmd);
|
||||
root_cmd = subcommands::render_kustomize::build_command(root_cmd);
|
||||
root_cmd = subcommands::render::build_command(root_cmd);
|
||||
root_cmd = subcommands::init::build_command(root_cmd, self.clone());
|
||||
|
||||
self.command = Some(root_cmd);
|
||||
|
||||
self
|
||||
}
|
||||
|
||||
fn build_bare_cli(mut self) -> Self {
|
||||
let mut root_cmd = Command::new("cuddle")
|
||||
.version("1.0")
|
||||
.author("kjuulh <contact@kasperhermansen.com>")
|
||||
.about("cuddle is your domain specific organization tool. It enabled widespread sharing through repositories, as well as collaborating while maintaining speed and integrity")
|
||||
.subcommand_required(true)
|
||||
.arg_required_else_help(true)
|
||||
.propagate_version(true);
|
||||
|
||||
root_cmd = subcommands::init::build_command(root_cmd, self.clone());
|
||||
|
||||
self.command = Some(root_cmd);
|
||||
|
||||
self
|
||||
}
|
||||
|
||||
pub fn execute(self) -> anyhow::Result<Self> {
|
||||
if let Some(cli) = self.command.clone() {
|
||||
let matches = cli.clone().get_matches();
|
||||
|
||||
let res = match matches.subcommand() {
|
||||
Some(("x", exe_submatch)) => subcommands::x::execute_x(exe_submatch, self.clone()),
|
||||
Some(("render", sub_matches)) => {
|
||||
RenderCommand::execute(sub_matches, self.clone())?;
|
||||
Ok(())
|
||||
}
|
||||
Some(("render_template", sub_matches)) => {
|
||||
RenderTemplateCommand::from_matches(sub_matches, self.clone())
|
||||
.and_then(|cmd| cmd.execute())?;
|
||||
Ok(())
|
||||
}
|
||||
Some(("render-kustomize", sub_matches)) => {
|
||||
RenderKustomizeCommand::from_matches(sub_matches, self.clone())
|
||||
.and_then(|cmd| cmd.execute())?;
|
||||
Ok(())
|
||||
}
|
||||
Some(("init", sub_matches)) => {
|
||||
subcommands::init::execute_init(sub_matches, self.clone())
|
||||
}
|
||||
_ => Err(anyhow::anyhow!("could not find a match")),
|
||||
};
|
||||
|
||||
match res {
|
||||
Ok(()) => {}
|
||||
Err(e) => {
|
||||
return Err(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(self)
|
||||
}
|
||||
}
|
||||
|
||||
pub enum SecretProvider {
|
||||
OnePassword {
|
||||
inject: Vec<String>,
|
||||
dotenv: Option<String>,
|
||||
},
|
||||
}
|
||||
|
||||
impl TryFrom<String> for SecretProvider {
|
||||
type Error = anyhow::Error;
|
||||
|
||||
fn try_from(value: String) -> Result<Self, Self::Error> {
|
||||
match value.as_str() {
|
||||
"1password" => {
|
||||
let one_password_inject = std::env::var("CUDDLE_ONE_PASSWORD_INJECT")
|
||||
.ok()
|
||||
.filter(|f| f.as_str() != "");
|
||||
let one_password_dot_env = std::env::var("CUDDLE_ONE_PASSWORD_DOT_ENV").ok();
|
||||
|
||||
let injectables = one_password_inject
|
||||
.unwrap_or(String::new())
|
||||
.split(",")
|
||||
.filter(|s| s.contains('='))
|
||||
.map(|i| i.to_string())
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
// for i in &injectables {
|
||||
// if !std::path::PathBuf::from(i).exists() {
|
||||
// anyhow::bail!("1pass injectable path doesn't exist: {}", i);
|
||||
// }
|
||||
// }
|
||||
if let Some(one_password_dot_env) = &one_password_dot_env {
|
||||
if let Ok(dir) = std::env::current_dir() {
|
||||
tracing::trace!(
|
||||
current_dir = dir.display().to_string(),
|
||||
dotenv = &one_password_dot_env,
|
||||
exists = PathBuf::from(&one_password_dot_env).exists(),
|
||||
"1password dotenv inject"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Self::OnePassword {
|
||||
inject: injectables,
|
||||
dotenv: if let Some(one_password_dot_env) = one_password_dot_env {
|
||||
if PathBuf::from(&one_password_dot_env).exists() {
|
||||
Some(one_password_dot_env)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
} else {
|
||||
None
|
||||
},
|
||||
})
|
||||
}
|
||||
value => {
|
||||
tracing::debug!(
|
||||
"provided secrets manager doesn't match any allowed values {}",
|
||||
value
|
||||
);
|
||||
Err(anyhow::anyhow!("value is not one of supported values"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_providers(provider: Vec<String>) -> anyhow::Result<()> {
|
||||
fn execute_1password(lookup: &str) -> anyhow::Result<String> {
|
||||
let out = std::process::Command::new("op")
|
||||
.arg("read")
|
||||
.arg(lookup)
|
||||
.output()?;
|
||||
let secret = std::str::from_utf8(&out.stdout)?;
|
||||
Ok(secret.to_string())
|
||||
}
|
||||
|
||||
fn execute_1password_inject(file: &str) -> anyhow::Result<Vec<(String, String)>> {
|
||||
let out = std::process::Command::new("op")
|
||||
.arg("inject")
|
||||
.arg("--in-file")
|
||||
.arg(file)
|
||||
.output()?;
|
||||
let secrets = std::str::from_utf8(&out.stdout)?.split('\n');
|
||||
let secrets_pair = secrets
|
||||
.map(|secrets_pair| secrets_pair.split_once("="))
|
||||
.flatten()
|
||||
.map(|(key, value)| (key.to_string(), value.to_string()))
|
||||
.collect::<Vec<(String, String)>>();
|
||||
|
||||
Ok(secrets_pair)
|
||||
}
|
||||
|
||||
let res = provider
|
||||
.into_iter()
|
||||
.map(|p| SecretProvider::try_from(p))
|
||||
.collect::<anyhow::Result<Vec<_>>>();
|
||||
let res = res?;
|
||||
|
||||
let res = res
|
||||
.into_iter()
|
||||
.map(|p| match p {
|
||||
SecretProvider::OnePassword { inject, dotenv } => {
|
||||
tracing::trace!(
|
||||
inject = inject.join(","),
|
||||
dotenv = dotenv,
|
||||
"handling 1password"
|
||||
);
|
||||
if let Some(dotenv) = dotenv {
|
||||
let pairs = execute_1password_inject(&dotenv).unwrap();
|
||||
for (key, value) in pairs {
|
||||
tracing::debug!(env_name = &key, value=&value, "set var from 1password");
|
||||
std::env::set_var(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
for i in inject {
|
||||
let (env_var_name, op_lookup) = i.split_once("=").ok_or(anyhow::anyhow!(
|
||||
"CUDDLE_ONE_PASSWORD_INJECT is not a key value pair ie. key:value,key2=value2"
|
||||
))?;
|
||||
let secret = execute_1password(&op_lookup)?;
|
||||
std::env::set_var(&env_var_name, secret);
|
||||
tracing::debug!(
|
||||
env_name = &env_var_name,
|
||||
lookup = &op_lookup,
|
||||
"set var from 1password"
|
||||
);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
})
|
||||
.collect::<anyhow::Result<Vec<()>>>();
|
||||
|
||||
let _ = res?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@ -1,169 +0,0 @@
|
||||
use std::{collections::HashMap, path::PathBuf};
|
||||
|
||||
use anyhow::Context;
|
||||
use clap::{Arg, ArgAction, ArgMatches, Command};
|
||||
use serde_json::from_value;
|
||||
use tera::Function;
|
||||
|
||||
use crate::{cli::CuddleCli, model::CuddleVariable};
|
||||
|
||||
pub fn build_command(root_cmd: Command) -> Command {
|
||||
root_cmd.subcommand(
|
||||
Command::new("folder")
|
||||
.about("renders a template folder")
|
||||
.args(&[
|
||||
Arg::new("source")
|
||||
.long("source")
|
||||
.required(true)
|
||||
.value_parser(clap::value_parser!(PathBuf)),
|
||||
Arg::new("destination")
|
||||
.long("destination")
|
||||
.required(true)
|
||||
.value_parser(clap::value_parser!(PathBuf)),
|
||||
Arg::new("extra-var")
|
||||
.long("extra-var")
|
||||
.action(ArgAction::Append)
|
||||
.required(false),
|
||||
]),
|
||||
)
|
||||
}
|
||||
|
||||
pub struct FolderCommand {
|
||||
variables: Vec<CuddleVariable>,
|
||||
source: PathBuf,
|
||||
destination: PathBuf,
|
||||
}
|
||||
|
||||
impl FolderCommand {
|
||||
pub fn from_matches(matches: &ArgMatches, cli: CuddleCli) -> anyhow::Result<Self> {
|
||||
let source = matches
|
||||
.get_one::<PathBuf>("source")
|
||||
.expect("source")
|
||||
.clone();
|
||||
|
||||
let destination = matches
|
||||
.get_one::<PathBuf>("destination")
|
||||
.expect("destination")
|
||||
.clone();
|
||||
|
||||
let mut extra_vars: Vec<CuddleVariable> =
|
||||
if let Some(extra_vars) = matches.get_many::<String>("extra-var") {
|
||||
let mut vars = Vec::with_capacity(extra_vars.len());
|
||||
for var in extra_vars.into_iter() {
|
||||
let parts: Vec<&str> = var.split('=').collect();
|
||||
if parts.len() != 2 {
|
||||
return Err(anyhow::anyhow!("extra-var: is not set correctly: {}", var));
|
||||
}
|
||||
|
||||
vars.push(CuddleVariable::new(parts[0], parts[1]));
|
||||
}
|
||||
vars
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
|
||||
extra_vars.append(&mut cli.variables.clone());
|
||||
|
||||
Ok(Self {
|
||||
variables: extra_vars,
|
||||
source,
|
||||
destination,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn execute(self) -> anyhow::Result<()> {
|
||||
let _ = std::fs::remove_dir_all(&self.destination);
|
||||
std::fs::create_dir_all(&self.destination).context("failed to create directory")?;
|
||||
|
||||
// Prepare context
|
||||
let mut context = tera::Context::new();
|
||||
for var in self.variables.iter().rev() {
|
||||
context.insert(var.name.to_lowercase().replace([' ', '-'], "_"), &var.value)
|
||||
}
|
||||
|
||||
let mut tera = tera::Tera::default();
|
||||
|
||||
tera.register_function("filter_by_prefix", filter_by_prefix(self.variables.clone()));
|
||||
|
||||
for entry in walkdir::WalkDir::new(&self.source) {
|
||||
let entry = entry.context("entry was not found")?;
|
||||
let entry_path = entry.path();
|
||||
let rel_path = self
|
||||
.destination
|
||||
.join(entry_path.strip_prefix(&self.source)?);
|
||||
|
||||
if entry_path.is_file() {
|
||||
// Load source template
|
||||
let source = std::fs::read_to_string(entry_path)
|
||||
.context("failed to read entry into memory")?;
|
||||
|
||||
let output = tera.render_str(&source, &context)?;
|
||||
|
||||
if let Some(parent) = rel_path.parent() {
|
||||
std::fs::create_dir_all(parent).context("failed to create parent dir")?;
|
||||
}
|
||||
|
||||
// Put template in final destination
|
||||
std::fs::write(&rel_path, output).context(format!(
|
||||
"failed to write to destination: {}",
|
||||
&rel_path.display()
|
||||
))?;
|
||||
|
||||
log::info!("finished writing template to: {}", &rel_path.display());
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn filter_by_prefix(variables: Vec<CuddleVariable>) -> impl Function {
|
||||
Box::new(
|
||||
move |args: &HashMap<String, tera::Value>| -> tera::Result<tera::Value> {
|
||||
for var in &variables {
|
||||
tracing::info!("variable: {} - {}", var.name, var.value);
|
||||
}
|
||||
|
||||
let prefix = match args.get("prefix") {
|
||||
Some(value) => match from_value::<Vec<String>>(value.clone()) {
|
||||
Ok(prefix) => prefix,
|
||||
Err(e) => {
|
||||
tracing::error!("prefix was not a string: {}", e);
|
||||
return Err("prefix was not a string".into());
|
||||
}
|
||||
},
|
||||
None => return Err("prefix is required".into()),
|
||||
};
|
||||
|
||||
let prefix = prefix.join("_");
|
||||
|
||||
let vars = variables
|
||||
.iter()
|
||||
.filter_map(|v| {
|
||||
if v.name.starts_with(&prefix) {
|
||||
Some(CuddleVariable::new(
|
||||
v.name.trim_start_matches(&prefix).trim_start_matches('_'),
|
||||
v.value.clone(),
|
||||
))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<CuddleVariable>>();
|
||||
|
||||
let mut structure: HashMap<String, String> = HashMap::new();
|
||||
for var in vars {
|
||||
if !structure.contains_key(&var.name) {
|
||||
tracing::info!("found: {} - {}", &var.name, &var.value);
|
||||
structure.insert(var.name, var.value);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(serde_json::to_value(structure).unwrap())
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
fn filter_by_name(args: &HashMap<String, tera::Value>) -> tera::Result<tera::Value> {
|
||||
Ok(tera::Value::Null)
|
||||
}
|
||||
@ -1,227 +0,0 @@
|
||||
use std::collections::BTreeMap;
|
||||
use std::fs::{create_dir_all, read, read_dir};
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use anyhow::Context;
|
||||
use clap::{ArgMatches, Command};
|
||||
use walkdir::WalkDir;
|
||||
|
||||
use crate::cli::CuddleCli;
|
||||
|
||||
pub fn build_command(root_cmd: Command, _cli: CuddleCli) -> Command {
|
||||
let mut repo_url = clap::Arg::new("repo").long("repo").short('r');
|
||||
|
||||
if let Ok(cuddle_template_url) = std::env::var("CUDDLE_TEMPLATE_URL") {
|
||||
repo_url = repo_url.default_value(cuddle_template_url);
|
||||
} else {
|
||||
repo_url = repo_url.required(true);
|
||||
}
|
||||
|
||||
let execute_cmd = Command::new("init")
|
||||
.about("init bootstraps a repository from a template")
|
||||
.arg(repo_url)
|
||||
.arg(clap::Arg::new("name").long("name"))
|
||||
.arg(clap::Arg::new("path").long("path"))
|
||||
.arg(clap::Arg::new("value").short('v').long("value"));
|
||||
|
||||
root_cmd.subcommand(execute_cmd)
|
||||
}
|
||||
|
||||
pub fn execute_init(exe_submatch: &ArgMatches, _cli: CuddleCli) -> anyhow::Result<()> {
|
||||
let repo = exe_submatch.get_one::<String>("repo").unwrap();
|
||||
let name = exe_submatch.get_one::<String>("name");
|
||||
let path = exe_submatch.get_one::<String>("path");
|
||||
let values = exe_submatch
|
||||
.get_many::<String>("value")
|
||||
.unwrap_or_default()
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
tracing::info!("Downloading: {}", repo);
|
||||
|
||||
create_dir_all(std::env::temp_dir())?;
|
||||
|
||||
let tmpdir = tempfile::tempdir()?;
|
||||
|
||||
let tmpdir_path = tmpdir.path().canonicalize()?;
|
||||
|
||||
let output = std::process::Command::new("git")
|
||||
.args(&["clone", repo, "."])
|
||||
.current_dir(tmpdir_path)
|
||||
.output()?;
|
||||
|
||||
std::io::stdout().write_all(&output.stdout)?;
|
||||
std::io::stderr().write_all(&output.stderr)?;
|
||||
|
||||
let templates_path = tmpdir.path().join("cuddle-templates.json");
|
||||
let template_path = tmpdir.path().join("cuddle-template.json");
|
||||
let templates = if templates_path.exists() {
|
||||
let templates = read(templates_path)?;
|
||||
let templates: CuddleTemplates = serde_json::from_slice(&templates)?;
|
||||
|
||||
let mut single_templates = Vec::new();
|
||||
|
||||
for template_name in templates.templates.iter() {
|
||||
let template = read(
|
||||
tmpdir
|
||||
.path()
|
||||
.join(template_name)
|
||||
.join("cuddle-template.json"),
|
||||
)?;
|
||||
let template = serde_json::from_slice::<CuddleTemplate>(&template)?;
|
||||
|
||||
single_templates.push((template_name, template))
|
||||
}
|
||||
|
||||
single_templates
|
||||
.into_iter()
|
||||
.map(|(name, template)| (name.clone(), tmpdir.path().join(name), template))
|
||||
.collect::<Vec<_>>()
|
||||
} else if template_path.exists() {
|
||||
let template = read(template_path)?;
|
||||
let template = serde_json::from_slice::<CuddleTemplate>(&template)?;
|
||||
vec![(template.clone().name, tmpdir.path().to_path_buf(), template)]
|
||||
} else {
|
||||
anyhow::bail!("No cuddle-template.json or cuddle-templates.json found");
|
||||
};
|
||||
|
||||
let template = match name {
|
||||
Some(name) => {
|
||||
let template = read(tmpdir.path().join(name).join("cuddle-template.json"))?;
|
||||
let template = serde_json::from_slice::<CuddleTemplate>(&template)?;
|
||||
Ok((name.clone(), tmpdir.path().join(name), template))
|
||||
}
|
||||
None => {
|
||||
if templates.len() > 1 {
|
||||
let name = inquire::Select::new(
|
||||
"template",
|
||||
templates.iter().map(|t| t.0.clone()).collect(),
|
||||
)
|
||||
.with_help_message("name of which template to use")
|
||||
.prompt()?;
|
||||
|
||||
let found_template = templates
|
||||
.iter()
|
||||
.find(|item| item.0 == name)
|
||||
.ok_or(anyhow::anyhow!("could not find an item with that name"))?;
|
||||
|
||||
Ok(found_template.clone())
|
||||
} else if templates.len() == 1 {
|
||||
Ok(templates[0].clone())
|
||||
} else {
|
||||
Err(anyhow::anyhow!("No templates found, with any valid names"))
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let (_name, template_dir, mut template) = template?;
|
||||
|
||||
let path = match path {
|
||||
Some(path) => path.clone(),
|
||||
None => inquire::Text::new("path")
|
||||
.with_help_message("to where it should be placed")
|
||||
.with_default(".")
|
||||
.prompt()?,
|
||||
};
|
||||
|
||||
create_dir_all(&path)?;
|
||||
let dir = std::fs::read_dir(&path)?;
|
||||
if dir.count() != 0 {
|
||||
for entry in read_dir(&path)? {
|
||||
let entry = entry?;
|
||||
if entry.file_name() == ".git" {
|
||||
continue;
|
||||
} else {
|
||||
anyhow::bail!("Directory {} is not empty", &path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
if let Some(ref mut prompt) = template.prompt {
|
||||
'prompt: for (name, prompt) in prompt {
|
||||
for value in &values {
|
||||
if let Some((value_name, value_content)) = value.split_once("=") {
|
||||
if value_name == name {
|
||||
prompt.value = value_content.to_string();
|
||||
continue 'prompt;
|
||||
}
|
||||
}
|
||||
}
|
||||
let value = inquire::Text::new(&name)
|
||||
.with_help_message(&prompt.description)
|
||||
.prompt()?;
|
||||
prompt.value = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for entry in WalkDir::new(&template_dir).follow_links(false) {
|
||||
let entry = entry?;
|
||||
let entry_path = entry.path();
|
||||
|
||||
let new_path = PathBuf::from(&path).join(entry_path.strip_prefix(&template_dir)?);
|
||||
let new_path = replace_with_variables(&new_path.to_string_lossy().to_string(), &template)?;
|
||||
let new_path = PathBuf::from(new_path);
|
||||
|
||||
if entry_path.is_dir() {
|
||||
create_dir_all(&new_path)?;
|
||||
}
|
||||
|
||||
if entry_path.is_file() {
|
||||
let name = entry.file_name();
|
||||
if let Some(parent) = entry_path.parent() {
|
||||
create_dir_all(parent)?;
|
||||
}
|
||||
|
||||
if name == "cuddle-template.json" || name == "cuddle-templates.json" {
|
||||
continue;
|
||||
}
|
||||
|
||||
tracing::info!("writing to: {}", new_path.display());
|
||||
|
||||
let old_content = match std::fs::read_to_string(entry_path) {
|
||||
Ok(e) => e,
|
||||
Err(e) => {
|
||||
tracing::debug!("found invalid file possibly with invalid utf8: {}", e);
|
||||
std::fs::copy(entry_path, new_path).context("failed to write file")?;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let new_content = replace_with_variables(&old_content, &template)?;
|
||||
|
||||
std::fs::write(new_path, new_content.as_bytes())?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn replace_with_variables(content: &str, template: &CuddleTemplate) -> anyhow::Result<String> {
|
||||
let mut content = content.to_string();
|
||||
if let Some(prompt) = &template.prompt {
|
||||
for (name, value) in prompt {
|
||||
content = content.replace(&format!("%%{}%%", name), &value.value);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(content)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
||||
struct CuddleTemplates {
|
||||
pub templates: Vec<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
||||
struct CuddleTemplate {
|
||||
pub name: String,
|
||||
pub prompt: Option<BTreeMap<String, CuddleTemplatePrompt>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
||||
struct CuddleTemplatePrompt {
|
||||
pub description: String,
|
||||
#[serde(skip)]
|
||||
pub value: String,
|
||||
}
|
||||
@ -1,91 +0,0 @@
|
||||
use std::{io::Write, path::PathBuf};
|
||||
|
||||
use anyhow::Context;
|
||||
use clap::{Arg, ArgMatches, Command};
|
||||
|
||||
use crate::cli::CuddleCli;
|
||||
|
||||
pub fn build_command(root_cmd: Command) -> Command {
|
||||
root_cmd.subcommand(
|
||||
Command::new("kustomize")
|
||||
.about("renders a kustomize folder")
|
||||
.args(&[
|
||||
Arg::new("kustomize-folder")
|
||||
.long("kustomize-folder")
|
||||
.value_parser(clap::value_parser!(PathBuf))
|
||||
.required(true),
|
||||
Arg::new("destination")
|
||||
.long("destination")
|
||||
.required(true)
|
||||
.value_parser(clap::value_parser!(PathBuf)),
|
||||
]),
|
||||
)
|
||||
}
|
||||
|
||||
pub struct KustomizeCommand {
|
||||
kustomize_folder: PathBuf,
|
||||
destination: PathBuf,
|
||||
}
|
||||
|
||||
impl KustomizeCommand {
|
||||
pub fn from_matches(matches: &ArgMatches, _cli: CuddleCli) -> anyhow::Result<Self> {
|
||||
let kustomize_folder = matches
|
||||
.get_one::<PathBuf>("kustomize-folder")
|
||||
.expect("kustomize-folder")
|
||||
.clone();
|
||||
|
||||
let destination = matches
|
||||
.get_one::<PathBuf>("destination")
|
||||
.expect("destination")
|
||||
.clone();
|
||||
|
||||
Ok(Self {
|
||||
kustomize_folder,
|
||||
destination,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn execute(self) -> anyhow::Result<()> {
|
||||
let mut cmd = std::process::Command::new("kubectl");
|
||||
|
||||
let _ = std::fs::remove_dir_all(&self.destination);
|
||||
std::fs::create_dir_all(&self.destination)?;
|
||||
|
||||
let cmd = cmd
|
||||
.arg("kustomize")
|
||||
.arg("--enable-helm")
|
||||
.arg(self.kustomize_folder);
|
||||
let output = cmd.output().context("failed to run kubectl kustomize")?;
|
||||
|
||||
if !output.status.success() {
|
||||
anyhow::bail!(
|
||||
"failed to run kustomize: {}",
|
||||
output.status.code().expect("to find exit code")
|
||||
)
|
||||
}
|
||||
|
||||
let mut cmd = std::process::Command::new("kubectl-slice");
|
||||
let cmd = cmd
|
||||
.arg("-o")
|
||||
.arg(self.destination)
|
||||
.stdin(std::process::Stdio::piped());
|
||||
|
||||
let mut child = cmd.spawn().context("failed to run kubectl-slice")?;
|
||||
|
||||
if let Some(mut stdin) = child.stdin.take() {
|
||||
stdin.write_all(&output.stdout)?;
|
||||
}
|
||||
|
||||
let output = child
|
||||
.wait_with_output()
|
||||
.context("failed to run kubectl-slice")?;
|
||||
if !output.status.success() {
|
||||
anyhow::bail!(
|
||||
"failed to run kustomize: {}",
|
||||
output.status.code().expect("to find exit code")
|
||||
)
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
pub mod folder;
|
||||
pub mod init;
|
||||
pub mod kustomize;
|
||||
pub mod render;
|
||||
pub mod render_kustomize;
|
||||
pub mod render_template;
|
||||
pub mod x;
|
||||
@ -1,34 +0,0 @@
|
||||
use anyhow::Context;
|
||||
use clap::{ArgMatches, Command};
|
||||
|
||||
use crate::cli::CuddleCli;
|
||||
|
||||
use super::{folder::FolderCommand, kustomize::KustomizeCommand};
|
||||
|
||||
pub fn build_command(root_cmd: Command) -> Command {
|
||||
let cmd = Command::new("render").about("accesses different render commands");
|
||||
|
||||
let cmd = super::kustomize::build_command(cmd);
|
||||
let cmd = super::folder::build_command(cmd);
|
||||
|
||||
root_cmd.subcommand(cmd)
|
||||
}
|
||||
|
||||
pub struct RenderCommand {}
|
||||
impl RenderCommand {
|
||||
pub fn execute(matches: &ArgMatches, cli: CuddleCli) -> anyhow::Result<()> {
|
||||
match matches.subcommand() {
|
||||
Some(("kustomize", sub_matches)) => {
|
||||
KustomizeCommand::from_matches(sub_matches, cli)?.execute()?;
|
||||
}
|
||||
Some(("folder", sub_matches)) => {
|
||||
FolderCommand::from_matches(sub_matches, cli)?
|
||||
.execute()
|
||||
.context("failed to render folder")?;
|
||||
}
|
||||
_ => anyhow::bail!("failed to find match for render"),
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -1,70 +0,0 @@
|
||||
use std::path::PathBuf;
|
||||
|
||||
use clap::{Arg, ArgMatches, Command};
|
||||
|
||||
use crate::cli::CuddleCli;
|
||||
|
||||
pub fn build_command(root_cmd: Command) -> Command {
|
||||
root_cmd.subcommand(
|
||||
Command::new("render-kustomize")
|
||||
.about("renders a kustomize folder")
|
||||
.args(&[
|
||||
Arg::new("kustomize-folder")
|
||||
.long("kustomize-folder")
|
||||
.value_parser(clap::value_parser!(PathBuf))
|
||||
.required(true),
|
||||
Arg::new("destination")
|
||||
.long("destination")
|
||||
.required(true)
|
||||
.value_parser(clap::value_parser!(PathBuf)),
|
||||
]),
|
||||
)
|
||||
}
|
||||
|
||||
pub struct RenderKustomizeCommand {
|
||||
kustomize_folder: PathBuf,
|
||||
destination: PathBuf,
|
||||
}
|
||||
|
||||
impl RenderKustomizeCommand {
|
||||
pub fn from_matches(matches: &ArgMatches, _cli: CuddleCli) -> anyhow::Result<Self> {
|
||||
let kustomize_folder = matches
|
||||
.get_one::<PathBuf>("kustomize-folder")
|
||||
.expect("kustomize-folder")
|
||||
.clone();
|
||||
|
||||
let destination = matches
|
||||
.get_one::<PathBuf>("destination")
|
||||
.expect("destination")
|
||||
.clone();
|
||||
|
||||
Ok(Self {
|
||||
kustomize_folder,
|
||||
destination,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn execute(self) -> anyhow::Result<()> {
|
||||
let mut cmd = std::process::Command::new("kubectl");
|
||||
|
||||
std::fs::create_dir_all(&self.destination)?;
|
||||
|
||||
let cmd = cmd
|
||||
.arg("kustomize")
|
||||
.arg(self.kustomize_folder)
|
||||
.arg(format!("--output={}", self.destination.display()));
|
||||
|
||||
let mut process = cmd.spawn()?;
|
||||
|
||||
let exit = process.wait()?;
|
||||
|
||||
if !exit.success() {
|
||||
anyhow::bail!(
|
||||
"failed to run kustomize: {}",
|
||||
exit.code().expect("to find exit code")
|
||||
)
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -1,153 +0,0 @@
|
||||
use std::{path::PathBuf, str::FromStr};
|
||||
|
||||
use anyhow::Context;
|
||||
use clap::{Arg, ArgMatches, Command};
|
||||
|
||||
use crate::{cli::CuddleCli, model::CuddleVariable};
|
||||
|
||||
const DESTINATION: &str = "destination is the output path of the template once done, but default .tmpl is stripped and the normal file extension is used. this can be overwritten if a file path is entered instead. I.e. (/some/file/name.txt)";
|
||||
const TEMPLATE_FILE: &str = "template-file is the input file path of the .tmpl file (or inferred) that you would like to render";
|
||||
|
||||
pub fn build_command(root_cmd: Command) -> Command {
|
||||
root_cmd.subcommand(
|
||||
Command::new("render_template")
|
||||
.about("renders a jinja compatible template")
|
||||
.args(&[
|
||||
Arg::new("template-file")
|
||||
.alias("template")
|
||||
.short('t')
|
||||
.long("template-file")
|
||||
.required(true)
|
||||
.action(clap::ArgAction::Set)
|
||||
.long_help(TEMPLATE_FILE),
|
||||
Arg::new("destination")
|
||||
.alias("dest")
|
||||
.short('d')
|
||||
.long("destination")
|
||||
.required(true)
|
||||
.action(clap::ArgAction::Set)
|
||||
.long_help(DESTINATION),
|
||||
Arg::new("extra-var")
|
||||
.long("extra-var")
|
||||
.required(false)
|
||||
.action(clap::ArgAction::Append),
|
||||
]),
|
||||
)
|
||||
}
|
||||
|
||||
pub struct RenderTemplateCommand {
|
||||
variables: Vec<CuddleVariable>,
|
||||
template_file: PathBuf,
|
||||
destination: PathBuf,
|
||||
}
|
||||
|
||||
impl RenderTemplateCommand {
|
||||
pub fn from_matches(matches: &ArgMatches, cli: CuddleCli) -> anyhow::Result<Self> {
|
||||
let template_file = matches
|
||||
.get_one::<String>("template-file")
|
||||
.ok_or(anyhow::anyhow!("template-file was not found"))
|
||||
.and_then(get_path_buf_and_check_exists)?;
|
||||
|
||||
let destination = matches
|
||||
.get_one::<String>("destination")
|
||||
.ok_or(anyhow::anyhow!("destination was not found"))
|
||||
.and_then(get_path_buf_and_check_dir_exists)
|
||||
.and_then(RenderTemplateCommand::transform_extension)
|
||||
.context("failed to access dest directory")?;
|
||||
|
||||
let mut extra_vars: Vec<CuddleVariable> =
|
||||
if let Some(extra_vars) = matches.get_many::<String>("extra-var") {
|
||||
let mut vars = Vec::with_capacity(extra_vars.len());
|
||||
for var in extra_vars.into_iter() {
|
||||
let parts: Vec<&str> = var.split('=').collect();
|
||||
if parts.len() != 2 {
|
||||
return Err(anyhow::anyhow!("extra-var: is not set correctly: {}", var));
|
||||
}
|
||||
|
||||
vars.push(CuddleVariable::new(parts[0], parts[1]));
|
||||
}
|
||||
vars
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
|
||||
extra_vars.append(&mut cli.variables.clone());
|
||||
|
||||
Ok(Self {
|
||||
variables: extra_vars,
|
||||
template_file,
|
||||
destination,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn execute(self) -> anyhow::Result<()> {
|
||||
// Prepare context
|
||||
let mut context = tera::Context::new();
|
||||
for var in self.variables {
|
||||
context.insert(var.name.to_lowercase().replace([' ', '-'], "_"), &var.value)
|
||||
}
|
||||
|
||||
// Load source template
|
||||
let source = std::fs::read_to_string(self.template_file)?;
|
||||
|
||||
let output = tera::Tera::one_off(source.as_str(), &context, false)?;
|
||||
|
||||
if let Some(parent) = self.destination.parent() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
|
||||
// Put template in final destination
|
||||
std::fs::write(&self.destination, output).context(format!(
|
||||
"failed to write to destination: {}",
|
||||
&self.destination.display(),
|
||||
))?;
|
||||
|
||||
log::info!(
|
||||
"finished writing template to: {}",
|
||||
&self.destination.to_string_lossy()
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn transform_extension(template_path: PathBuf) -> anyhow::Result<PathBuf> {
|
||||
if template_path.is_file() {
|
||||
let ext = template_path.extension().ok_or(anyhow::anyhow!(
|
||||
"destination path does not have an extension"
|
||||
))?;
|
||||
if ext.to_string_lossy().ends_with("tmpl") {
|
||||
let template_dest = template_path
|
||||
.to_str()
|
||||
.and_then(|s| s.strip_suffix(".tmpl"))
|
||||
.ok_or(anyhow::anyhow!("string does not end in .tmpl"))?;
|
||||
|
||||
return PathBuf::from_str(template_dest).map_err(|e| anyhow::anyhow!(e));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(template_path)
|
||||
}
|
||||
}
|
||||
|
||||
fn get_path_buf_and_check_exists(raw_path: impl Into<String>) -> anyhow::Result<PathBuf> {
|
||||
match PathBuf::from_str(&raw_path.into()) {
|
||||
Ok(pb) => {
|
||||
if pb.exists() {
|
||||
Ok(pb)
|
||||
} else {
|
||||
Err(anyhow::anyhow!(
|
||||
"path: {}, could not be found",
|
||||
pb.to_string_lossy()
|
||||
))
|
||||
}
|
||||
}
|
||||
Err(e) => Err(anyhow::anyhow!(e)),
|
||||
}
|
||||
}
|
||||
|
||||
fn get_path_buf_and_check_dir_exists(raw_path: impl Into<String>) -> anyhow::Result<PathBuf> {
|
||||
match PathBuf::from_str(&raw_path.into()) {
|
||||
Ok(pb) => Ok(pb),
|
||||
Err(e) => Err(anyhow::anyhow!(e)),
|
||||
}
|
||||
}
|
||||
@ -1,89 +0,0 @@
|
||||
use clap::{Arg, ArgMatches, Command};
|
||||
|
||||
use crate::cli::CuddleCli;
|
||||
|
||||
pub fn build_command(root_cmd: Command, cli: CuddleCli) -> Command {
|
||||
if cli.scripts.len() > 0 {
|
||||
let execute_cmd_about = "x is your entry into your domains scripts, scripts inherited from parents will also be present here";
|
||||
let mut execute_cmd = Command::new("x")
|
||||
.about(execute_cmd_about)
|
||||
.subcommand_required(true);
|
||||
|
||||
execute_cmd = execute_cmd.subcommands(&build_scripts(cli));
|
||||
|
||||
root_cmd.subcommand(execute_cmd)
|
||||
} else {
|
||||
root_cmd
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build_scripts(cli: CuddleCli) -> Vec<Command> {
|
||||
let mut cmds = Vec::new();
|
||||
for script in cli.scripts.iter() {
|
||||
let mut cmd = Command::new(&script.name);
|
||||
|
||||
if let Some(desc) = &script.description {
|
||||
cmd = cmd.about(desc)
|
||||
}
|
||||
|
||||
match &script.script {
|
||||
crate::model::CuddleScript::Shell(shell_script) => {
|
||||
if let Some(args) = &shell_script.args {
|
||||
for (arg_name, arg) in args {
|
||||
cmd = match arg {
|
||||
crate::model::CuddleShellScriptArg::Env(arg_env) => cmd.arg(
|
||||
Arg::new(arg_name.clone())
|
||||
.env(arg_name.to_uppercase().replace(".", "_"))
|
||||
.required(true),
|
||||
),
|
||||
crate::model::CuddleShellScriptArg::Flag(arg_flag) => {
|
||||
let mut arg_val = Arg::new(arg_name.clone())
|
||||
.env(arg_name.to_uppercase().replace(".", "_"))
|
||||
.long(arg_name);
|
||||
|
||||
if let Some(true) = arg_flag.required {
|
||||
arg_val = arg_val.required(true);
|
||||
}
|
||||
|
||||
if let Some(def) = &arg_flag.default_value {
|
||||
arg_val = arg_val.default_value(def);
|
||||
}
|
||||
|
||||
if let Some(desc) = &arg_flag.description {
|
||||
arg_val = arg_val.help(&*desc.clone().leak())
|
||||
}
|
||||
|
||||
cmd.arg(arg_val)
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
crate::model::CuddleScript::Dagger(_) => todo!(),
|
||||
crate::model::CuddleScript::Lua(l) => {}
|
||||
crate::model::CuddleScript::Rust(_) => todo!(),
|
||||
}
|
||||
|
||||
cmds.push(cmd)
|
||||
}
|
||||
|
||||
cmds
|
||||
}
|
||||
|
||||
pub fn execute_x(exe_submatch: &ArgMatches, cli: CuddleCli) -> anyhow::Result<()> {
|
||||
match exe_submatch.subcommand() {
|
||||
Some((name, action_matches)) => {
|
||||
log::trace!(action=name; "running action; name={}", name);
|
||||
match cli.scripts.iter().find(|ele| ele.name == name) {
|
||||
Some(script) => {
|
||||
script
|
||||
.clone()
|
||||
.execute(action_matches, cli.variables.clone())?;
|
||||
Ok(())
|
||||
}
|
||||
_ => Err(anyhow::anyhow!("could not find a match")),
|
||||
}
|
||||
}
|
||||
_ => Err(anyhow::anyhow!("could not find a match")),
|
||||
}
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
use envconfig::Envconfig;
|
||||
|
||||
pub enum CuddleFetchPolicy {
|
||||
Always,
|
||||
Once,
|
||||
Never,
|
||||
}
|
||||
|
||||
#[derive(Envconfig, Clone, Debug)]
|
||||
pub struct CuddleConfig {
|
||||
#[envconfig(from = "CUDDLE_FETCH_POLICY", default = "once")]
|
||||
fetch_policy: String,
|
||||
}
|
||||
|
||||
impl CuddleConfig {
|
||||
pub fn from_env() -> anyhow::Result<Self> {
|
||||
CuddleConfig::init_from_env().map_err(|e| anyhow::Error::from(e))
|
||||
}
|
||||
|
||||
pub fn get_fetch_policy(&self) -> anyhow::Result<CuddleFetchPolicy> {
|
||||
match self.fetch_policy.clone().to_lowercase().as_str() {
|
||||
"always" => Ok(CuddleFetchPolicy::Always),
|
||||
"once" => Ok(CuddleFetchPolicy::Once),
|
||||
"never" => Ok(CuddleFetchPolicy::Never),
|
||||
_ => Err(anyhow::anyhow!("could not parse fetch policy")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,211 +0,0 @@
|
||||
use std::{
|
||||
env::{self, current_dir},
|
||||
ffi::OsStr,
|
||||
path::{Path, PathBuf},
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
use git2::{
|
||||
build::{CheckoutBuilder, RepoBuilder},
|
||||
FetchOptions, RemoteCallbacks,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
config::{CuddleConfig, CuddleFetchPolicy},
|
||||
model::{CuddleBase, CuddlePlan},
|
||||
};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum CuddleTreeType {
|
||||
Root,
|
||||
Leaf,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct CuddleContext {
|
||||
pub plan: CuddlePlan,
|
||||
pub path: PathBuf,
|
||||
pub node_type: CuddleTreeType,
|
||||
}
|
||||
|
||||
pub fn extract_cuddle(
|
||||
config: CuddleConfig,
|
||||
) -> anyhow::Result<Option<Arc<Mutex<Vec<CuddleContext>>>>> {
|
||||
let mut curr_dir = current_dir()?;
|
||||
curr_dir.push(".cuddle/");
|
||||
let fetch_policy = config.get_fetch_policy()?;
|
||||
if let CuddleFetchPolicy::Always = fetch_policy {
|
||||
if curr_dir.exists() {
|
||||
if let Err(res) = std::fs::remove_dir_all(curr_dir) {
|
||||
panic!("{}", res)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Load main cuddle file.
|
||||
let cuddle_yaml = find_root_cuddle()?;
|
||||
if cuddle_yaml.is_none() {
|
||||
return Ok(None);
|
||||
}
|
||||
let cuddle_yaml = cuddle_yaml.unwrap();
|
||||
log::trace!(cuddle_yaml=log::as_debug!(cuddle_yaml); "Find root cuddle");
|
||||
|
||||
let cuddle_plan = serde_yaml::from_str::<CuddlePlan>(cuddle_yaml.as_str())?;
|
||||
log::debug!(cuddle_plan=log::as_debug!(cuddle_yaml); "parse cuddle plan");
|
||||
|
||||
let context: Arc<Mutex<Vec<CuddleContext>>> = Arc::new(Mutex::new(Vec::new()));
|
||||
context.lock().unwrap().push(CuddleContext {
|
||||
plan: cuddle_plan.clone(),
|
||||
path: current_dir()?,
|
||||
node_type: CuddleTreeType::Root,
|
||||
});
|
||||
|
||||
// pull parent plan and execute recursive descent
|
||||
match cuddle_plan.base {
|
||||
CuddleBase::Bool(true) => {
|
||||
return Err(anyhow::anyhow!(
|
||||
"plan cannot be enabled without specifying a plan"
|
||||
))
|
||||
}
|
||||
CuddleBase::Bool(false) => {
|
||||
log::debug!("plan is root: skipping");
|
||||
}
|
||||
CuddleBase::String(parent_plan) => {
|
||||
let destination_path = create_cuddle_local()?;
|
||||
let mut cuddle_dest = destination_path.clone();
|
||||
cuddle_dest.push("base");
|
||||
|
||||
if !cuddle_dest.exists() {
|
||||
pull_parent_cuddle_into_local(parent_plan, cuddle_dest.clone())?;
|
||||
}
|
||||
|
||||
recurse_parent(cuddle_dest, context.clone())?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Some(context))
|
||||
}
|
||||
|
||||
fn create_cuddle_local() -> anyhow::Result<PathBuf> {
|
||||
let mut curr_dir = current_dir()?.clone();
|
||||
curr_dir.push(".cuddle/");
|
||||
|
||||
if curr_dir.exists() {
|
||||
log::debug!(".cuddle/ already exists: skipping");
|
||||
return Ok(curr_dir);
|
||||
}
|
||||
|
||||
std::fs::create_dir(curr_dir.clone())?;
|
||||
|
||||
Ok(curr_dir)
|
||||
}
|
||||
|
||||
fn create_cuddle(path: PathBuf) -> anyhow::Result<PathBuf> {
|
||||
let mut curr_dir = path.clone();
|
||||
curr_dir.push(".cuddle/");
|
||||
|
||||
if curr_dir.exists() {
|
||||
log::debug!(".cuddle/ already exists: skipping");
|
||||
return Ok(curr_dir);
|
||||
}
|
||||
|
||||
std::fs::create_dir(curr_dir.clone())?;
|
||||
|
||||
Ok(curr_dir)
|
||||
}
|
||||
|
||||
fn pull_parent_cuddle_into_local(
|
||||
parent_cuddle: String,
|
||||
destination: PathBuf,
|
||||
) -> anyhow::Result<()> {
|
||||
let mut rc = RemoteCallbacks::new();
|
||||
rc.credentials(|_url, username_from_url, _allowed_types| {
|
||||
if *"true" == std::env::var("CUDDLE_SSH_AGENT").ok().unwrap_or("".into()) {
|
||||
git2::Cred::ssh_key_from_agent(username_from_url.unwrap())
|
||||
} else {
|
||||
git2::Cred::ssh_key(
|
||||
username_from_url.unwrap(),
|
||||
None,
|
||||
Path::new(&format!("{}/.ssh/id_ed25519", env::var("HOME").unwrap())),
|
||||
None,
|
||||
)
|
||||
}
|
||||
});
|
||||
|
||||
rc.certificate_check(|_cert, _something| Ok(git2::CertificateCheckStatus::CertificateOk));
|
||||
|
||||
let mut fo = FetchOptions::new();
|
||||
fo.remote_callbacks(rc);
|
||||
|
||||
let co = CheckoutBuilder::new();
|
||||
RepoBuilder::new()
|
||||
.fetch_options(fo)
|
||||
.with_checkout(co)
|
||||
.clone(&parent_cuddle, &destination)?;
|
||||
|
||||
log::debug!(parent_cuddle=log::as_display!(parent_cuddle); "pulled repository");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn recurse_parent(
|
||||
path: PathBuf,
|
||||
context: Arc<Mutex<Vec<CuddleContext>>>,
|
||||
) -> anyhow::Result<Option<()>> {
|
||||
let cuddle_contents = find_cuddle(path.clone())?;
|
||||
if cuddle_contents.is_none() {
|
||||
return Ok(None);
|
||||
}
|
||||
let cuddle_plan = serde_yaml::from_str::<CuddlePlan>(&cuddle_contents.unwrap())?;
|
||||
|
||||
let ctx = context.clone();
|
||||
if let Ok(mut ctxs) = ctx.lock() {
|
||||
ctxs.push(CuddleContext {
|
||||
plan: cuddle_plan.clone(),
|
||||
path: path.clone(),
|
||||
node_type: CuddleTreeType::Leaf,
|
||||
});
|
||||
} else {
|
||||
return Err(anyhow::anyhow!("Could not acquire lock, aborting"));
|
||||
}
|
||||
|
||||
match cuddle_plan.base {
|
||||
CuddleBase::Bool(true) => Err(anyhow::anyhow!(
|
||||
"plan cannot be enabled without specifying a plan"
|
||||
)),
|
||||
CuddleBase::Bool(false) => {
|
||||
log::debug!("plan is root: finishing up");
|
||||
Ok(Some(()))
|
||||
}
|
||||
CuddleBase::String(parent_plan) => {
|
||||
let destination_path = create_cuddle(path.clone())?;
|
||||
let mut cuddle_dest = destination_path.clone();
|
||||
cuddle_dest.push("base");
|
||||
|
||||
if !cuddle_dest.exists() {
|
||||
pull_parent_cuddle_into_local(parent_plan, cuddle_dest.clone())?;
|
||||
}
|
||||
recurse_parent(cuddle_dest, context.clone())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn find_root_cuddle() -> anyhow::Result<Option<String>> {
|
||||
// TODO: Make recursive towards root
|
||||
let current_dir = env::current_dir()?;
|
||||
find_cuddle(current_dir)
|
||||
}
|
||||
|
||||
fn find_cuddle(path: PathBuf) -> anyhow::Result<Option<String>> {
|
||||
for entry in std::fs::read_dir(path)? {
|
||||
let entry = entry?;
|
||||
let path = entry.path();
|
||||
|
||||
let metadata = std::fs::metadata(&path)?;
|
||||
if metadata.is_file() && path.file_name().unwrap() == OsStr::new("cuddle.yaml") {
|
||||
return Ok(Some(std::fs::read_to_string(path)?));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(None)
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
use config::CuddleConfig;
|
||||
use tracing_subscriber::prelude::*;
|
||||
use tracing_subscriber::{fmt, EnvFilter};
|
||||
|
||||
mod actions;
|
||||
mod cli;
|
||||
mod config;
|
||||
mod context;
|
||||
mod model;
|
||||
mod util;
|
||||
|
||||
fn main() -> anyhow::Result<()> {
|
||||
init_logging()?;
|
||||
let _ = dotenv::dotenv();
|
||||
|
||||
let config = CuddleConfig::from_env()?;
|
||||
|
||||
let context = context::extract_cuddle(config.clone())?;
|
||||
_ = cli::CuddleCli::new(context, config)?.execute()?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn init_logging() -> anyhow::Result<()> {
|
||||
tracing_subscriber::registry()
|
||||
.with(fmt::layer())
|
||||
.with(EnvFilter::from_default_env())
|
||||
.init();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@ -1,236 +0,0 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use serde::Deserialize;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
#[serde(untagged)]
|
||||
pub enum CuddleBase {
|
||||
Bool(bool),
|
||||
String(String),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub struct CuddleShellScriptArgEnv {
|
||||
pub key: String,
|
||||
pub description: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub struct CuddleShellScriptArgFlag {
|
||||
pub name: String,
|
||||
pub description: Option<String>,
|
||||
pub required: Option<bool>,
|
||||
pub default_value: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
#[serde(tag = "type")]
|
||||
pub enum CuddleShellScriptArg {
|
||||
#[serde(alias = "env")]
|
||||
Env(CuddleShellScriptArgEnv),
|
||||
#[serde(alias = "flag")]
|
||||
Flag(CuddleShellScriptArgFlag),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub struct CuddleShellScript {
|
||||
pub description: Option<String>,
|
||||
pub args: Option<HashMap<String, CuddleShellScriptArg>>,
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub struct CuddleDaggerScript {
|
||||
pub description: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub struct CuddleLuaScript {
|
||||
pub description: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub enum CuddleRustUpstream {
|
||||
#[serde(alias = "gitea")]
|
||||
Gitea { url: String },
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub struct CuddleRustScript {
|
||||
pub description: Option<String>,
|
||||
pub upstream: CuddleRustUpstream,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
#[serde(tag = "type")]
|
||||
pub enum CuddleScript {
|
||||
#[serde(alias = "shell")]
|
||||
Shell(CuddleShellScript),
|
||||
#[serde(alias = "dagger")]
|
||||
Dagger(CuddleDaggerScript),
|
||||
#[serde(alias = "lua")]
|
||||
Lua(CuddleLuaScript),
|
||||
#[serde(alias = "rust")]
|
||||
Rust(CuddleRustScript),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize)]
|
||||
pub struct CuddlePlan {
|
||||
pub base: CuddleBase,
|
||||
pub vars: Option<CuddlePlanVariables>,
|
||||
pub scripts: Option<HashMap<String, CuddleScript>>,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Debug, Clone, PartialEq)]
|
||||
pub struct CuddlePlanVariables(HashMap<String, CuddlePlanVar>);
|
||||
|
||||
impl From<CuddlePlanVariables> for Vec<CuddleVariable> {
|
||||
fn from(value: CuddlePlanVariables) -> Self {
|
||||
let variables: CuddleVariables = value.0.into();
|
||||
|
||||
let mut vars = variables.0;
|
||||
vars.sort_by(|a, b| a.name.partial_cmp(&b.name).unwrap());
|
||||
|
||||
vars
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Debug, Clone, PartialEq)]
|
||||
#[serde(untagged)]
|
||||
pub enum CuddlePlanVar {
|
||||
Str(String),
|
||||
Nested(HashMap<String, CuddlePlanVar>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
struct CuddleVariables(Vec<CuddleVariable>);
|
||||
|
||||
impl From<HashMap<String, CuddlePlanVar>> for CuddleVariables {
|
||||
fn from(value: HashMap<String, CuddlePlanVar>) -> Self {
|
||||
let mut variables = Vec::new();
|
||||
for (k, v) in value {
|
||||
match v {
|
||||
CuddlePlanVar::Str(value) => variables.push(CuddleVariable::new(k, value)),
|
||||
CuddlePlanVar::Nested(nested) => {
|
||||
let nested_variables: CuddleVariables = nested.into();
|
||||
|
||||
let mut combined_variables: Vec<_> = nested_variables
|
||||
.0
|
||||
.into_iter()
|
||||
.map(|v| CuddleVariable::new(format!("{}_{}", k, v.name), v.value))
|
||||
.collect();
|
||||
|
||||
variables.append(&mut combined_variables);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CuddleVariables(variables)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize, serde::Serialize)]
|
||||
#[allow(dead_code)]
|
||||
pub struct CuddleVariable {
|
||||
pub name: String,
|
||||
pub value: String,
|
||||
}
|
||||
|
||||
impl CuddleVariable {
|
||||
pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
|
||||
Self {
|
||||
name: name.into(),
|
||||
value: value.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<HashMap<String, CuddlePlanVar>> for CuddlePlanVar {
|
||||
fn from(value: HashMap<String, CuddlePlanVar>) -> Self {
|
||||
CuddlePlanVar::Nested(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<HashMap<&str, CuddlePlanVar>> for CuddlePlanVar {
|
||||
fn from(value: HashMap<&str, CuddlePlanVar>) -> Self {
|
||||
CuddlePlanVar::Nested(value.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl From<String> for CuddlePlanVar {
|
||||
fn from(value: String) -> Self {
|
||||
CuddlePlanVar::Str(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&str> for CuddlePlanVar {
|
||||
fn from(value: &str) -> Self {
|
||||
CuddlePlanVar::Str(value.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use std::collections::HashMap;
|
||||
|
||||
use super::{CuddlePlanVariables, CuddleVariable};
|
||||
|
||||
#[test]
|
||||
pub fn parse_cuddle_variables() {
|
||||
let cuddle = r#"
|
||||
someKey: someValue
|
||||
someNestedKey:
|
||||
someNestedNestedKey:
|
||||
someKey: key
|
||||
someKey: key
|
||||
"#;
|
||||
|
||||
let cuddle_var: CuddlePlanVariables = serde_yaml::from_str(cuddle).unwrap();
|
||||
|
||||
let mut expected = HashMap::new();
|
||||
expected.insert("someKey", "someValue".into());
|
||||
|
||||
let mut nested_key = HashMap::new();
|
||||
nested_key.insert("someKey", "key".into());
|
||||
|
||||
let mut nested_nested_key = HashMap::new();
|
||||
nested_nested_key.insert("someKey", "key".into());
|
||||
|
||||
nested_key.insert("someNestedNestedKey", nested_nested_key.into());
|
||||
|
||||
expected.insert("someNestedKey", nested_key.into());
|
||||
|
||||
assert_eq!(
|
||||
CuddlePlanVariables(
|
||||
expected
|
||||
.into_iter()
|
||||
.map(|(k, v)| (k.to_string(), v))
|
||||
.collect()
|
||||
),
|
||||
cuddle_var
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn to_cuddle_variables() {
|
||||
let cuddle = r#"
|
||||
someKey: someValue
|
||||
someNestedKey:
|
||||
someNestedNestedKey:
|
||||
someKey: key
|
||||
someKey: key
|
||||
"#;
|
||||
|
||||
let cuddle_var: CuddlePlanVariables = serde_yaml::from_str(cuddle).unwrap();
|
||||
|
||||
let variables: Vec<CuddleVariable> = cuddle_var.into();
|
||||
|
||||
let mut expected: Vec<CuddleVariable> = vec![
|
||||
CuddleVariable::new("someKey", "someValue"),
|
||||
CuddleVariable::new("someNestedKey_someKey", "key"),
|
||||
CuddleVariable::new("someNestedKey_someNestedNestedKey_someKey", "key"),
|
||||
];
|
||||
|
||||
expected.sort_by(|a, b| a.name.partial_cmp(&b.name).unwrap());
|
||||
|
||||
assert_eq!(expected, variables);
|
||||
}
|
||||
}
|
||||
@ -1,33 +0,0 @@
|
||||
use std::env::current_dir;
|
||||
|
||||
use git2::Repository;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GitCommit {
|
||||
pub commit_sha: String,
|
||||
}
|
||||
|
||||
impl GitCommit {
|
||||
pub fn new() -> anyhow::Result<GitCommit> {
|
||||
let repo = Repository::open(current_dir().expect("having current_dir available")).map_err(
|
||||
|e| {
|
||||
log::debug!("{}", e);
|
||||
anyhow::anyhow!("could not open repository")
|
||||
},
|
||||
)?;
|
||||
let head_ref = repo
|
||||
.head()
|
||||
.map_err(|e| {
|
||||
log::warn!("{}", e);
|
||||
anyhow::anyhow!("could not get HEAD")
|
||||
})?
|
||||
.target()
|
||||
.ok_or(anyhow::anyhow!(
|
||||
"could not extract head -> target to commit_sha"
|
||||
))?;
|
||||
|
||||
Ok(Self {
|
||||
commit_sha: head_ref.to_string(),
|
||||
})
|
||||
}
|
||||
}
|
||||
@ -1 +0,0 @@
|
||||
pub mod git;
|
||||
@ -1,8 +0,0 @@
|
||||
[package]
|
||||
name = "base"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
@ -1,8 +0,0 @@
|
||||
# yaml-language-server: $schema=../../schemas/base.json
|
||||
|
||||
base: "git@git.front.kjuulh.io:kjuulh/cuddle-rust-plan.git"
|
||||
|
||||
scripts:
|
||||
build:
|
||||
type: shell
|
||||
description: "build rust plan"
|
||||
@ -1,3 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
echo "Ran build"
|
||||
@ -1,3 +0,0 @@
|
||||
fn main() {
|
||||
println!("Hello, world!");
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
# yaml-language-server: $schema=../../schemas/base.json
|
||||
|
||||
base: false
|
||||
|
||||
vars:
|
||||
service: "some-service"
|
||||
|
||||
scripts:
|
||||
test_render_template:
|
||||
type: shell
|
||||
args:
|
||||
extravar:
|
||||
type: env
|
||||
key: "HOME"
|
||||
@ -1,6 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
CUDDLE_FETCH_POLICY=never cuddle render_template \
|
||||
--template-file "$TMP/input.txt.tmpl" \
|
||||
--destination "$TMP/input.txt" \
|
||||
--extra-var "extravar=someextravar"
|
||||
@ -1,3 +0,0 @@
|
||||
some {{ service }} name
|
||||
|
||||
- {{ extravar }}
|
||||
@ -1,135 +0,0 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema#",
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
"base": {
|
||||
"title": "Base url from which to base current cuddle plan on",
|
||||
"description": "Base url from which to construct current cuddle plan, is recursive",
|
||||
"oneOf": [
|
||||
{
|
||||
"type": "string",
|
||||
"title": "The url of the parameter"
|
||||
},
|
||||
{
|
||||
"type": "boolean",
|
||||
"title": "Whether it is enabled or not"
|
||||
}
|
||||
]
|
||||
},
|
||||
"vars": {
|
||||
"type": "object",
|
||||
"title": "your collection of variables to be available to cuddle",
|
||||
"patternProperties": {
|
||||
"^.*$": {
|
||||
"anyOf": [
|
||||
{
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"type": "object"
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"additionalProperties": false
|
||||
},
|
||||
"scripts": {
|
||||
"type": "object",
|
||||
"title": "Scripts the cuddle cli can execute",
|
||||
"description": "Scripts the cuddle cli can execute 'cuddle x my-awesome-script'",
|
||||
"additionalProperties": false,
|
||||
"patternProperties": {
|
||||
"^.*$": {
|
||||
"required": [
|
||||
"type"
|
||||
],
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
"type": {
|
||||
"enum": [
|
||||
"shell",
|
||||
"dagger"
|
||||
]
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"vars": {
|
||||
"type": "object",
|
||||
"title": "your collection of variables to be available to cuddle",
|
||||
"patternProperties": {
|
||||
"^.*$": {
|
||||
"type": "string"
|
||||
}
|
||||
},
|
||||
"additionalProperties": false
|
||||
},
|
||||
"args": {
|
||||
"title": "arguments to send to the specified script",
|
||||
"type": "object",
|
||||
"patternProperties": {
|
||||
"^.*$": {
|
||||
"anyOf": [
|
||||
{
|
||||
"type": "object",
|
||||
"required": [
|
||||
"type",
|
||||
"name"
|
||||
],
|
||||
"properties": {
|
||||
"type": {
|
||||
"enum": [
|
||||
"flag"
|
||||
]
|
||||
},
|
||||
"name": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"required": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"default": {
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "object",
|
||||
"required": [
|
||||
"type",
|
||||
"key"
|
||||
],
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
"type": {
|
||||
"enum": [
|
||||
"env"
|
||||
]
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"key": {
|
||||
"title": "the environment key to pull arg from",
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"base"
|
||||
],
|
||||
"type": "object",
|
||||
"title": "Cuddle base schema"
|
||||
}
|
||||
@ -1,16 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -e
|
||||
|
||||
tag="$REGISTRY/$SERVICE:${COMMIT_SHA:0:10}"
|
||||
latest_tag="$REGISTRY/$SERVICE:latest"
|
||||
|
||||
echo "logging in"
|
||||
docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD
|
||||
|
||||
echo "building image"
|
||||
DOCKER_BUILDKIT=1 docker build -t "$tag" -t "$latest_tag" -f "$TMP/build_cuddle_image.Dockerfile" .
|
||||
|
||||
echo "pushing image"
|
||||
docker push "$tag"
|
||||
docker push "$latest_tag"
|
||||
@ -1,5 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
cargo install --path cuddle/ --force
|
||||
|
||||
cuddle --version
|
||||
@ -1,38 +0,0 @@
|
||||
FROM rustlang/rust:nightly as base
|
||||
|
||||
RUN rustup target add x86_64-unknown-linux-musl
|
||||
|
||||
RUN apt-get update -qq && \
|
||||
apt-get install -y \
|
||||
musl-tools \
|
||||
musl-dev
|
||||
|
||||
RUN update-ca-certificates
|
||||
|
||||
RUN apt-get update && apt-get upgrade -y
|
||||
RUN apt-get install -y -q build-essential curl git
|
||||
|
||||
WORKDIR /app/cuddle/
|
||||
|
||||
COPY . .
|
||||
|
||||
RUN cargo install --target x86_64-unknown-linux-musl --path cuddle
|
||||
|
||||
FROM docker:dind
|
||||
|
||||
RUN apk add bash git kubectl
|
||||
|
||||
ENV SLICE_VERSION=v1.2.7
|
||||
RUN wget -O kubectl-slice_linux_x86_64.tar.gz \
|
||||
"https://github.com/patrickdappollonio/kubectl-slice/releases/download/$SLICE_VERSION/kubectl-slice_linux_x86_64.tar.gz" && \
|
||||
tar -xf kubectl-slice_linux_x86_64.tar.gz && \
|
||||
chmod +x ./kubectl-slice && \
|
||||
mv ./kubectl-slice /usr/local/bin/kubectl-slice && \
|
||||
rm kubectl-slice_linux_x86_64.tar.gz
|
||||
|
||||
RUN eval `ssh-agent`
|
||||
|
||||
COPY --from=1password/op:2 /usr/local/bin/op /usr/local/bin/op
|
||||
|
||||
COPY --from=base /usr/local/cargo/bin/ /usr/local/cargo/bin/
|
||||
ENV PATH="${PATH}:/usr/local/cargo/bin"
|
||||
@ -1,3 +0,0 @@
|
||||
.cuddle/
|
||||
.git/
|
||||
target/
|
||||
15
templates/docker-compose.yaml
Normal file
15
templates/docker-compose.yaml
Normal file
@ -0,0 +1,15 @@
|
||||
version: "3"
|
||||
services:
|
||||
crdb:
|
||||
restart: 'always'
|
||||
image: 'cockroachdb/cockroach:v23.1.14'
|
||||
command: 'start-single-node --advertise-addr 0.0.0.0 --insecure'
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "-f", "http://localhost:8080/health?ready=1"]
|
||||
interval: '10s'
|
||||
timeout: '30s'
|
||||
retries: 5
|
||||
start_period: '20s'
|
||||
ports:
|
||||
- 8080:8080
|
||||
- '26257:26257'
|
||||
Loading…
Reference in New Issue
Block a user