remove :refer :all

Signed-off-by: Sean Corfield <[email protected]>

Author: seancorfield

CHANGELOG.md

@@ -0,0 +1,13 @@
+## CHANGES
+
+v0.1.8 in progress
+* Clean up lint issues; export clj-kondo config
+* Add a changelog!
+
+v0.1.7 -- 2025-09-02
+* Bring all dependencies up to date
+* Matrix test against Clojure 1.10, 1.11, and 1.12
+* Matrix test against JDK 11, 17, and 21 (also tested on JDK 24 manually)
+* Add `deps.edn`, `bb.edn`, `build.clj`
+* Add GitHub Actions for test, snapshot, and release
+* Remove non-functional CircleCI integration

README.md

@@ -15,20 +15,20 @@ This library implements a disk-backed task queue, allowing for queues that can s
 To interact with queues, first create a `queues` object by specifying a directory in the filesystem and an options map:
 
 ```clj
-> (require '[durable-queue :refer :all])
+> (require '[durable-queue :as dq])
 nil
-> (def q (queues "/tmp" {}))
+> (def q (dq/queues "/tmp" {}))
 #'q
 ```
 
 This allows us to `put!` and `take!` tasks from named queues.  `take!` is a blocking read, and will only return once a task is available or, if a timeout is defined (in milliseconds), once the timeout elapses:
 
 ```clj
-> (take! q :foo 10 :timed-out!)
+> (dq/take! q :foo 10 :timed-out!)
 :timed-out!
-> (put! q :foo "a task")
+> (dq/put! q :foo "a task")
 true
-> (take! q :foo)
+> (dq/take! q :foo)
 < :in-progress | "a task" >
 > (deref *1)
 "a task"
@@ -39,20 +39,20 @@ Notice that the task has a value describing its progress, and a value describing
 Calling `take!` removed the task from the queue, but just because we've taken the task doesn't mean we've completed the action associated with it.  In order to make sure the task isn't retried on restart, we must mark it as `complete!`.
 
 ```clj
-> (put! q :foo "another task")
+> (dq/put! q :foo "another task")
 true
-> (take! q :foo)
+> (dq/take! q :foo)
 < :in-progress | "another task" >
-> (complete! *1)
+> (dq/complete! *1)
 true
 ```
 
-If our task fails and we want to re-enqueue it to be tried again, we can instead call `(retry! task)`.  Tasks which are marked for retry are added to the end of the current queue.
+If our task fails and we want to re-enqueue it to be tried again, we can instead call `(dq/retry! task)`.  Tasks which are marked for retry are added to the end of the current queue.
 
 To get a description of the current state of the queue, we can use `stats`, which returns a map of queue names onto various counts:
 
 ```clj
