Merge pull request #8049 from penpot/niwinz-virtual-clock-by-user

✨ Make the virtual clock by profile and not global

backend/src/app/http/debug.clj

@@ -49,13 +49,16 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defn index-handler
-  [_cfg _request]
-  (let [{:keys [clock offset]} @clock/current]
+  [cfg request]
+  (let [profile-id (::session/profile-id request)
+        offset     (clock/get-offset profile-id)
+        profile    (profile/get-profile cfg profile-id)]
     {::yres/status  200
      ::yres/headers {"content-type" "text/html"}
      ::yres/body    (-> (io/resource "app/templates/debug.tmpl")
                         (tmpl/render {:version (:full cf/version)
-                                      :current-clock  (str clock)
+                                      :profile profile
+                                      :current-clock  ct/*clock*
                                       :current-offset (if offset
                                                         (ct/format-duration offset)
                                                         "NO OFFSET")
@@ -447,15 +450,16 @@
 
 (defn- set-virtual-clock
   [_ {:keys [params] :as request}]
-  (let [offset (some-> params :offset str/trim not-empty ct/duration)
-        reset? (contains? params :reset)]
+  (let [offset     (some-> params :offset str/trim not-empty ct/duration)
+        profile-id (::session/profile-id request)
+        reset?     (contains? params :reset)]
     (if (= "production" (cf/get :tenant))
       {::yres/status 501
        ::yres/body "OPERATION NOT ALLOWED"}
       (do
         (if (or reset? (zero? (inst-ms offset)))
-          (clock/set-offset! nil)
-          (clock/set-offset! offset))
+          (clock/assign-offset profile-id nil)
+          (clock/assign-offset profile-id offset))
         {::yres/status 302
          ::yres/headers {"location" "/dbg"}}))))
 
@@ -495,7 +499,7 @@
 
 (defn authorized?
   [pool {:keys [::session/profile-id]}]
-  (or (= "devenv" (cf/get :host))
+  (or (and (= "devenv" (cf/get :host)) profile-id)
       (let [profile (ex/ignoring (profile/get-profile pool profile-id))
             admins  (or (cf/get :admins) #{})]
         (contains? admins (:email profile)))))

backend/src/app/http/session.clj

@@ -20,6 +20,7 @@
    [app.http.session.tasks :as-alias tasks]
    [app.main :as-alias main]
    [app.setup :as-alias setup]
+   [app.setup.clock :as clock]
    [app.tokens :as tokens]
    [integrant.core :as ig]
    [yetti.request :as yreq]
@@ -229,18 +230,22 @@
     (let [{:keys [type token claims metadata]} (get request ::http/auth-data)]
       (cond
         (= type :cookie)
-        (let [session (case (:ver metadata)
-                        ;; BACKWARD COMPATIBILITY WITH OLD TOKENS
-                        0 (read-session manager token)
-                        1 (some->> (:sid claims) (read-session manager))
-                        nil)
+        (let [session
+              (case (:ver metadata)
+                ;; BACKWARD COMPATIBILITY WITH OLD TOKENS
+                0 (read-session manager token)
+                1 (some->> (:sid claims) (read-session manager))
+                nil)
 
-              request (cond-> request
-                        (some? session)
-                        (-> (assoc ::profile-id (:profile-id session))
-                            (assoc ::session session)))
+              request
+              (cond-> request
+                (some? session)
+                (-> (assoc ::profile-id (:profile-id session))
+                    (assoc ::session session)))
 
-              response (handler request)]
+              response
+              (binding [ct/*clock* (clock/get-clock (:profile-id session))]
+                (handler request))]
 
           (if (and session (renew-session? session))
             (let [session (->> session

backend/src/app/setup/clock.clj

@@ -9,48 +9,35 @@
   modification of time offset (useful for testing and time adjustments)."
   (:require
    [app.common.logging :as l]
-   [app.common.time :as ct]
-   [app.setup :as-alias setup]
-   [integrant.core :as ig])
-  (:import
-   java.time.Clock
-   java.time.Duration
-   java.time.Instant
-   java.time.ZoneId))
+   [app.common.time :as ct]))
 
-(defonce current
-  (atom {:clock (Clock/systemDefaultZone)
-         :offset nil}))
+(defonce state
+  (atom {}))
 
-(defmethod ig/init-key ::setup/clock
-  [_ _]
-  (add-watch current ::common
-             (fn [_ _ _ {:keys [clock offset]}]
-               (let [clock (if (ct/duration? offset)
-                             (Clock/offset ^Clock clock
-                                           ^Duration offset)
-                             clock)]
-                 (l/wrn :hint "altering clock" :clock (str clock))
-                 (alter-var-root #'ct/*clock* (constantly clock))))))
+(defn assign-offset
+  "Assign virtual clock offset to a specific user. Is the responsability
+  of RPC module to properly bind the correct clock to the user
+  request."
+  [profile-id duration]
+  (swap! state (fn [state]
+                 (if (nil? duration)
+                   (dissoc state profile-id)
+                   (assoc state profile-id duration)))))
 
+(defn get-offset
+  [profile-id]
+  (get @state profile-id))
 
-(defmethod ig/halt-key! ::setup/clock
-  [_ _]
-  (remove-watch current ::common))
+(defn get-clock
+  [profile-id]
+  (if-let [offset (get-offset profile-id)]
+    (ct/offset-clock offset)
+    (ct/get-system-clock)))
 
-(defn fixed
-  "Get fixed clock, mainly used in tests"
-  [instant]
-  (Clock/fixed ^Instant (ct/inst instant)
-               ^ZoneId (ZoneId/of "Z")))
-
-(defn set-offset!
-  [duration]
-  (swap! current assoc :offset (some-> duration ct/duration)))
-
-(defn set-clock!
+(defn set-global-clock
   ([]
-   (swap! current assoc :clock (Clock/systemDefaultZone)))
+   (set-global-clock (ct/get-system-clock)))
   ([clock]
-   (when (instance? Clock clock)
-     (swap! current assoc :clock clock))))
+   (assert (ct/clock? clock) "expected valid clock instance")
+   (l/wrn :hint "altering clock" :clock (str clock))
+   (alter-var-root #'ct/*clock* (constantly clock))))