optional logging protocol

.gitignore

@@ -14,3 +14,4 @@ dev/dev.clj
 .clj-kondo/
 .lsp/
 nrepl.sh
+.env

README.md

@@ -37,6 +37,15 @@ Mark your work-in-progress PR's with ```WIP``` in the PR title.
 
 Every PR needs a proper description. Please link the issue you are adressing and explain how the PR goes about fixing the issue / adding the required feature.
 
+## Deployment
+
+In order to build a jar for Congest, run `clojure -T:build jar`. 
+This will create a `/target` directory with a jar, pom and all the necessary files for deployment.
+
+To delete the `/target` folder, run `clojure -T:build clean`.
+
+Finally, to deploy to clojars, run `env CLOJARS_USERNAME=clojars-username CLOJARS_PASSWORD=clojars-deploy-token clojure -T:build deploy`.
+
 ## Thats all folks!
 
 # HAPPY HACKING!!!!

build.clj

@@ -1,35 +1,50 @@
 (ns build
-  (:require [clojure.tools.build.api :as b]))
+  (:require [clojure.tools.build.api :as b]
+            [deps-deploy.deps-deploy :as dd]))
 
-(def lib 'com.modulr-software/congest)
-(def version "0.1.0")
+(def lib 'io.github.modulr-software/congest)
+(def version "0.1.7")
 (def class-dir "target/classes")
 (def basis (b/create-basis {:project "deps.edn"}))
 (def jar-file (format "target/%s-%s.jar" (name lib) version))
 
+(def pom-template
+  [[:description "Clojure Job Scheduler"]
+   [:licenses
+    [:license
+     [:name "MIT"]
+     [:url "https://opensource.org/license/mit"]]]
+   [:developers
+    [:developer
+     [:name "Modulr-Software"]]]])
+
 (defn clean [_]
   (b/delete {:path "target"}))
 
 (defn jar [_]
   (clean nil)
+  (b/write-pom {:class-dir class-dir
+                :lib lib
+                :version version
+                :basis basis
+                :src-dirs ["src"]
+                :pom-data pom-template})
   (b/copy-dir {:src-dirs ["src"]
                :target-dir class-dir})
   (b/jar {:class-dir class-dir
           :jar-file jar-file
           :basis basis
           :lib lib
-          :version version
-          :pom-data {:group (namespace lib)
-                     :artifact (name lib)
-                     :version version
-                     :description "congest"
-                     :url "https://github.com/modulr-software/congest"
-                     :licenses [{:name "MIT"
-                                 :url "https://opensource.org/licenses/MIT"}]}}))
+          :version version}))
 
 (defn install [_]
   (b/install {:basis basis
               :lib lib
               :version version
               :jar-file jar-file
               :class-dir class-dir}))
+
+(defn deploy [_]
+  (dd/deploy {:installer :remote
+              :artifact jar-file
+              :pom-file (b/pom-path {:lib lib :class-dir class-dir})}))

deps.edn

@@ -16,6 +16,6 @@
   {:exec-args   {:watch?     true
                  :skip-meta  :slow
                  :fail-fast? true}}
-  :build {:deps {io.github.clojure/tools.build {:git/tag "v0.10.9" :git/sha "e405aac"}}
-          :ns-default build
-          :exec-fn build/jar}}}
+  :build {:deps {io.github.clojure/tools.build {:git/tag "v0.10.9" :git/sha "e405aac"}
+                 slipset/deps-deploy {:mvn/version "0.2.2"}}
+          :ns-default build}}}

src/congest/jobs.clj

@@ -1,34 +1,48 @@
 (ns congest.jobs
-  (:require
-   [overtone.at-at :as at]
-   [congest.util :as util]))
+  (:require [overtone.at-at :as at]))
 
 (defn- -get-time []
   (.getTime (new java.util.Date)))
 
