feat: add blog contents

2025-07-31 11:01:22 +02:00
parent da0771ccb9
commit 4bb6b0228a
79 changed files with 18092 additions and 246 deletions
--- a/ci/src/main.rs
+++ b/ci/src/main.rs
@@ -1,20 +1,70 @@
-use std::sync::Arc;
+use cuddle_ci::{Context, MainAction, PullRequestAction};
+use dagger_sdk::{
+    Container, HostDirectoryOptsBuilder, PortForward, QueryContainerOptsBuilder,
+    ServiceUpOptsBuilder,
+};

-use dagger_sdk::{HostDirectoryOptsBuilder, QueryContainerOptsBuilder};
-use tokio::sync::Mutex;
+const UPDATE_DEPLOYMENT_IMAGE: &str = "docker.io/kasperhermansen/update-deployment:1690401410";

-#[tokio::main]
-async fn main() -> eyre::Result<()> {
-    let _ = dotenv::dotenv();
-    dagger_sdk::connect(|client| async move {
+const ZOLA_VERSION: &str = "0.17.2-1";
+const DEBIAN_EDITION: &str = "bullseye";
+const DEBIAN_PLATFORM: &str = "amd64";

-let src = client.host().directory_opts(
+#[derive(Clone)]
+pub struct BlogComponent {
+    client: dagger_sdk::Query,
+}
+
+impl BlogComponent {
+    pub async fn run(&self) -> eyre::Result<()> {
+        let (_, container) = build(self.client.clone()).await?;
+
+        container
+            .as_service()
+            .up_opts(
+                ServiceUpOptsBuilder::default()
+                    .ports(vec![PortForward {
+                        backend: 8000,
+                        frontend: 8000,
+                        protocol: dagger_sdk::NetworkProtocol::Tcp,
+                    }])
+                    .build()?,
+            )
+            .await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl PullRequestAction for BlogComponent {
+    async fn execute_pull_request(&self, _ctx: &mut Context) -> eyre::Result<()> {
+        let (tag, container) = build(self.client.clone()).await?;
+        deploy(self.client.clone(), tag, container).await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl MainAction for BlogComponent {
+    async fn execute_main(&self, _ctx: &mut Context) -> eyre::Result<()> {
+        let (tag, container) = build(self.client.clone()).await?;
+        deploy(self.client.clone(), tag, container).await?;
+
+        Ok(())
+    }
+}
+
+async fn build(client: dagger_sdk::Query) -> eyre::Result<(i64, Container)> {
+    let src = client.host().directory_opts(
        ".",
        HostDirectoryOptsBuilder::default()
            .exclude(vec![".git", "node_modules", "public", "ci", "target"])
            .build()?,
    );

+    let github_zola_download: String = format!("https://github.com/barnumbirr/zola-debian/releases/download/v{ZOLA_VERSION}/zola_{ZOLA_VERSION}_{DEBIAN_PLATFORM}_{DEBIAN_EDITION}.deb");
    let node_cache = client.cache_volume("node_cache");
    let debian_cache = client.cache_volume("debian_cache");

@@ -28,40 +78,15 @@ let src = client.host().directory_opts(
        .with_exec(vec!["yarn", "compile"])
        .file("static/styles/styles.css");

-    let zola_version = "0.17.2-1";
-    let debian_edition = "bullseye";
-    let debian_platform = "amd64";
    let tag = chrono::Utc::now().timestamp();

-    let github_zola_download = format!("https://github.com/barnumbirr/zola-debian/releases/download/v{zola_version}/zola_{zola_version}_{debian_platform}_{debian_edition}.deb");
-    let pull_articles_docker_image = "docker.io/kasperhermansen/pull-articles:1690413158";
-    let update_deployments_docker_image = "docker.io/kasperhermansen/update-deployment:1690401410";
-
-    let pull_articles = client
-        .container()
-        .from(pull_articles_docker_image)
-        .with_exec(vec!["echo", &format!("{tag}")])
-        .with_env_variable("GIT_USERNAME", "kjuulh")
-        .with_env_variable("GIT_PASSWORD", std::env::var("GIT_PASSWORD").unwrap())
-        .with_exec(vec![
-            "pull-articles",
-            "--repo",
-            "https://git.front.kjuulh.io/kjuulh/obsidian.git",
-            "--path",
-            "areas/blog/posts",
-            "--out",
-            "/mnt/posts",
-            "--static-out=/mnt/static",
-        ])
-        .directory("/mnt/");
-
    let dist_dir = client
        .container_opts(
            dagger_sdk::QueryContainerOptsBuilder::default()
-                .platform(format!("linux/{debian_platform}"))
+                .platform(format!("linux/{DEBIAN_PLATFORM}"))
                .build()?,
        )
-        .from(format!("debian:{debian_edition}"))
+        .from(format!("debian:{DEBIAN_EDITION}"))
        .with_exec(vec!["apt", "update"])
        .with_exec(vec!["apt", "install", "wget", "-y"])
        .with_workdir("/mnt")
@@ -70,75 +95,33 @@ let src = client.host().directory_opts(
        .with_exec(vec![
            "dpkg",
            "-i",
-            format!("zola_{zola_version}_{debian_platform}_{debian_edition}.deb").as_str(),
+            format!("zola_{ZOLA_VERSION}_{DEBIAN_PLATFORM}_{DEBIAN_EDITION}.deb").as_str(),
        ])
        .with_workdir("/app")
        .with_directory(".", src.id().await?)
-        .with_directory(
-            "content/posts",
-            pull_articles.directory("posts").id().await?,
-        )
-        .with_directory(
-            "static/assets",
-            pull_articles.directory("static").id().await?,
-        )
-        .with_file(
-            "content/posts/_index.md",
-            src.file("content/posts/_index.md").id().await?,
-        )
        .with_file("static/styles/styles.css", styles_file.id().await?)
        .with_exec(vec!["zola", "build"])
        .directory("public");

    let caddy_file = client.host().directory("deployment").file("Caddyfile");

-    let variants = vec!["linux/amd64", "linux/arm64"];
-    let platform_variants = Arc::new(Mutex::new(Vec::new()));
+    let dep_image = client
+        .container_opts(QueryContainerOptsBuilder::default().build().unwrap())
+        .from("caddy")
+        .with_directory("/usr/share/caddy", dist_dir.id().await.unwrap())
+        .with_file("/etc/caddy/Caddyfile", caddy_file.id().await.unwrap());

-    tokio_scoped::scope(|s| {
-        for platform in variants {
-            let caddy_file = caddy_file.clone();
-            let client = client.clone();
-            let dist_dir = dist_dir.clone();
-            let platform_variants = platform_variants.clone();
+    Ok((tag, dep_image))
+}

-            s.spawn(async move {
-                let dep_image = client
-                    .container_opts(
-                        QueryContainerOptsBuilder::default()
-                            .platform(platform)
-                            .build()
-                            .unwrap(),
-                    )
-                    .from("caddy")
-                    .with_directory("/usr/share/caddy", dist_dir.id().await.unwrap())
-                    .with_file("/etc/caddy/Caddyfile", caddy_file.id().await.unwrap());
-
-                let mut platform_variants = platform_variants.lock().await;
-                platform_variants.push(dep_image.id().await.unwrap())
-            });
-        }
-    });
-
-    let variants = platform_variants
-        .lock()
-        .await
-        .iter().cloned()
-        .collect::<Vec<_>>();
-
-    client
-        .container()
-        .publish_opts(
-            format!("kasperhermansen/kasperhermansen-blog:{tag}"),
-            dagger_sdk::ContainerPublishOptsBuilder::default()
-                .platform_variants(variants)
-                .build()?,
-        )
+async fn deploy(client: dagger_sdk::Query, tag: i64, container: Container) -> eyre::Result<()> {
+    container
+        .publish(format!("kasperhermansen/kasperhermansen-blog:{tag}"))
        .await?;

    client
        .container()
-        .from(update_deployments_docker_image)
+        .from(UPDATE_DEPLOYMENT_IMAGE)
        .with_env_variable("GIT_USERNAME", "kjuulh")
        .with_env_variable("GIT_PASSWORD", std::env::var("GIT_PASSWORD").unwrap())
        .with_exec(vec![
@@ -153,7 +136,31 @@ let src = client.host().directory_opts(
        .exit_code()
        .await?;

-        Ok(()) }).await?;
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    let _ = dotenvy::dotenv();
+
+    dagger_sdk::connect(|client| async move {
+        let blog_component = &BlogComponent { client };
+
+        let run = std::env::var("RUN").unwrap_or_default();
+        if !run.is_empty() {
+            blog_component.run().await?;
+
+            return Ok(());
+        }
+
+        cuddle_ci::CuddleCI::default()
+            .with_main(blog_component)
+            .execute(std::env::args())
+            .await?;
+
+        Ok(())
+    })
+    .await?;

    Ok(())
 }