ci: improve Spin CLI installation with manual download and code formatting

marclove · marclove · commit cca1d21e5216 · 2025-08-30T23:22:45.000-04:00
Replace the automated Spin CLI installation script with a manual download
approach that provides better architecture detection, error handling, and
version pinning. This ensures more reliable CI builds across different
platforms.

Additionally, apply consistent code formatting across Rust source files
to improve code readability and maintainability. Changes include:
- Better struct field formatting
- Improved function parameter alignment
- Consistent line breaking for long expressions
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -172,9 +172,35 @@ jobs:
 
       - name: Install Spin CLI
         run: |
-          # Pin Spin CLI version via env var
-          curl -fsSL https://developer.fermyon.com/downloads/spin/install.sh | bash
+          set -euo pipefail
+          ver="${SPIN_VERSION:-2.7.0}"
+          os="linux"
+          arch="$(uname -m)"
+          case "$arch" in
+            x86_64) arch="amd64" ;;
+            aarch64|arm64) arch="arm64" ;;
+            *) echo "Unsupported arch: $arch" >&2; exit 1 ;;
+          esac
+          url="https://github.com/fermyon/spin/releases/download/v${ver}/spin-v${ver}-${os}-${arch}.tar.gz"
+          echo "Downloading Spin from $url"
+          mkdir -p "$HOME/.spin/bin"
+          tmpdir="$(mktemp -d)"
+          curl -fsSL "$url" -o "$tmpdir/spin.tgz"
+          tar -xzf "$tmpdir/spin.tgz" -C "$tmpdir"
+          # Find the spin binary and install it
+          spincandidate="$(find "$tmpdir" -type f -name spin -perm -111 | head -n1 || true)"
+          if [ -z "$spincandidate" ]; then
+            # Some archives contain 'spin' without exec bit; try any matching file
+            spincandidate="$(find "$tmpdir" -type f -name spin | head -n1 || true)"
+          fi
+          if [ -z "$spincandidate" ]; then
+            echo "Failed to locate 'spin' in archive" >&2
+            ls -R "$tmpdir" >&2 || true
+            exit 1
+          fi
+          install -m 0755 "$spincandidate" "$HOME/.spin/bin/spin"
           echo "$HOME/.spin/bin" >> "$GITHUB_PATH"
+          "$HOME/.spin/bin/spin" --version
 
       - name: Verify Spin version
         run: |
diff --git a/apps/e2e-keel/src/lib.rs b/apps/e2e-keel/src/lib.rs
@@ -1,6 +1,10 @@
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
-use spin_sdk::{http::{Method, Request, Response}, http_component, sqlite::{Connection, Value}};
+use spin_sdk::{
+    http::{Method, Request, Response},
+    http_component,
+    sqlite::{Connection, Value},
+};
 use urlencoding::decode;
 
 #[derive(Serialize, Deserialize)]
@@ -22,7 +26,14 @@ fn handle_e2e(req: Request) -> Result<Response> {
         (m, "/test/users-add") if *m == Method::Get => users_add_via_query(req),
         (m, "/txn/commit") if *m == Method::Post || *m == Method::Get => txn_commit(),
         (m, "/txn/rollback") if *m == Method::Post || *m == Method::Get => txn_rollback(),
-        _ => json(404, &ApiResponse::<()> { ok: false, data: None, error: Some("not found".into()) }),
+        _ => json(
+            404,
+            &ApiResponse::<()> {
+                ok: false,
+                data: None,
+                error: Some("not found".into()),
+            },
+        ),
     }
 }
 
@@ -38,14 +49,27 @@ fn json<T: Serialize>(status: u16, val: &T) -> Result<Response> {
 fn setup() -> Result<Response> {
     let db = Connection::open_default()?;
     db.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, email TEXT)", &[])?;
-    db.execute("CREATE TABLE IF NOT EXISTS accounts (id INTEGER PRIMARY KEY AUTOINCREMENT, balance INTEGER)", &[])?;
+    db.execute(
+        "CREATE TABLE IF NOT EXISTS accounts (id INTEGER PRIMARY KEY AUTOINCREMENT, balance INTEGER)",
+        &[],
+    )?;
     db.execute("DELETE FROM users", &[])?;
     db.execute("DELETE FROM accounts", &[])?;
-    json(200, &ApiResponse::<()> { ok: true, data: None, error: None })
+    json(
+        200,
+        &ApiResponse::<()> {
+            ok: true,
+            data: None,
+            error: None,
+        },
+    )
 }
 
 #[derive(Deserialize)]
