Remove atoms from server,db so app can be reloaded

src/clj/grub/core.clj

@@ -38,9 +38,13 @@
     (include-js "/js/grub.js")
     [:script {:type "text/javascript"} "goog.require(\"grub.core\")"]]))
 
-(def index-page (atom dev-index-page))
+(def prod-config
+  {:index prod-index-page
+   :database-name "grub"})
 
-(def default-port 3000)
+(def dev-config
+  {:index dev-index-page
+   :database-name "grub-dev"})
 
 (defn handle-websocket [handler]
   (fn [{:keys [websocket?] :as request}]
@@ -52,40 +56,25 @@
           (state/sync-new-client! to-client from-client)))
       (handler request))))
 
-(defn handle-root [handler]
+(defn handle-root [handler index]
   (fn [{:keys [uri] :as request}]
     (if (= uri "/")
-      (resp/response @index-page)
+      (resp/response index)
       (handler request))))
 
-(defn start-server [port]
+(defn make-handler [{:keys [index]}]
-  (httpkit/run-server (-> (fn [req] "Not found")
+  (-> (fn [req] "Not found")
-                          (file/wrap-file "public")
+      (file/wrap-file "public")
-                          (content-type/wrap-content-type)
+      (content-type/wrap-content-type)
-                          (handle-root)
+      (handle-root index)
-                          (handle-websocket))
+      (handle-websocket)))
-                      {:port port}))
 
-(defn run-integration-test []
+(defn start [{:keys [port database-name] :as config}]
-  (let [stop-server (start-server integration-test/server-port)]
+  (let [to-db (chan)
-    (println "Starting integration test server on localhost:" integration-test/server-port)
+        db (db/connect-and-handle-events to-db database-name)]
-    (integration-test/run)
+    (state/init-server to-db (db/get-current-state db))
-    (stop-server)))
+    (println "Starting server on localhost:" port)
-
+    (httpkit/run-server (make-handler config) {:port port})))
-(defn start-production-server [{:keys [port mongo-url]}]
-  (reset! index-page prod-index-page)
-  (let [to-db (chan)]
-    (db/connect-production-database to-db mongo-url)
-    (state/init-server to-db (db/get-current-state))
-    (println "Starting production server on localhost:" port)
-    (start-server port)))
-
-(defn start-development-server [{:keys [port]}]
-  (let [to-db (chan)]
-    (db/connect-development-database to-db)
-    (state/init-server to-db (db/get-current-state))
-    (println "Starting development server on localhost:" port)
-    (start-server port)))
 
 (defn usage [options-summary]
   (->> ["Usage: grub [options] action"
@@ -95,17 +84,14 @@
         ""
         "Actions:"
         "  dev[elopment]  Start development server"
-        "  prod[uction]   Start production server"
+        "  prod[uction]   Start production server"]
-        "  integration    Run integration tests"]
        (clojure.string/join \newline)))
 
 (def cli-options
   [["-p" "--port PORT" "Port number"
-    :default default-port
+    :default 3000
     :parse-fn #(Integer/parseInt %)
     :validate [#(< 0 % 0x10000) "Must be a number between 0 and 65536"]]
-   ["-m" "--mongo-url URL"
-    :default (System/getenv "MONGOHQ_URL")]
    ["-h" "--help"]])
 
 (defn error-msg [errors]
@@ -124,9 +110,8 @@
       (not= (count arguments) 1) (exit 1 (usage summary))
       errors (exit 1 (error-msg errors)))
     (case (first arguments)
-      "development" (start-development-server options)
+      "development" (start (merge dev-config options))
-      "dev"         (start-development-server options)
+      "dev"         (start (merge dev-config options))
-      "production"  (start-production-server options)
+      "production"  (start (merge prod-config options))
-      "prod"        (start-production-server options)
+      "prod"        (start (merge prod-config options))
-      "integration" (run-integration-test)
       (exit 1 (usage summary)))))

src/clj/grub/db.clj

@@ -6,44 +6,28 @@
             [monger.operators :as mo]
             [clojure.core.async :as a :refer [<! >! chan go]]))
 
-(def conn (atom nil))
-(def db (atom nil))
 (def collection "grub-lists")
-(def production-db "grub")
-(def development-db "grub-dev")
 
-(defn clear-all []
+(defn clear-all [db]
-  (mc/drop @db collection))
+  (mc/drop db collection))
 
-(defn update-db! [state]
+(defn update-db! [db state]
-  (mc/drop @db collection)
+  (mc/drop db collection)
-  (mc/insert @db collection state))
+  (mc/insert db collection state))
 
-(defn get-current-state []
+(defn get-current-state [db]
-  (let [state (first (mc/find-maps @db collection))]
+  (let [state (first (mc/find-maps db collection))]
     (if state
       (dissoc state :_id)
       sync/empty-state)))
 
-(defn connect! [db-name mongo-url]
+(defn connect-and-handle-events [to-db db-name]
-  (if mongo-url
+  (println "Connected to mongo at localhost:" db-name)
-    (do (println "Connected to mongo via url:" mongo-url)
+  (let [conn (m/connect)
-        (:conn (m/connect-via-uri mongo-url)))
+        db (m/get-db conn db-name)]
-    (do (println "Connected to mongo at localhost:" db-name)
+    (a/go-loop []
-        (m/connect))))
+               (if-let [state (<! to-db)]
-
+                 (do (update-db! db state)
-(defn connect-and-handle-events [to-db db-name & [mongo-url]]
+                     (recur))
-  (a/go-loop []
+                 (println "Database disconnected")))
-             (if-let [state (<! to-db)]
+    db))
-               (do (update-db! state)
-                   (recur))
-               (println "Database disconnected")))
-  (let [_conn (connect! db-name mongo-url)]
-    (reset! conn _conn)
-    (reset! db (m/get-db _conn db-name))))
-
-(defn connect-production-database [to-db mongo-url]
-  (connect-and-handle-events to-db production-db mongo-url))
-
-(defn connect-development-database [to-db]
-  (connect-and-handle-events to-db development-db))