Use java.time Durations and Instants. Remove clj-time.

Author: john-shaffer

src/io/staticweb/rate_limit/limits.clj

@@ -28,10 +28,10 @@
   (get-quota [self req])
   (get-ttl [self req]))
 
-(defrecord IpRateLimit [id quota ttl]
+(defrecord IpRateLimit [id quota ^java.time.Duration ttl]
   RateLimit
   (get-key [self req]
-    (str (.getName (type self)) id "-" (:remote-addr req)))
+    (str (.getName ^Class (type self)) id "-" (:remote-addr req)))
 
   (get-quota [self req]
     quota)

src/io/staticweb/rate_limit/middleware.clj

@@ -20,7 +20,7 @@
   An optional :response-builder can be provided to override the
   default 429 response. The builder must be a (fn [quota retry-after]
   ...) function where `quota` is the number of requests allowed by the
-  limit and `retry-after` is a clj-time/Joda DateTime specifying when
+  limit and `retry-after` is a java.time.Duration specifying when
   the rate-limit will be reset. The too-many-requests-response fn can
   be used as a helper in forming a proper 429 response."
   [handler {:keys [storage limit response-builder]}]
@@ -80,7 +80,7 @@
   limit in the storage (eg two IP-based limits on two different routes
   that should have independent counters).
 
-  Eg. (ip-rate-limit :my-limit 1000 (t/hours 1)) allows 1000 requests
+  Eg. (ip-rate-limit :my-limit 1000 (java.time.Duration/ofHours 1)) allows 1000 requests
   per hour per IP-address.
 
   Note: make sure that the incoming ring request has the
@@ -109,6 +109,6 @@
 
 (defn add-retry-after-header
   "Add a Retry-After header to the provided response. The
-  `retry-after` argument is expected to be a clj-time/Joda DateTime."
+  `retry-after` argument is expected to be a java.time.Duration."
   [rsp retry-after]
   (responses/add-retry-after-header rsp retry-after))

src/io/staticweb/rate_limit/redis.clj

@@ -1,6 +1,7 @@
 (ns io.staticweb.rate-limit.redis
   (:require [io.staticweb.rate-limit.storage :as storage]
-            [taoensso.carmine :as car]))
+            [taoensso.carmine :as car])
+  (:import [java.time Duration Instant]))
 
 (set! *warn-on-reflection* true)
 
@@ -24,23 +25,23 @@
       (if-let [counter (car/wcar
                         conn-opts
                         (car/get redis-key))]
-        (Integer. counter)
+        (Integer/parseInt counter)
         0)))
 
   (increment-count [self key ttl]
     (let [redis-key (generate-redis-key key)
-          ttl-in-secs (-> ttl .toStandardDuration .getStandardSeconds)]
+          ttl-in-secs (-> ^Duration ttl .getSeconds)]
       (car/wcar
        conn-opts
        (car/eval* ttl-incr-script 1 redis-key ttl-in-secs))))
 
   (counter-expiry [self key]
-    (let [now (t/now)
+    (let [now (Instant/now)
           redis-key (generate-redis-key key)
           ttl (car/wcar conn-opts (car/ttl redis-key))]
       (if (neg? ttl)
         now
-        (t/plus now (t/seconds ttl)))))
+        (.plus now (Duration/ofSeconds ttl)))))
 
   (clear-counters [self]
     (let [redis-key (generate-redis-key "*")]

src/io/staticweb/rate_limit/responses.clj

@@ -1,19 +1,12 @@
-(ns io.staticweb.rate-limit.responses
-  (:require [clj-time.format :as f]))
+(ns io.staticweb.rate-limit.responses)
 
 (set! *warn-on-reflection* true)
 
 (def default-response
   "The default 429 response."
-  {:headers {"Content-Type" "application/json"}
-   :body "{\"error\": \"Too Many Requests\"}"})
-
-(def ^:private time-format (f/formatter "EEE, dd MMM yyyy HH:mm:ss"))
-
-(defn- time->str
-  [time]
-  ;; All HTTP timestamps MUST be in GMT and UTC == GMT in this case.
-  (str (f/unparse time-format time) " GMT"))
+  {:status 429
+   :headers {"Content-Type" "application/json"}
+   :body "{\"error\":\"rate-limit-exceeded\"}"})
 
 (defn rate-limit-applied?
   [rsp]
@@ -26,10 +19,10 @@
   (assoc rsp ::rate-limit-applied quota-state))
 
 (defn add-retry-after-header
-  [rsp retry-after]
+  [rsp ^java.time.Duration retry-after]
   (assoc-in rsp
             [:headers "Retry-After"]
-            (time->str retry-after)))
+            (str (.getSeconds retry-after))))
 
 (defn too-many-requests-response
   ([retry-after]

src/io/staticweb/rate_limit/storage.clj

@@ -1,8 +1,10 @@
 (ns io.staticweb.rate-limit.storage
-  (:require [clj-time.core :as t]))
+  (:import [java.time Duration Instant]))
 
 (set! *warn-on-reflection* true)
 
+(defn now ^Instant []
+  (Instant/now))
 
 (defprotocol Storage
   "A protocol describing the interface for storage backends.
@@ -18,15 +20,15 @@
   will expire, ie when the rate limit is reset again."
 
   (get-count [self key])
-  (increment-count [self key ttl])
+  (increment-count [self key ^Duration ttl])
   (counter-expiry [self key])
   (clear-counters [self]))
 
 ;;; LocalStorage implementation
 (defn- expired-keys
-  [m now]
+  [m ^Instant now]
   (->> (:timeouts m)
-       (filter (fn [[k v]] (t/before? v now)))
+       (filter (fn [[k ^Instant v]] (.isAfter v now)))
        (map first)))
 
 (defn- remove-key
@@ -37,21 +39,21 @@
 
 (defn- remove-expired-keys
   [state]
-  (doseq [k (expired-keys @state (t/now))]
+  (doseq [k (expired-keys @state (now))]
     (swap! state remove-key k)))
 
 (defn- increment-key
   "Increment the counter in the state map.
 
   If the counter didn't exist already, we also record the time when
   the counter expires."
-  [state key ttl]
+  [state key ^Duration ttl]
   (if (get-in state [:counters key])
     (update-in state [:counters key] inc)
     (->
      state
      (assoc-in [:counters key] 1)
-     (assoc-in [:timeouts key] (t/plus (t/now) ttl)))))
+     (assoc-in [:timeouts key] (.plus (now) ttl)))))
 
 (defrecord LocalStorage [state]
   Storage
@@ -66,7 +68,7 @@
   (counter-expiry [self key]
     (if-let [timeout (get-in @state [:timeouts key])]
       timeout
-      (t/now)))
+      (now)))
 
   (clear-counters [self]
     (reset! state {})))