-> (stats q)
+> (dq/stats q)
 {:enqueued 2,
  :retried 0,
  :completed 1,
@@ -90,7 +90,7 @@ A complete list of options is as follows:
 
 Disabling `:fsync-put?` will risk losing tasks if a process dies.  Disabling `:fsync-take?` increases the chance of a task being re-run when a process dies.  Disabling both will increase throughput of the queue by at least an order of magnitude (in the default configuration, ~1.5k tasks/sec on rotating disks and ~6k tasks/sec on SSD, with fsync completely disabled ~100k tasks/sec independent of hardware).
 
-Writes can be batched using `fsync-threshold` and/or `fsync-interval`, or by explicitly calling `(durable-queue/fsync q)`.  Setting the `fsync-threshold` to 10 will allow for ~25k tasks/sec on SSD, and still enforces a small upper boundary on how much data can be lost when the process dies.  An exception will be thrown if both per-task and batch sync options are set.
+Writes can be batched using `fsync-threshold` and/or `fsync-interval`, or by explicitly calling `(dq/fsync q)`.  Setting the `fsync-threshold` to 10 will allow for ~25k tasks/sec on SSD, and still enforces a small upper boundary on how much data can be lost when the process dies.  An exception will be thrown if both per-task and batch sync options are set.
 
 ### license
 

test/durable_queue_test.clj

@@ -1,8 +1,8 @@
 (ns durable-queue-test
   (:require
     [clojure.java.io :as io]
-    [clojure.test :refer :all]
-    [durable-queue :refer :all]
+    [clojure.test :refer [deftest is]]
+    [durable-queue :as dq]
     [criterium.core :as c]))
 
 (defn clear-tmp-directory []
@@ -13,121 +13,121 @@
 
 (deftest test-basic-put-take
   (clear-tmp-directory)
-  (let [q (queues "/tmp" {:slab-size 1024})
+  (let [q (dq/queues "/tmp" {:slab-size 1024})
         tasks (range 1e4)]
     (doseq [t tasks]
-      (put! q :foo t))
-    (is (= tasks (map deref (immediate-task-seq q :foo))))
-    (delete! q)))
+      (dq/put! q :foo t))
+    (is (= tasks (map deref (dq/immediate-task-seq q :foo))))
+    (dq/delete! q)))
 
 (deftest test-partial-slab-writes
   (clear-tmp-directory)
   (dotimes [i 10]
-    (put! (queues "/tmp") :foo i))
-  (is (= (range 10) (map deref (immediate-task-seq (queues "/tmp") :foo)))))
+    (dq/put! (dq/queues "/tmp") :foo i))
+  (is (= (range 10) (map deref (dq/immediate-task-seq (dq/queues "/tmp") :foo)))))
 
 (deftest test-retry
   (clear-tmp-directory)
-  (with-open [^java.io.Closeable q (queues "/tmp")]
+  (with-open [^java.io.Closeable q (dq/queues "/tmp")]
 
     (doseq [t (range 10)]
-      (put! q :foo t))
+      (dq/put! q :foo t))
 
-    (let [tasks' (immediate-task-seq q :foo)]
+    (let [tasks' (dq/immediate-task-seq q :foo)]
       (is (= (range 10) (map deref tasks')))
       (doseq [t (take 5 tasks')]
-        (complete! t))
+        (dq/complete! t))
       (doseq [t (range 10 15)]
-        (put! q :foo t))))
+        (dq/put! q :foo t))))
 
   ;; create a new manager, which will mark all in-progress tasks as incomplete
-  (with-open [^java.io.Closeable q (queues "/tmp")]
-    (let [tasks' (immediate-task-seq q :foo)]
+  (with-open [^java.io.Closeable q (dq/queues "/tmp")]
+    (let [tasks' (dq/immediate-task-seq q :foo)]
       (is (= (range 5 15) (map deref tasks')))
       (doseq [t (take 5 tasks')]
-        (complete! t))))
+        (dq/complete! t))))
 
-  (with-open [^java.io.Closeable q (queues "/tmp")]
-    (let [tasks' (immediate-task-seq q :foo)]
+  (with-open [^java.io.Closeable q (dq/queues "/tmp")]
+    (let [tasks' (dq/immediate-task-seq q :foo)]
       (is (= (range 10 15) (map deref tasks')))
       (doseq [t (range 15 20)]
-        (put! q :foo t))))
+        (dq/put! q :foo t))))
 
-  (let [q (queues "/tmp" {:complete? even?})]
-    (is (= (remove even? (range 10 20)) (map deref (immediate-task-seq q :foo))))))
+  (let [q (dq/queues "/tmp" {:complete? even?})]
+    (is (= (remove even? (range 10 20)) (map deref (dq/immediate-task-seq q :foo))))))
 
 ;;;
 
 (deftest ^:benchmark benchmark-put-take
   (clear-tmp-directory)
 
   (println "\n\n-- sync both")
-  (let [q (queues "/tmp" {:fsync-put? true, :fsync-take? true})]
+  (let [q (dq/queues "/tmp" {:fsync-put? true, :fsync-take? true})]
     (c/quick-bench
       (do
-        (put! q :foo 1)
-        (complete! (take! q :foo)))))
+        (dq/put! q :foo 1)
+        (dq/complete! (dq/take! q :foo)))))
 
   (println "\n\n-- sync take")
-  (let [q (queues "/tmp" {:fsync-put? false, :fsync-take? true})]
+  (let [q (dq/queues "/tmp" {:fsync-put? false, :fsync-take? true})]
     (c/quick-bench
       (do
-        (put! q :foo 1)
-        (complete! (take! q :foo)))))
+        (dq/put! q :foo 1)
+        (dq/complete! (dq/take! q :foo)))))
 
   (println "\n\n-- sync put")
-  (let [q (queues "/tmp" {:fsync-put? true, :fsync-take? false})]
+  (let [q (dq/queues "/tmp" {:fsync-put? true, :fsync-take? false})]
     (c/quick-bench
       (do
-        (put! q :foo 1)
-        (complete! (take! q :foo)))))
+        (dq/put! q :foo 1)
+        (dq/complete! (dq/take! q :foo)))))
 
   (println "\n\n-- sync every 10 writes")
-  (let [q (queues "/tmp" {:fsync-put? false, :fsync-threshold 10})]
+  (let [q (dq/queues "/tmp" {:fsync-put? false, :fsync-threshold 10})]
     (c/quick-bench
       (do
-        (put! q :foo 1)
-        (complete! (take! q :foo)))))
+        (dq/put! q :foo 1)
+        (dq/complete! (dq/take! q :foo)))))
 
   (println "\n\n-- sync every 100 writes")
-  (let [q (queues "/tmp" {:fsync-put? false, :fsync-threshold 100})]
+  (let [q (dq/queues "/tmp" {:fsync-put? false, :fsync-threshold 100})]
     (c/quick-bench
       (do
-        (put! q :foo 1)
-        (complete! (take! q :foo)))))
+        (dq/put! q :foo 1)
+        (dq/complete! (dq/take! q :foo)))))
 
   (println "\n\n-- sync every 100ms")
-  (let [q (queues "/tmp" {:fsync-put? false, :fsync-interval 100})]
+  (let [q (dq/queues "/tmp" {:fsync-put? false, :fsync-interval 100})]
     (c/quick-bench
       (do
-        (put! q :foo 1)
-        (complete! (take! q :foo)))))
+        (dq/put! q :foo 1)
+        (dq/complete! (dq/take! q :foo)))))
 
   (println "\n\n-- sync neither")
-  (let [q (queues "/tmp" {:fsync-put? false, :fsync-take? false})]
+  (let [q (dq/queues "/tmp" {:fsync-put? false, :fsync-take? false})]
     (c/quick-bench
       (do
-        (put! q :foo 1)
-        (complete! (take! q :foo))))))
+        (dq/put! q :foo 1)
+        (dq/complete! (dq/take! q :foo))))))
 
 ;;;
 
 (deftest ^:stress stress-queue-size
   (clear-tmp-directory)
 
-  (with-open [^java.io.Closeable q (queues "/tmp")]
+  (with-open [^java.io.Closeable q (dq/queues "/tmp")]
     (let [ary (byte-array 1e6)]
       (dotimes [i 1e6]
         (aset ary i (byte (rand-int 127))))
       (dotimes [_ 1e5]
-        (put! q :stress ary))))
+        (dq/put! q :stress ary))))
 
-  (with-open [^java.io.Closeable q (queues "/tmp" {:complete? (constantly false)})]
-    (let [s (doall (immediate-task-seq q :stress))]
+  (with-open [^java.io.Closeable q (dq/queues "/tmp" {:complete? (constantly false)})]
+    (let [s (doall (dq/immediate-task-seq q :stress))]
       (doseq [t s]
-        (retry! t)))
-    (let [s (immediate-task-seq q :stress)]
+        (dq/retry! t)))
+    (let [s (dq/immediate-task-seq q :stress)]
       (doseq [t s]
-        (complete! t))))
+        (dq/complete! t))))
 
   (clear-tmp-directory))