                (close! results)))
     results))
 
-(defn run-scenarios [options scenarios]
+(defn run-scenarios [options scenarios convert-from-legacy?]
   (println "Running simulation with" (runner-info (:runner options)))
   (let [simulation-start (local-time/local-now)
         sent-requests (atom 0)
+        runnable-scenarios (validate [schema/RunnableScenario] (if convert-from-legacy?
+                                                                 (convert-from-legacy scenarios)
+                                                                 scenarios))
         run-scenario-with-opts (partial run-scenario
                                         (assoc options
                                                :simulation-start simulation-start
                                                :sent-requests sent-requests))
-        responses (async/merge (map run-scenario-with-opts (convert-from-legacy scenarios)))
+        responses (async/merge (map run-scenario-with-opts runnable-scenarios))
         results (async/chan)]
     (go-loop []
              (if-let [result (<! responses)]

  (run-scenarios (assoc options :runner (choose-runner scenarios
                                                       concurrency
                                                       options))
                 (weighted-scenarios (range concurrency) scenarios)))



      c)))

(defn- convert-from-legacy [scenarios]
  (let [request->step (fn [request]
                        (-> request
                            (assoc :request (convert-legacy-fn request))
                            (dissoc :fn :http)))]
    (map (fn [scenario]
           (-> scenario
               (update :requests #(map request->step %))
               (rename-keys {:requests :steps})
               (dissoc :concurrency :weight)))
         scenarios)))

(defn- run-scenario [options scenario]
  (print-scenario-info scenario)
