core.clj

(ns docker-clojure.core
  (:require [babashka.cli :as cli]
            [clojure.core.async :refer [<!! chan pipeline-blocking to-chan!] :as async]
            [clojure.java.io :as io]
            [clojure.java.shell :refer [sh]]
            [clojure.spec.alpha :as s]
            [clojure.string :as str]
            [docker-clojure.config :as cfg]
            [docker-clojure.docker :as docker]
            [docker-clojure.dockerfile :as df]
            [docker-clojure.log :refer [log] :as logger]
            [docker-clojure.manifest :as manifest]
            [docker-clojure.util :refer [get-or-default]]
            [docker-clojure.variant :as variant]))

(defn exclude?
  "Returns true if `variant` matches one of `exclusions` elements (meaning
  `(contains-every-key-value? variant exclusion)` returns true)."
  [exclusions variant]
  (some (partial variant/exclude? variant) exclusions))

(def latest-variants
  "The latest variant is special because we include all 3 build tools via the
  [::all] value on the end."
  (for [arch cfg/architectures]
    (list (-> cfg/base-images :default first)
          cfg/default-jdk-version
          (get-or-default cfg/default-distros cfg/default-jdk-version)
          [::all]
          arch)))

(defn- invalid-variant?
  [variant]
  (let [status   (s/conform ::variant/variant variant)
        invalid? (= ::s/invalid status)]
    (when invalid?
      (println "invalid variant:" (pr-str variant))
      true)))

(defn image-variants
  [base-images jdk-versions distros build-tools architectures]
  (into #{}
        (comp
         (map variant/->map)
         (remove invalid-variant?))
        (concat
         (variant/combinations base-images jdk-versions distros build-tools
                               architectures)
         latest-variants)))

(defn rand-delay
  "Runs argument f w/ any supplied args after a random delay of 100-1000 ms"
  [f & args]
  (let [rand-time (+ 100 (rand-int 900))]
    (Thread/sleep rand-time)
    (apply f args)))

(defn build-images
  [parallelization installer-hashes variants]
  (log "Building images" parallelization "at a time")
  (let [variants-ch (to-chan! variants)
        builds-ch   (chan parallelization)]
    (async/thread (pipeline-blocking parallelization builds-ch
                                     (map (partial rand-delay docker/build-image
                                                   installer-hashes))
                                     variants-ch))
    (while (<!! builds-ch))))

(defn generate-dockerfiles! [installer-hashes variants]
  (log "Generated" (count variants) "variants")
  (doseq [variant variants]
    (df/generate! installer-hashes variant)))

(defn valid-variants []
  (remove (partial exclude? cfg/exclusions)
          (image-variants cfg/base-images cfg/jdk-versions cfg/distros
                          cfg/build-tools cfg/architectures)))

(defn generate-manifest! [variants target-file]
  (let [git-head    (->> ["git" "rev-parse" "HEAD"] (apply sh) :out)
        manifest    (manifest/generate {:maintainers   cfg/maintainers
                                        :architectures cfg/architectures
                                        :git-repo      cfg/git-repo}
                                       git-head variants)]
    (log "Writing manifest of" (count variants) "variants to" target-file "...")
    (let [output-writer (if (= :stdout target-file)
                          *out*
                          (io/writer target-file))]
      (.write output-writer manifest)
      (when (not= :stdout target-file)
        (.close output-writer)))))

(defn generate-variants
  [opts]
  (let [variant-filter #(or
                         (empty? opts)
                         (every? (fn [[k v]]
                                   (= (get % k) v))
                                 opts))]
    (when (seq opts)
      (println "Filtering variants with:")
      (doseq [[k v] opts]
        (println (str "(= " (pr-str v) " (get variant " (pr-str k) "))")))
      (println))
    (filter variant-filter (valid-variants))))

(defn cmd-clean [{:keys [_opts]}]
  (df/clean-all))

(defn cmd-dockerfiles [{:keys [opts]}]
  (generate-dockerfiles! cfg/installer-hashes (generate-variants opts)))

(defn cmd-manifest [{:keys [opts]}]
  (let [target-file (or (:output-file opts) :stdout)
        filter-opts (dissoc opts :output-file)]
    (generate-manifest! (generate-variants filter-opts) target-file)))

(defn cmd-build-images [{:keys [opts]}]
  (let [parallelism (:parallelism opts)
        filter-opts (dissoc opts :parallelism)]
    (build-images (or parallelism 4) cfg/installer-hashes (generate-variants filter-opts))))

(def cmd-table
  [{:cmds ["clean"]
    :fn   cmd-clean
    :doc  "Clean all generated Dockerfiles"}
   {:cmds ["dockerfiles"]
    :fn   cmd-dockerfiles
    :doc  "Generate Dockerfiles for matching variants"}
   {:cmds ["manifest"]
    :fn   cmd-manifest
    :doc  "Generate manifest for matching variants"
    :args->opts [:output-file]
    :spec   {:output-file {:desc "Output file (default: stdout)"}}}
   {:cmds ["build-images"]
    :fn   cmd-build-images
    :doc  "Build Docker images for matching variants"
    :spec {:parallelism {:alias     :p
                         :coerce    :long
                         :desc      "Number of parallel builds"
                         :default   4
                         :validate  pos?}}}])

(defn -main
  "Entrypoint for CLI."
  [& args]
  (logger/start)
  (cli/dispatch cmd-table args {:prog "docker-clojure" :help true})
  (logger/stop))

(defn run
  "Entrypoint for exec-fn (preserves compat with deps.edn :exec-fn)."
  [m]
  (let [cmd             (:cmd m)
        _parallelization (:parallelization m)
        variant-keys    (into [] (disj (set (keys m)) :cmd :parallelization))
        opts            (select-keys m variant-keys)]
    (logger/start)
    ((case cmd
       :clean        cmd-clean
       :dockerfiles  cmd-dockerfiles
       :manifest     cmd-manifest
       :build-images cmd-build-images)
     {:opts opts :args nil})
    (logger/stop)))