test/io/staticweb/rate_limit/acceptance_test.clj

@@ -3,8 +3,10 @@
         compojure.core
         io.staticweb.rate-limit.middleware
         io.staticweb.rate-limit.test-utils)
-  (:require [io.staticweb.rate-limit.storage :as s]
-            [ring.mock.request :as mock]))
+  (:require [io.staticweb.rate-limit.redis :as redis]
+            [io.staticweb.rate-limit.storage :as s]
+            [ring.mock.request :as mock])
+  (:import [java.time Duration Instant]))
 
 (def default-response-handler
   (constantly default-response))
@@ -13,7 +15,7 @@
   "A collection of functions used to instantiate the various storage
   backends."
   [s/local-storage
-   #(s/redis-storage {:spec {:host "localhost" :port 6379}})])
+   #(redis/redis-storage {:spec {:host "localhost" :port 6379}})])
 
 (defn create-storage
   [factory-fn]
@@ -24,7 +26,7 @@
   (testing "wrap-rate-limit"
     (doseq [storage-factory-fn storage-factory-fns]
       (let [storage (create-storage storage-factory-fn)
-            limit (ip-rate-limit :test 1 (t/seconds 1))
+            limit (ip-rate-limit :test 1 (Duration/ofSeconds 1))
             response-builder (fn [& args]
                                (apply too-many-requests-response
                                       {:headers
@@ -82,7 +84,7 @@
   (testing "single wrap-stacking-rate-limit instance"
     (doseq [storage-factory-fn storage-factory-fns]
       (let [storage (create-storage storage-factory-fn)
-            limit (ip-rate-limit :test 1 (t/seconds 1))
+            limit (ip-rate-limit :test 1 (Duration/ofSeconds 1))
             response-builder (partial too-many-requests-response
                                       {:headers
                                        {"Content-Type" "text/plain"}
@@ -153,10 +155,10 @@
   (testing "multiple wrap-stacking-rate-limit instance"
     (doseq [storage-factory-fn storage-factory-fns]
       (let [storage (create-storage storage-factory-fn)
-            first-limit (ip-rate-limit :test 1 (t/seconds 1))
+            first-limit (ip-rate-limit :test 1 (Duration/ofSeconds 1))
             first-config {:storage storage
                           :limit first-limit}
-            second-limit (->MethodRateLimit #{:get} 1 (t/seconds 1))
+            second-limit (->MethodRateLimit #{:get} 1 (Duration/ofSeconds 1))
             second-response-builder (partial too-many-requests-response
                                              {:headers
                                               {"Content-Type" "text/plain"}

test/io/staticweb/rate_limit/limits_test.clj

@@ -1,16 +1,16 @@
 (ns io.staticweb.rate-limit.limits-test
-  (:require [clj-time.core :as t]
-            [clojure.test :refer :all]
-            [io.staticweb.rate-limit.limits :refer :all]))
+  (:use clojure.test
+        io.staticweb.rate-limit.limits)
+  (:import java.time.Duration))
 
 (deftest ^:unit test-ip-rate-limit
   (testing "IpRateLimit"
-    (let [limit (->IpRateLimit :test 100 (t/seconds 10))
+    (let [limit (->IpRateLimit :test 100 (Duration/ofSeconds 10))
           req {:remote-addr "127.0.0.1"}]
       (is (= (get-key limit req)
-             "io.staticweb.rate-limit.limits.IpRateLimit:test-127.0.0.1"))
+             "io.staticweb.rate_limit.limits.IpRateLimit:test-127.0.0.1"))
       (is (= (get-quota limit req) 100))
-      (is (= (get-ttl limit req) (t/seconds 10))))))
+      (is (= (get-ttl limit req) (Duration/ofSeconds 10))))))
 
 (deftest ^:unit test-nil-rate-limit
   (testing "nil as a RateLimit"

test/io/staticweb/rate_limit/middleware_test.clj

@@ -1,11 +1,11 @@
 (ns io.staticweb.rate-limit.middleware-test
-  (:require [clj-time.coerce :as c]
-            [clojure.test :refer :all]
-            [io.staticweb.rate-limit.limits :as l]
-            [io.staticweb.rate-limit.middleware :refer :all]
+  (:use clojure.test
+        io.staticweb.rate-limit.middleware
+        io.staticweb.rate-limit.test-utils)
+  (:require [io.staticweb.rate-limit.limits :as l]
             [io.staticweb.rate-limit.responses :as r]
-            [io.staticweb.rate-limit.storage :as s]
-            [io.staticweb.rate-limit.test-utils :refer :all]))
+            [io.staticweb.rate-limit.storage :as s])
+  (:import java.time.Duration))
 
 (defrecord MockStorage [counters timeouts]
   s/Storage
@@ -37,7 +37,7 @@
   [counters & body]
   `(binding [*storage* (->MockStorage (atom {}) (atom {}))]
      (doseq [[k# v# e#] ~counters]
-       (set-counter k# v# (c/from-date e#)))
+       (set-counter k# v# e#))
      ~@body))
 
 (defn make-request
@@ -66,17 +66,17 @@
         (is (= (s/counter-expiry *storage* :mock-limit-key) :mock-ttl)))))
 
   (testing "with exhausted limit"
-    (with-counters [[:mock-limit-key 10 #inst "2014-12-31T12:34:56Z"]]
+    (with-counters [[:mock-limit-key 10 (Duration/ofMinutes 5)]]
       (let [limit (->MockRateLimit 10 :mock-limit-key :mock-ttl)
             rsp (make-request wrap-stacking-rate-limit limit)]
         (is (= (:status rsp) 429))
         (is (= (::r/rate-limit-applied rsp) {:key :mock-limit-key
                                              :quota 10
                                              :remaining 0}))
-        (is (= (retry-after rsp) "Wed, 31 Dec 2014 12:34:56 GMT")))))
+        (is (= (retry-after rsp) "300")))))
 
   (testing "with custom 429 reponse"
-    (with-counters [[:mock-limit-key 10 #inst "2014-12-31T12:34:56Z"]]
+    (with-counters [[:mock-limit-key 10 (Duration/ofSeconds 42)]]
       (let [limit (->MockRateLimit 10 :mock-limit-key :mock-ttl)
             custom-response-handler (fn [key retry-after]
                                       {:status 418
@@ -111,7 +111,7 @@
           (is (= (s/counter-expiry *storage* :first-limit-key) :first-ttl))))))
 
   (testing "with exhausted first rate limit"
-    (with-counters [[:first-limit-key 1000 #inst "2014-12-31T12:34:56Z"]]
+    (with-counters [[:first-limit-key 1000 (Duration/ofMillis 15000)]]
       (let [first-limit (->MockRateLimit 1000 :first-limit-key :first-ttl)
             second-limit (->MockRateLimit 10 :second-limit-key :second-ttl)
             handler (-> default-response
@@ -125,12 +125,12 @@
           (is (= (::r/rate-limit-applied rsp) {:key :first-limit-key
                                                :quota 1000
                                                :remaining 0}))
-          (is (= (retry-after rsp) "Wed, 31 Dec 2014 12:34:56 GMT"))
+          (is (= (retry-after rsp) "15"))
           (is (= (s/get-count *storage* :first-limit-key) 1000))
           (is (= (s/get-count *storage* :second-limit-key) 0))))))
 
   (testing "with exhausted second rate limit"
-    (with-counters [[:second-limit-key 10 #inst "2014-12-31T12:34:56Z"]]
+    (with-counters [[:second-limit-key 10 (Duration/ofHours 3)]]
       (let [first-limit (->MockRateLimit 1000 :first-limit-key :first-ttl)
             second-limit (->MockRateLimit 10 :second-limit-key :second-ttl)
             handler (-> default-response
@@ -144,6 +144,6 @@
           (is (= (::r/rate-limit-applied rsp) {:key :second-limit-key
                                                :quota 10
                                                :remaining 0}))
-          (is (= (retry-after rsp) "Wed, 31 Dec 2014 12:34:56 GMT"))
+          (is (= (retry-after rsp) "10800"))
           (is (= (s/get-count *storage* :first-limit-key) 0))
           (is (= (s/get-count *storage* :second-limit-key) 10)))))))