   (let [u (if (string? url) (uri/uri url) url)]
     (assoc u :host (resolve-host (uri/host u)))))
 
+(def OldRequirements
+  {(s/optional-key :browser-name)  s/Str
+   (s/optional-key :reserved)      s/Bool
+   (s/optional-key :tags)          [s/Str]
+   (s/optional-key :node)          {:url s/Str}})
+
 (defn matches-requirements [session-model requirements]
+  (s/validate OldRequirements requirements)
   (let [exact-match-keys [:browser-name :reserved]
         resolved-nodes (map (comp str host-resolved-url)
                             (filter identity

        (car/sadd session-set-key session-id)
        (car/return (modify-session session-id defaulted-reqs))))))

(defn get-or-create-session
  [{:keys [browser-name
           node

         reserve-after-create nil
         force-create nil
         current-url nil}
    :as arg}]
  (s/validate OldGetOrCreateArg arg)
  (with-car*
    (car/return
      (or
        (if force-create
          (create-session
            (rename-keys arg
                         {:reserve-after-create :reserved})))
        (if-let [candidate (->> (view-models nil)
                                (filter #(matches-requirements % (dissoc arg :reserve-after-create)))
                                first)]
          (if (or reserve-after-create current-url)
            (modify-session (get candidate :id)
                            (rename-keys
                              (select-keys arg
                                           [:reserve-after-create
                                            :current-url
                                            :tags])
                              {:reserve-after-create :reserved}))
            candidate))
        (create-session arg)))))

(defn resume-webdriver-from-id [session-id]
  (if-let [model (view-model session-id)]
