Babashka 脚本化与任务自动化：原生镜像、bb 任务与生产实践

# macOS
brew install borkdude/brew/babashka

# 或官方安装脚本
curl -sLO https://raw.githubusercontent.com/babashka/babashka/master/install
chmod +x install && ./install

# 验证
bb --version

{:paths ["src" "script"]
 :deps  {org.clojure/data.json {:mvn/version "2.5.0"}}
 :tasks
 {;; 简单任务：调用外部命令
  test   {:doc "运行测试"
          :task (shell "clojure -M:test")}

  ;; 带额外依赖的任务
  lint   {:extra-deps {clj-kondo/clj-kondo {:mvn/version "2024.08.01"}}
          :requires ([clj-kondo.main])
          :task (clj-kondo.main/main "--lint" "src")}

  ;; 组合任务：依赖其他任务
  ci     {:doc "CI 流水线"
          :depends [lint test]}

  ;; 默认任务（直接 bb 时执行）
  default {:task (println "用法: bb <task>")}}}

bb lint        # 跑 lint 任务
bb ci          # 先 lint 再 test
bb             # 跑 default
bb tasks       # 列出所有任务

{:tasks
 {build    {:task (do (println "compile") nil)}
  lint     {:task (do (println "lint") nil)}
  parallel {:task (do (future (shell "bb build"))
                      (future (shell "bb lint"))
                      nil)}}}

bb -e '(println (+ 1 2))'          # 执行表达式
bb script.clj                      # 执行文件
bb -f script.clj                   # 同 -f
cat script.clj | bb -              # 从 stdin

