@tolitius: does the state have to be in the same file as the handler? How does mount.core find start otherwise?

not working yet …. I have this

(ns app.handler
    (:require [castra.middleware :as castra]
      [compojure.core :as c]
      [compojure.route :as route]
      [ring.middleware.defaults :as d]
      [ring.util.response :as response]
      [mount.core :refer [defstate]]
      [app.datomic-seed :refer [get-conn]]))

(c/defroutes app-routes
             (c/GET "/" req (response/content-type (response/resource-response "index.html") "text/html"))
             (route/resources "/" {:root ""}))

(def app
  (-> app-routes
      (castra/wrap-castra 'app.api)
      (castra/wrap-castra-session "a 16-byte secret")
      (d/wrap-defaults d/api-defaults)))

(defstate datomic-conn :start (get-conn))

which is similar to your example

boot dev configured like this:

(deftask dev
  "Build castra-simple for local development."
  []
  (comp
    (serve
      :init 'mount.core/start
      :handler 'app.handler/app
      :reload true
      :port 8000)
    (watch)
    (speak)
    (hoplon)
    (reload)
    (cljs-repl)
    (cljs)))

and finally I also want to use the connection in the app

(ns app.api
    (:require
      [app.handler :refer [datomic-conn]]
      [app.datomic-query :refer [fetch-random-data]]
      [castra.core :refer [defrpc]]))

(defrpc get-state []
        {:random (fetch-random-data conn)})

the code for get-conn is like this:

(defn seed-db [conn]
      (print "Seeding DB... ")
      (create-schema conn)
      (doall (map #(insert-seed-data conn %) (range 256)))
      (println "done"))

(defn get-conn []
      (println "Fetching conn ... ")
      (if (d/create-database uri)
        (seed-db (d/connect uri)))
      (d/connect uri))

but I see no messages and the connection is always nil

I have pushed the failing code to my github so that you can take a look at the whole thing if you wish

https://github.com/opengrail/demos/tree/master/castra-datomic-free

ah.. did not pick up that you used boot, so did an example for you in lein-ring

looks like serve calls :init before app.handler is compiled, or it might be compiled, but not visible (yet, since these are boot tmp dirs) to mount at the point of :init

it does not matter where the defstate lives, as long as it is under :source-paths for a given task

mount.core/start does get called, but there is nothing to start (mount does not see sources at the point of :init)

in order to make it work you can just create a function anywhere in sources:

(defn init [] (mount.core/start))

(serve
      :init 'app.handler/init

ah ha - ok! thanks

re boot … I’m trying to keep up with the cool cats

yea, I am learning it myself. does look like mount/start is called before the app.handler is compiled

too see that you can put

(println "app.handler is compiled..")

and add this task:

(deftask mount-start []
  (println "started:" (mount/start))
  identity)

then instead of :init, just put this task in dev, you'll see that mount/start is called before that println

this is not to solve this, just to see it for yourself

I need to look what serve's :init does to understand better how external (outside of :source-paths) calls are handled.

since it's handled a bit differently from lein's way. this works: https://github.com/tolitius/mount/blob/lein-ring/project.clj#L34

let me know of init function solved it for you. I added a packaging section to the docs that explains it a bit more: https://github.com/tolitius/mount/blob/master/README.md#packaging

adding the (defn init[]…) function did the trick.

rock-n-roll

🎸

It's added into a pull request for the hoplon guys

For the Datomic demo