-(defn- -start-job [pool handler opts]
+(defn- -start-job
+  [pool handler {:keys [logger recurring? interval initial-delay] :as opts}]
   (if
    ;; test with initial delay nil
-   (:recurring? opts)
-    (at/every
-     (:interval opts)
-     handler
-     pool
-     :initial-delay
-     (max (:initial-delay opts) 100)) ;; set the minimum initial delay to 100
-
-    (at/after (:interval opts) handler pool)))
-
-(defn- -create-stop [pool handler opts]
-  (let [stop (-start-job pool handler opts)]
+   recurring?
+    (do
+      (when (some? logger)
+        (logger (merge opts {:log-time (-get-time)
+                             :action "start"})))
+      (at/every
+       interval
+       handler
+       pool
+       :initial-delay
+       (max initial-delay 100))) ;; set the minimum initial delay to 100
+
+    (do
+      (when (some? logger)
+        (logger (merge opts {:log-time (-get-time)
+                             :action "start"})))
+      (at/after interval handler pool))))
+
+(defn- -create-stop [pool handler {:keys [logger] :as opts}]
+  (let [extended-opts (merge opts {:log-time (-get-time)})
+        stop (-start-job pool handler opts)]
     (fn
       ([]
-       (util/dlog "Stopping job" at/stop stop)) ;; Log message before stopping the job
+       (when (some? logger)
+         (logger (merge extended-opts {:action "stop"})))
+       (at/stop stop)) ;; Log message before stopping the job
 
       ([kill?]
        (if kill?
-         (util/dlog "Killing job" at/kill stop) ;; Log message before killing the job
-         (util/dlog "Stopping job" at/stop stop)))))) ;; Log message before stopping the job
+         (do (when (some? logger)
+               (logger (merge extended-opts {:action "kill"})))
+             (at/kill stop)) ;; Log message before killing the job
+         (do (when (some? logger)
+               (logger (merge extended-opts {:action "stop"})))
+             (at/stop stop))))))) ;; Log message before stopping the job
 
 (defn- -stop! [*jobs job-id kill?]
   (let [{:keys [stop]} (get-in @*jobs [job-id])]
@@ -39,33 +53,51 @@
       (stop false))))
 
 (defn- -deregister! [*jobs job-id]
-  (when
-   (some? (get-in @*jobs [job-id]))
-    (-stop! *jobs job-id true)
-    (swap! *jobs dissoc job-id)))
+  (let [{:keys [logger] :as opts} (get-in @*jobs [job-id])]
+    (when (some? opts)
+      (when (some? logger)
+        (logger (merge opts {:log-time (-get-time)
+                             :action "deregister"})))
+      (-stop! *jobs job-id true)
+      (swap! *jobs dissoc job-id))))
 
 (defn- -handle-with-retries
   ([job]
    (-handle-with-retries job 0))
 
-  ([job tries]
+  ([{:keys [logger] :as job} tries]
    (let [handler (:handler job)
-         max-retries (:max-retries job)
+         max-retries (or (:max-retries job) 0)
+         extended-opts (merge job {:log-time (-get-time)
+                                   :action "run"
+                                   :tries tries
+                                   :max-retries max-retries})
          event (handler job)]
-     (if (and (< tries (or max-retries 0))
+     (if (and (< tries max-retries)
+              (> max-retries 0)
               (= event :fail))
-       (-handle-with-retries job
-                             (inc tries))
-
-       (assoc job :event (or event :success)))))) ;; if event is nil then we default to success
+       (do
+         (when (some? logger)
+           (logger (merge extended-opts {:event :fail})))
+         (-handle-with-retries job
+                               (inc tries)))
+       (if (= event :fail)
+         (do
+           (when (some? logger)
+             (logger (merge extended-opts {:event :fail})))
+           (assoc job :event :fail))
+         (do
+           (when (some? logger)
+             (logger (merge extended-opts {:event :success})))
+           (assoc job :event (or event :success)))))))) ;; if event is nil then we default to success
 
 (defmulti -maybe-deregister (fn [job] (:recurring? job)))
 
-(defmethod -maybe-deregister true [{:keys [stop-after-fail?
+(defmethod -maybe-deregister true [{:keys [stop-after-fail
                                            stop
                                            kill-after] :as job}]
   (cond (= (:event job) :fail)
-        (if (and (some? stop-after-fail?) (not stop-after-fail?))
+        (if (and (some? stop-after-fail) (not stop-after-fail))
           (assoc job :num-fails (inc (or (:num-fails job) 0)))
 
           (do
@@ -99,17 +131,20 @@
        (-increase-calls)
        (-post-run-cleanup)))
 
-(defn- -wrapper [*jobs job-id]
+(defn- -wrapper [*jobs {:keys [id] :as opts}]
   (fn []
-    (->> (get-in @*jobs [job-id])
+    (->> (get-in @*jobs [id])
          (-run-job)
-         (swap! *jobs assoc job-id))))
+         (swap! *jobs assoc id))))
 
-(defn- -register! [*jobs pool {:keys [id] :as opts}]
+(defn- -register! [*jobs pool {:keys [logger id] :as opts}]
+  (when (some? logger)
+    (logger (merge opts {:log-time (-get-time)
+                         :action "register"})))
   (when-not (some? (get-in @*jobs [id]))
     (->> (-create-stop
           pool
-          (-wrapper *jobs id)
+          (-wrapper *jobs opts)
           opts)
          (assoc opts :created-at (-get-time) :stop)
          (swap! *jobs assoc id))))
@@ -128,7 +163,8 @@
   (register! [this opts])
   (deregister! [this job-id])
   (stop! [this job-id kill?])
-  (read-jobs [this]))
+  (kill! [this])
+  (view [this]))
 
 (defn create-job-service [initial-data]
   (let [*jobs (atom {})
@@ -142,22 +178,29 @@
         (-deregister! *jobs job-id))
       (stop! [_ job-id kill?]
         (-stop! *jobs job-id kill?))
-      (kill [_]
-        (at/stop-and-reset-pool! job-pool :strategy :kill)))))
+      (kill! [_]
+        (at/stop-and-reset-pool! job-pool :strategy :kill))
+      (view [_]
+        @*jobs))))
 
 (comment
   (def initial-data-1 [])
   (def initial-data-2 [{:initial-delay 10
                         :auto-start true
                         :stop-after-fail false,
                         :id "test"
-                        :kill-after 1
-                        :num-calls nil
-                        :interval 1000
+                        ;:kill-after 5
+                        :num-calls 0
+                        :interval 60000
                         :recurring? true
                         :created-at nil
                         :handler (fn [metadata] (println "RUN"))
+                        :logger (fn [opts] (println opts))
                         :sleep false}])
 
   (def js (create-job-service initial-data-2))
-  (stop! js "test" false))
+  (view js)
+  (deregister! js "test")
+  (stop! js "test" true)
+
+  ())

src/congest/util.clj

@@ -2,4 +2,4 @@
 
 (defn dlog [message f & args]
   (println message)
-  (apply f args))
+  (apply f args))