;;; script.clj
(require '[babashka.fs :as fs]
         '[babashka.process :refer [shell]])

(let [files (fs/glob "." "**/*.clj")]
  (println "找到" (count files) "个文件")
  (shell "wc" "-l" (map str files)))

(require '[babashka.cli :as cli])

(def opts
  (cli/parse-opts *command-line-args*
                  {:spec {:port  {:coerce :long :default 8080}
                          :env   {:coerce :keyword}
                          :debug {:coerce :boolean}}}))

(println "端口" (:port opts) "环境" (:env opts))

bb script.clj --port 9000 --env prod --debug
# => 端口 9000 环境 :prod

#!/usr/bin/env bb
(require '[babashka.fs :as fs])
(println (fs/absolutize "."))

chmod +x deploy.clj
./deploy.clj

;; bb.edn 声明 pod
{:pods {org.babashka/go-sqlite3 {:version "0.3.5"}}}

;; 代码里加载
(require '[babashka.pods :as pods])
(pods/load-pod 'org.babashka/go-sqlite3 "0.3.5")
(require '[pod.babashka.go-sqlite3 :as sqlite])

(def db (sqlite/open "app.db"))
(sqlite/execute! db ["create table t (id integer)"])

(require '[babashka.fs :as fs]
         '[clojure.string :as str])

;; 读
(slurp "config.edn")
(str/split-lines (slurp "data.txt"))

;; 写
(spit "out.txt" "hello\n")

;; 复制/移动/删除
(fs/copy "a.txt" "b.txt")
(fs/move "b.txt" "sub/b.txt" {:replace-existing true})
(fs/delete "tmp.txt")

;; 递归找所有 .clj 文件
(fs/glob "." "**/*.clj")

;; 过滤大文件
(->> (fs/glob "." "**/*")
     (filter fs/regular-file?)
     (filter #(> (fs/size %) (* 10 1024 1024)))
     (map str))

;; 创建临时目录
(let [tmp (fs/create-temp-dir)]
  (spit (fs/file tmp "x.txt") "data"))

(require '[babashka.process :as p :refer [shell process]])

;; 简单执行（继承 stdout）
(shell "git" "status")

;; 捕获输出
(-> (shell {:out :string} "git" "rev-parse" "HEAD")
    :out
    str/trim)

;; 流式管道
(-> (process {:out :string} "cat" "big.txt")
    :out
    (str/split-lines)
    count)

;; 管道串联
(->> (process "find . -name '*.clj'")
     (p/process "wc -l" {:in (:out *1)}))

(require '[babashka.http-client :as http]
         '[babashka.json :as json])

;; GET
(def resp (http/get "https://api.github.com/repos/babashka/babashka"))
(:status resp)                               ;; 200
(json/read-str (:body resp) :key-fn keyword) ;; 解析 JSON

;; POST
(http/post "https://httpbin.org/post"
           {:headers {"Content-Type" "application/json"}
            :body    (json/write-str {:name "bb" :ver "1.0"})})

;; 超时
(http/get "https://example.com" {:timeout 3000})

(require '[org.httpkit.server :as server])

(defn handler [req]
  {:status  200
   :headers {"Content-Type" "application/json"}
   :body    "{\"ok\":true}"})

(server/run-server handler {:port 8080})
@(promise)   ;; 阻塞不退

(require '[babashka.json :as json])

(json/write-str {:a 1 :b [1 2 3]})           ;; => "{\"a\":1,\"b\":[1,2,3]}"
(json/read-str "{\"x\":1}" :key-fn keyword)  ;; => {:x 1}

#!/usr/bin/env bb
;;; release.clj —— 打 tag、推送、发布
(require '[babashka.process :refer [shell]]
         '[babashka.cli :as cli]
         '[clojure.string :as str])

(def {:keys [version dry-run]}
  (cli/parse-opts *command-line-args*
                  {:spec {:version {:coerce :string :require true}
                          :dry-run {:coerce :boolean}}}))

(defn run! [& args]
  (println "执行" (str/join " " args))
  (when-not dry-run (apply shell args)))

(run! "git" "tag" (str "v" version))
(run! "git" "push" "origin" (str "v" version))
(println "发布" version (if dry-run "（演练）" "完成"))

;; 简易文件监听：变更即执行任务
(require '[babashka.fs :as fs]
         '[babashka.process :refer [shell]])

(defn watch-loop [dir f]
  (let [seen (atom {})]
    (loop []
      (doseq [file (fs/glob dir "**/*.clj")]
        (let [m (fs/last-modified-time file)]
          (when (not= m (get @seen file))
            (swap! seen assoc file m)
            (f file))))
      (Thread/sleep 1000)
      (recur))))

(watch-loop "src" (fn [f] (println "变更:" f) (shell "bb test")))

;;; migrate.clj —— 顺序执行迁移文件
(require '[babashka.fs :as fs]
         '[babashka.pods :as pods]
         '[clojure.string :as str])
(pods/load-pod 'org.babashka/go-sqlite3 "0.3.5")
(require '[pod.babashka.go-sqlite3 :as sqlite])

(def db (sqlite/open "app.db"))
(sqlite/execute! db ["create table if not exists schema_version (v text)"])

(doseq [f (sort (fs/glob "migrations" "*.sql"))]
  (println "执行" (str f))
  (doseq [stmt (str/split (slurp f) #";")]
    (when (seq (str/trim stmt))
      (sqlite/execute! db [stmt]))))

name: ci
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: DeLaGuardo/setup-clojure@12.5
        with:
          clojure: '1.12'
      - name: 安装 Babashka
        uses: turtlequeue/setup-babashka@v1.7.0
        with:
          babashka-version: 1.12.196
      - run: bb ci

;;; ci.clj
(require '[babashka.process :refer [shell]])

(defn step [name f]
  (println (str "== " name " =="))
  (let [r (f)]
    (when-not (zero? (:exit r))
      (println "失败:" name)
      (System/exit 1))))

(step "lint"  #(shell "clojure -M:clj-kondo --lint src"))
(step "test"  #(shell "clojure -X:test"))
(step "build" #(shell "clojure -T:build jar"))
(println "全部通过")