-struct NewUser { name: String, email: String }
+struct NewUser {
+    name: String,
+    email: String,
+}
 
 fn create_user(req: Request) -> Result<Response> {
     let db = Connection::open_default()?;
@@ -55,11 +79,22 @@ fn create_user(req: Request) -> Result<Response> {
         "INSERT INTO users (name, email) VALUES (?, ?)",
         &[Value::Text(nu.name), Value::Text(nu.email)],
     )?;
-    json(200, &ApiResponse::<()> { ok: true, data: None, error: None })
+    json(
+        200,
+        &ApiResponse::<()> {
+            ok: true,
+            data: None,
+            error: None,
+        },
+    )
 }
 
 #[derive(Serialize)]
-struct UserOut { id: i64, name: String, email: String }
+struct UserOut {
+    id: i64,
+    name: String,
+    email: String,
+}
 
 fn list_users() -> Result<Response> {
     let db = Connection::open_default()?;
@@ -69,9 +104,20 @@ fn list_users() -> Result<Response> {
         let id: i64 = row.get(0).unwrap_or_default();
         let name: &str = row.get(1).unwrap_or("");
         let email: &str = row.get(2).unwrap_or("");
-        users.push(UserOut { id, name: name.to_string(), email: email.to_string() });
+        users.push(UserOut {
+            id,
+            name: name.to_string(),
+            email: email.to_string(),
+        });
     }
-    json(200, &ApiResponse { ok: true, data: Some(users), error: None })
+    json(
+        200,
+        &ApiResponse {
+            ok: true,
+            data: Some(users),
+            error: None,
+        },
+    )
 }
 
 fn users_add_via_query(req: Request) -> Result<Response> {
@@ -80,7 +126,7 @@ fn users_add_via_query(req: Request) -> Result<Response> {
     let mut name: Option<String> = None;
     let mut email: Option<String> = None;
     if let Some(idx) = qs.find('?') {
-        let q = &qs[idx+1..];
+        let q = &qs[idx + 1..];
         for pair in q.split('&') {
             let mut it = pair.splitn(2, '=');
             if let (Some(k), Some(v)) = (it.next(), it.next()) {
@@ -99,9 +145,23 @@ fn users_add_via_query(req: Request) -> Result<Response> {
                 "INSERT INTO users (name, email) VALUES (?, ?)",
                 &[Value::Text(n), Value::Text(e)],
             )?;
-            json(200, &ApiResponse::<()> { ok: true, data: None, error: None })
+            json(
+                200,
+                &ApiResponse::<()> {
+                    ok: true,
+                    data: None,
+                    error: None,
+                },
+            )
         }
-        _ => json(400, &ApiResponse::<()> { ok: false, data: None, error: Some("missing name or email".into()) })
+        _ => json(
+            400,
+            &ApiResponse::<()> {
+                ok: false,
+                data: None,
+                error: Some("missing name or email".into()),
+            },
+        ),
     }
 }
 
@@ -110,25 +170,51 @@ fn txn_commit() -> Result<Response> {
     db.execute("DELETE FROM accounts", &[])?;
     db.execute("INSERT INTO accounts (balance) VALUES (100), (200)", &[])?;
     db.execute("BEGIN", &[])?;
-    db.execute("UPDATE accounts SET balance = balance - 50 WHERE id = 1", &[])?;
-    db.execute("UPDATE accounts SET balance = balance + 50 WHERE id = 2", &[])?;
+    db.execute(
+        "UPDATE accounts SET balance = balance - 50 WHERE id = 1",
+        &[],
+    )?;
+    db.execute(
+        "UPDATE accounts SET balance = balance + 50 WHERE id = 2",
+        &[],
+    )?;
     db.execute("COMMIT", &[])?;
     let qr = db.execute("SELECT balance FROM accounts ORDER BY id", &[])?;
     let b0: i64 = qr.rows.first().and_then(|r| r.get(0)).unwrap_or_default();
     let b1: i64 = qr.rows.get(1).and_then(|r| r.get(0)).unwrap_or_default();
-    json(200, &ApiResponse { ok: true, data: Some(vec![b0, b1]), error: None })
+    json(
+        200,
+        &ApiResponse {
+            ok: true,
+            data: Some(vec![b0, b1]),
+            error: None,
+        },
+    )
 }
 
 fn txn_rollback() -> Result<Response> {
     let db = Connection::open_default()?;
     db.execute("DELETE FROM accounts", &[])?;
     db.execute("INSERT INTO accounts (balance) VALUES (100), (200)", &[])?;
     db.execute("BEGIN", &[])?;
-    db.execute("UPDATE accounts SET balance = balance - 50 WHERE id = 1", &[])?;
-    db.execute("UPDATE accounts SET balance = balance + 50 WHERE id = 2", &[])?;
+    db.execute(
+        "UPDATE accounts SET balance = balance - 50 WHERE id = 1",
+        &[],
+    )?;
+    db.execute(
+        "UPDATE accounts SET balance = balance + 50 WHERE id = 2",
+        &[],
+    )?;
     db.execute("ROLLBACK", &[])?;
     let qr = db.execute("SELECT balance FROM accounts ORDER BY id", &[])?;
     let b0: i64 = qr.rows.first().and_then(|r| r.get(0)).unwrap_or_default();
     let b1: i64 = qr.rows.get(1).and_then(|r| r.get(0)).unwrap_or_default();
-    json(200, &ApiResponse { ok: true, data: Some(vec![b0, b1]), error: None })
+    json(
+        200,
+        &ApiResponse {
+            ok: true,
+            data: Some(vec![b0, b1]),
+            error: None,
+        },
+    )
 }
diff --git a/components/infrastructure/kv-rocksdb/src/lib.rs b/components/infrastructure/kv-rocksdb/src/lib.rs
@@ -23,12 +23,20 @@ impl wit_kv::Guest for Adapter {
         Err(op_err("not implemented"))
     }
 
-    fn set_with_ttl(_key: String, _value: wit_kv::KvValue, _ttl_seconds: u32) -> Result<(), wit_kv::KvError> {
+    fn set_with_ttl(
+        _key: String,
+        _value: wit_kv::KvValue,
+        _ttl_seconds: u32,
+    ) -> Result<(), wit_kv::KvError> {
         Err(op_err("not implemented"))
     }
 
-    fn delete(_key: String) -> Result<bool, wit_kv::KvError> { Err(op_err("not implemented")) }
-    fn exists(_key: String) -> Result<bool, wit_kv::KvError> { Err(op_err("not implemented")) }
+    fn delete(_key: String) -> Result<bool, wit_kv::KvError> {
+        Err(op_err("not implemented"))
+    }
+    fn exists(_key: String) -> Result<bool, wit_kv::KvError> {
+        Err(op_err("not implemented"))
+    }
 
     fn increment(_key: String, _delta: i64) -> Result<i64, wit_kv::KvError> {
         Err(op_err("not implemented"))
@@ -38,10 +46,13 @@ impl wit_kv::Guest for Adapter {
         Err(op_err("not implemented"))
     }
 
-    fn scan(_pattern: String, _cursor: Option<String>, _limit: Option<u32>) -> Result<wit_kv::ScanResult, wit_kv::KvError> {
+    fn scan(
+        _pattern: String,
+        _cursor: Option<String>,
+        _limit: Option<u32>,
+    ) -> Result<wit_kv::ScanResult, wit_kv::KvError> {
         Err(op_err("not implemented"))
     }
 }
 
 export!(Adapter);
-
diff --git a/components/infrastructure/sql-spin-sqlite/src/lib.rs b/components/infrastructure/sql-spin-sqlite/src/lib.rs
@@ -64,7 +64,10 @@ struct Adapter;
 impl wit_sql::Guest for Adapter {
     type Transaction = Transaction;
 
-    fn query(sql: String, params: Vec<wit_sql::SqlValue>) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
+    fn query(
+        sql: String,
+        params: Vec<wit_sql::SqlValue>,
+    ) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
         exec_query(&sql, &params)
     }
 
@@ -74,7 +77,8 @@ impl wit_sql::Guest for Adapter {
 
     fn begin_transaction() -> Result<wit_sql::Transaction, wit_sql::SqlError> {
         let conn = Connection::open_default().map_err(|e| map_err(e, "connection"))?;
-        conn.execute("BEGIN", &[]).map_err(|e| map_err(e, "transaction"))?;
+        conn.execute("BEGIN", &[])
+            .map_err(|e| map_err(e, "transaction"))?;
         Ok(wit_sql::Transaction::new(Transaction { conn }))
     }
 }
@@ -84,11 +88,19 @@ struct Transaction {
 }
 
 impl wit_sql::GuestTransaction for Transaction {
-    fn query(&self, sql: String, params: Vec<wit_sql::SqlValue>) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
+    fn query(
+        &self,
+        sql: String,
+        params: Vec<wit_sql::SqlValue>,
+    ) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
         exec_query_on(&self.conn, &sql, &params)
     }
 
-    fn execute(&self, sql: String, params: Vec<wit_sql::SqlValue>) -> Result<u64, wit_sql::SqlError> {
+    fn execute(
+        &self,
+        sql: String,
+        params: Vec<wit_sql::SqlValue>,
+    ) -> Result<u64, wit_sql::SqlError> {
         exec_execute_on(&self.conn, &sql, &params)
     }
 
@@ -110,7 +122,10 @@ impl wit_sql::GuestTransaction for Transaction {
 // Export the component entry points
 export!(Adapter);
 
-fn exec_query(sql: &str, params: &[wit_sql::SqlValue]) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
+fn exec_query(
+    sql: &str,
+    params: &[wit_sql::SqlValue],
+) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
     let conn = Connection::open_default().map_err(|e| map_err(e, "connection"))?;
     let values = values_from(params)?;
     let qr: SpinQueryResult = conn
@@ -120,15 +135,22 @@ fn exec_query(sql: &str, params: &[wit_sql::SqlValue]) -> Result<wit_sql::QueryR
     for row in &qr.rows {
         out_rows.push(row_to_wit(&qr.columns, &row.values));
     }
-    Ok(wit_sql::QueryResult { rows: out_rows, rows_affected: 0 })
+    Ok(wit_sql::QueryResult {
+        rows: out_rows,
+        rows_affected: 0,
+    })
 }
 
 fn exec_execute(sql: &str, params: &[wit_sql::SqlValue]) -> Result<u64, wit_sql::SqlError> {
     let conn = Connection::open_default().map_err(|e| map_err(e, "connection"))?;
     exec_execute_on(&conn, sql, params)
 }
 
-fn exec_query_on(conn: &Connection, sql: &str, params: &[wit_sql::SqlValue]) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
+fn exec_query_on(
+    conn: &Connection,
+    sql: &str,
+    params: &[wit_sql::SqlValue],
+) -> Result<wit_sql::QueryResult, wit_sql::SqlError> {
     let values = values_from(params)?;
     let qr: SpinQueryResult = conn
         .execute(sql, values.as_slice())
@@ -137,11 +159,19 @@ fn exec_query_on(conn: &Connection, sql: &str, params: &[wit_sql::SqlValue]) ->
     for row in &qr.rows {
         out_rows.push(row_to_wit(&qr.columns, &row.values));
     }
-    Ok(wit_sql::QueryResult { rows: out_rows, rows_affected: 0 })
+    Ok(wit_sql::QueryResult {
+        rows: out_rows,
+        rows_affected: 0,
+    })
 }
 
-fn exec_execute_on(conn: &Connection, sql: &str, params: &[wit_sql::SqlValue]) -> Result<u64, wit_sql::SqlError> {
+fn exec_execute_on(
+    conn: &Connection,
+    sql: &str,
+    params: &[wit_sql::SqlValue],
+) -> Result<u64, wit_sql::SqlError> {
     let values = values_from(params)?;
-    conn.execute(sql, values.as_slice()).map_err(|e| map_err(e, "query"))?;
+    conn.execute(sql, values.as_slice())
+        .map_err(|e| map_err(e, "query"))?;
     Ok(0)
 }
