dagger-components/crates/cuddle-ci/src/node_service.rs

291 lines
8.6 KiB
Rust
Raw Normal View History

use std::path::PathBuf;
use async_trait::async_trait;
use dagger_sdk::{Container, ContainerWithDirectoryOptsBuilder, HostDirectoryOptsBuilder};
use crate::{
dagger_middleware::DynMiddleware,
rust_service::architecture::{Architecture, Os},
Context, MainAction, PullRequestAction,
};
#[derive(Clone)]
pub enum NodeServiceStage {
BeforeDeps(DynMiddleware),
AfterDeps(DynMiddleware),
BeforeBase(DynMiddleware),
AfterBase(DynMiddleware),
BeforeBuild(DynMiddleware),
AfterBuild(DynMiddleware),
BeforePackage(DynMiddleware),
AfterPackage(DynMiddleware),
BeforeRelease(DynMiddleware),
AfterRelease(DynMiddleware),
}
#[derive(Clone)]
pub struct NodeService {
client: dagger_sdk::Query,
service: String,
base_image: Option<Container>,
final_image: Option<Container>,
stages: Vec<NodeServiceStage>,
source: Option<PathBuf>,
arch: Option<Architecture>,
os: Option<Os>,
}
impl NodeService {
pub fn new(value: dagger_sdk::Query, service: impl Into<String>) -> Self {
Self {
client: value,
service: service.into(),
base_image: None,
final_image: None,
stages: Vec::new(),
source: None,
arch: None,
os: None,
}
}
pub fn with_base_image(&mut self, base: dagger_sdk::Container) -> &mut Self {
self.base_image = Some(base);
self
}
pub fn with_service(&mut self, service: impl Into<String>) -> &mut Self {
self.service = service.into();
self
}
pub fn with_stage(&mut self, stage: NodeServiceStage) -> &mut Self {
self.stages.push(stage);
self
}
pub fn with_source(&mut self, path: impl Into<PathBuf>) -> &mut Self {
self.source = Some(path.into());
self
}
pub fn with_arch(&mut self, arch: Architecture) -> &mut Self {
self.arch = Some(arch);
self
}
pub fn with_os(&mut self, os: Os) -> &mut Self {
self.os = Some(os);
self
}
fn get_src(&self) -> PathBuf {
self.source
.clone()
.unwrap_or(std::env::current_dir().unwrap())
}
fn get_arch(&self) -> Architecture {
self.arch
.clone()
.unwrap_or_else(|| match std::env::consts::ARCH {
"x86" | "x86_64" | "amd64" => Architecture::Amd64,
"arm" => Architecture::Arm64,
arch => panic!("unsupported architecture: {arch}"),
})
}
fn get_os(&self) -> Os {
self.os
.clone()
.unwrap_or_else(|| match std::env::consts::OS {
"linux" => Os::Linux,
"macos" => Os::MacOS,
os => panic!("unsupported os: {os}"),
})
}
pub async fn build_base(&self) -> eyre::Result<Container> {
let src = self.client.host().directory_opts(
self.get_src().to_string_lossy(),
HostDirectoryOptsBuilder::default()
.exclude(vec!["node_modules/", ".git/", ".cuddle/"])
.build()?,
);
let pkg_files = self.client.host().directory_opts(
self.get_src().to_string_lossy(),
HostDirectoryOptsBuilder::default()
.include(vec!["package.json", "yarn.lock"])
.build()?,
);
let deps =
"apk add --no-cache build-base gcc autoconf automake zlib-dev libpng-dev vips-dev git postgresql-dev"
.split_whitespace();
let base_image = match self.base_image.clone() {
Some(image) => image,
None => self
.client
.container()
.from("node:20-alpine")
.with_exec(vec!["apk", "update"])
.with_exec(deps.collect()),
}
.with_env_variable("NODE_ENV", "production");
let base_yarn_image = base_image
.with_workdir("/opt/")
.with_directory(".", pkg_files)
.with_exec(vec!["yarn", "global", "add", "node-gyp"])
.with_exec(vec![
"yarn",
"config",
"set",
"network-timeout",
"600000",
"-g",
])
.with_exec(vec!["yarn", "install", "--production"]);
let base_build = base_yarn_image
.with_env_variable(
"PATH",
format!(
"/opt/node_modules/.bin:{}",
base_yarn_image.env_variable("PATH").await?
),
)
.with_workdir("/opt/app")
.with_directory(".", src)
.with_exec(vec!["yarn", "build"]);
Ok(base_build)
}
pub async fn build_release(&self) -> eyre::Result<Container> {
let base = self.build_base().await?;
let final_build_image = match self.final_image.clone() {
Some(c) => c,
None => self
.client
.container()
.from("node:20-alpine")
.with_exec(vec![
"apk",
"add",
"--no-cache",
"vips-dev",
"postgresql-dev",
]),
}
.with_env_variable("NODE_ENV", "production");
let final_image = final_build_image
.with_workdir("/opt/")
.with_directory("/opt/node_modules", base.directory("/opt/node_modules"))
.with_workdir("/opt/app")
.with_directory_opts(
"/opt/app",
base.directory("/opt/app"),
ContainerWithDirectoryOptsBuilder::default()
.owner("node:node")
.build()?,
)
.with_env_variable(
"PATH",
format!(
"/opt/node_modules/.bin:{}",
final_build_image.env_variable("PATH").await?
),
)
.with_user("node")
.with_exposed_port(1337)
.with_entrypoint(vec!["yarn", "start"]);
Ok(final_image)
}
}
#[async_trait]
impl PullRequestAction for NodeService {
async fn execute_pull_request(&self, _ctx: &mut Context) -> eyre::Result<()> {
let release = self.build_release().await?;
release.sync().await?;
Ok(())
}
}
#[async_trait]
impl MainAction for NodeService {
async fn execute_main(&self, _ctx: &mut Context) -> eyre::Result<()> {
let container = self.build_release().await?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs();
container
.publish(format!(
"docker.io/kasperhermansen/{}:main-{}",
self.service, timestamp,
))
.await?;
let update_deployments_docker_image =
"docker.io/kasperhermansen/update-deployment:1701123940";
let dep = self
.client
.container()
.from(update_deployments_docker_image);
let dep = match std::env::var("SSH_AUTH_SOCK").ok() {
Some(sock) => dep
.with_unix_socket("/tmp/ssh_sock", self.client.host().unix_socket(sock))
.with_env_variable("SSH_AUTH_SOCK", "/tmp/ssh_sock")
.with_exec(vec![
"update-deployment",
"--repo",
&format!(
"git@git.front.kjuulh.io:kjuulh/{}-deployment.git",
self.service
),
"--service",
&self.service,
"--image",
&format!("kasperhermansen/{}:main-{}", self.service, timestamp),
]),
_ => dep
.with_env_variable("GIT_USERNAME", "kjuulh")
.with_env_variable(
"GIT_PASSWORD",
std::env::var("GIT_PASSWORD").expect("GIT_PASSWORD to be set"),
)
.with_exec(vec![
"update-deployment",
"--repo",
&format!(
"https://git.front.kjuulh.io/kjuulh/{}-deployment.git",
self.service
),
"--service",
&self.service,
"--image",
&format!("kasperhermansen/{}:main-{}", self.service, timestamp),
]),
};
dep.sync().await?;
Ok(())
}
}