Initialize ignorabilis project

Author: ignorabilis

.gitignore

@@ -0,0 +1,23 @@
+*~
+*.iml
+*.jar
+*.class
+*.o
+*.pyc
+*.log
+*.a
+
+project.clj
+.nrepl-history
+
+/target
+/classes
+/.idea
+
+/resources/public/js
+/checkouts
+/script/repl.clj
+/.lein-*
+/.nrepl-port
+/out
+/.repl

build.boot

@@ -0,0 +1,106 @@
+#!/usr/bin/env boot
+
+(set-env!
+  :resource-paths #{"src/clj" "src/cljs"}
+  :dependencies '[[adzerk/boot-cljs "1.7.48-5" :scope "test"]
+                  [adzerk/boot-cljs-repl "0.3.0" :scope "test"]
+                  [adzerk/boot-reload "0.4.12" :scope "test"]
+                  [pandeiro/boot-http "0.7.1-SNAPSHOT" :scope "test"]
+                  [crisptrutski/boot-cljs-test "0.2.2-SNAPSHOT" :scope "test"]
+                  [com.cemerick/piggieback "0.2.1" :scope "test"]
+                  [weasel "0.7.0" :scope "test"]
+                  [org.clojure/tools.nrepl "0.2.10" :scope "test"]
+
+                  [org.clojure/clojure "1.7.0"]
+                  [org.clojure/clojurescript "1.7.228"]
+
+                  [environ "1.0.0"]
+                  [danielsz/boot-environ "0.0.4"]
+                  [org.danielsz/system "0.1.8"]
+                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]
+                  [com.taoensso/sente "1.5.0"]
+                  [http-kit "2.1.19"]
+                  ;; [org.immutant/web       "2.0.0-beta2"]
+                  [ring "1.4.0-RC1"]
+                  [ring/ring-defaults "0.1.5"]
+                  [bidi "2.0.9"]
+                  [compojure "1.3.4"]
+                  [hiccup "1.0.5"]
+                  [com.cognitect/transit-clj "0.8.275"]
+                  [com.cognitect/transit-cljs "0.8.220"]])
+
+(require
+  '[adzerk.boot-cljs :refer [cljs]]
+  '[adzerk.boot-cljs-repl :refer [cljs-repl start-repl]]
+  '[adzerk.boot-reload :refer [reload]]
+  '[crisptrutski.boot-cljs-test :refer [exit! test-cljs]]
+  '[pandeiro.boot-http :refer [serve]]
+  '[reloaded.repl :refer [init start stop go reset]]
+  '[ignorabilis.system.core :refer [dev-system]]
+  '[danielsz.boot-environ :refer [environ]]
+  '[system.boot :refer [system run]])
+
+(def version "0.1.0.0-SNAPSHOT")
+
+(task-options!
+  push {:ensure-branch nil}
+  pom {:project     'ignorabilis
+       :version     version
+       :description "Personal website"
+       :url         "https://bitbucket.org/irina-yaroslavova/ignorabilis"
+       :license     {"Eclipse Public License"
+                     "http://www.eclipse.org/legal/epl-v10.html"}})
+
+(defn- generate-lein-project-file! [& {:keys [keep-project] :or {:keep-project true}}]
+       (require 'clojure.java.io)
+       (let [pfile ((resolve 'clojure.java.io/file) "project.clj")
+             ; Only works when pom options are set using task-options!
+             {:keys [project version]} (:task-options (meta #'boot.task.built-in/pom))
+             prop #(when-let [x (get-env %2)] [%1 x])
+             head (list* 'defproject (or project 'boot-project) (or version "0.0.0-SNAPSHOT")
+                         (concat
+                           (prop :url :url)
+                           (prop :license :license)
+                           (prop :description :description)
+                           [:dependencies (get-env :dependencies)
+                            :repositories (get-env :repositories)
+                            :source-paths (vec (concat (get-env :source-paths)
+                                                       (get-env :resource-paths)))]))
+             proj (pp-str head)]
+            (if-not keep-project (.deleteOnExit pfile))
+            (spit pfile proj)))
+
+(deftask lein-generate
+         "Generate a leiningen `project.clj` file.
+          This task generates a leiningen `project.clj` file based on the boot
+          environment configuration, including project name and version (generated
+          if not present), dependencies, and source paths. Additional keys may be added
+          to the generated `project.clj` file by specifying a `:lein` key in the boot
+          environment whose value is a map of keys-value pairs to add to `project.clj`."
+         []
+         (generate-lein-project-file! :keep-project true))
+
+(deftask ignorabilis-build
+         "Builds an uberjar of the ignorabilis project that can be run with java -jar"
+         []
+         (comp
+           (aot :namespace '#{ignorabilis.core})
+           (pom :project 'ignorabilis
+                :version version)
+           (uber)
+           (jar :main 'ignorabilis.core)
+           (cljs :optimizations :advanced)
+           (target)))
+
+(deftask ignorabilis-dev []
+         (comp
+           (environ :env {:http-port 3019})
+           (watch)
+           (system :sys #'dev-system :auto-start true :hot-reload true :files ["core.clj"])
+           (reload)
+           (cljs :source-map true)
+           (repl :server true)))
+
+(defn -main [& args]
+      (require 'ignorabilis.core)
+      (apply (resolve 'ignorabilis.core/-main) args))

src/clj/ignorabilis/core.clj

@@ -0,0 +1,140 @@
+(ns ignorabilis.core
+    #_(:gen-class)
+    (:require
+      [clojure.string :as str]
+      [ring.middleware.defaults :refer [site-defaults]]
+      [compojure.core :as comp :refer (defroutes GET POST)]
+      [compojure.route :as route]
+      [hiccup.core :as hiccup]
+      [clojure.core.async :as async :refer (<! <!! >! >!! put! chan go go-loop)]
+      [taoensso.timbre :as timbre :refer (tracef debugf infof warnf errorf)]
+      [taoensso.sente :as sente]
+
+      ;;; ---> Choose (uncomment) a supported web server and adapter <---
+
+      [org.httpkit.server :as http-kit]
+
+      ;; or
+
+      ;; [immutant.web    :as immutant]
+
+      [reloaded.repl :refer [system]]))
+
+;;;; Logging config
+
+;; (sente/set-logging-level! :trace) ; Uncomment for more logging
+
+;;;; Server-side setup
+
+
+(defn landing-pg-handler [req]
+      (hiccup/html
+        [:h1 "Sente reference example"]
+        [:p "An Ajax/WebSocket connection has been configured (random)."]
+        [:hr]
+        [:p [:strong "Step 1: "] "Open browser's JavaScript console."]
+        [:p [:strong "Step 2: "] "Try: "
+         [:button#btn1 {:type "button"} "chsk-send! (w/o reply)"]
+         [:button#btn2 {:type "button"} "chsk-send! (with reply)"]]
+        ;;
+        [:p [:strong "Step 3: "] "See browser's console + nREPL's std-out."]
+        ;;
+        [:hr]
+        [:h2 "Login with a user-id"]
+        [:p "The server can use this id to send events to *you* specifically."]
+        [:p [:input#input-login {:type :text :placeholder "User-id"}]
+         [:button#btn-login {:type "button"} "Secure login!"]]
+        [:script {:src "main.js"}]                          ; Include our cljs target
+        ))
+
+(defn login!
+      "Here's where you'll add your server-side login/auth procedure (Friend, etc.).
+      In our simplified example we'll just always successfully authenticate the user
+      with whatever user-id they provided in the auth request."
+      [ring-request]
+      (let [{:keys [session params]} ring-request
+            {:keys [user-id]} params]
+           (debugf "Login request: %s" params)
+           {:status 200 :session (assoc session :uid user-id)}))
+
+(defroutes my-routes
+           (GET "/" req (landing-pg-handler req))
+           ;;
+           (GET "/chsk" req ((:ring-ajax-get-or-ws-handshake (:sente system)) req))
+           (POST "/chsk" req ((:ring-ajax-post (:sente system)) req))
+           (POST "/login" req (login! req))
+           ;;
+           (route/not-found "<h1>Page not found</h1>"))
+
+(def my-ring-handler
+  (let [ring-defaults-config
+        (-> site-defaults
+            (assoc-in [:static :resources] "/")
+            (assoc-in [:security :anti-forgery] {:read-token (fn [req] (-> req :params :csrf-token))}))]
+
+       ;; NB: Sente requires the Ring `wrap-params` + `wrap-keyword-params`
+       ;; middleware to work. These are included with
+       ;; `ring.middleware.defaults/wrap-defaults` - but you'll need to ensure
+       ;; that they're included yourself if you're not using `wrap-defaults`.
+       ;;
+       (ring.middleware.defaults/wrap-defaults my-routes ring-defaults-config)))
+
+;;;; Routing handlers
+
+;; So you'll want to define one server-side and one client-side
+;; (fn event-msg-handler [ev-msg]) to correctly handle incoming events. How you
+;; actually do this is entirely up to you. In this example we use a multimethod
+;; that dispatches to a method based on the `event-msg`'s event-id. Some
+;; alternatives include a simple `case`/`cond`/`condp` against event-ids, or
+;; `core.match` against events.
+
+(defmulti event-msg-handler :id)                            ; Dispatch on event-id
+;; Wrap for logging, catching, etc.:
+(defn event-msg-handler* [{:as ev-msg :keys [id ?data event]}]
+      (debugf "Event: %s" event)
+      (event-msg-handler ev-msg))
+
+(defmethod event-msg-handler :default                       ; Fallback
+           [{:as ev-msg :keys [event id ?data ring-req ?reply-fn send-fn]}]
+           (let [session (:session ring-req)
+                 uid (:uid session)]
+                (debugf "Unhandled event: %s" event)
+                (when ?reply-fn
+                      (?reply-fn {:umatched-event-as-echoed-from-from-server event}))))
+
+;; Add your (defmethod event-msg-handler <event-id> [ev-msg] <body>)s here...
+
+
+;;;; Example: broadcast server>user
+
+;; As an example of push notifications, we'll setup a server loop to broadcast
+;; an event to _all_ possible user-ids every 10 seconds:
+(defn start-broadcaster! []
+      (go-loop [i 0]
+               (<! (async/timeout 10000))
+               (println (format "Broadcasting server>user: %s" @(:connected-uids (:sente system))))
+               (doseq [uid (:any @(:connected-uids (:sente system)))]
+                      ((:chsk-send! (:sente system)) uid
+                        [:some/broadcast
+                         {:what-is-this "A broadcast pushed from server"
+                          :how-often    "Every 10 seconds"
+                          :to-whom      uid
+                          :i            i}]))
+               (recur (inc i))))
+
+; Note that this'll be fast+reliable even over Ajax!:
+(defn test-fast-server>User-pushes []
+      (doseq [uid (:any @(:connected-uids (:sente system)))]
+             (doseq [i (range 100)]
+                    ((:chsk-send! (:sente system)) uid [:fast-push/is-fast (str "hello " i "!!")]))))
+
+(comment (test-fast-server>user-pushes))
+
+;;;; Init
+
+(defn start! []
+      (start-broadcaster!))
+
+;; #+clj (start!) ; Server-side auto-start disabled for LightTable, etc.
+(comment (start!)
+         (test-fast-server>user-pushes))

src/clj/ignorabilis/system/core.clj

@@ -0,0 +1,22 @@
+(ns ignorabilis.system.core
+    (:require
+      [ignorabilis.core :refer [event-msg-handler* my-ring-handler]]
+      [taoensso.sente.server-adapters.http-kit :refer (sente-web-server-adapter)]
+      ;; or
+      ;; [taoensso.sente.server-adapters.immutant :refer (sente-web-server-adapter)]
+      ;; Optional, for Transit encoding:
+      [taoensso.sente.packers.transit :as sente-transit]
+      [environ.core :refer [env]]
+      [system.core :refer [defsystem]]
+      (system.components
+        [http-kit :refer [new-web-server]]
+        [sente :refer [new-channel-sockets]])))
+
+(defsystem dev-system
+           [:web (new-web-server (Integer. (env :http-port)) my-ring-handler)
+            :sente (new-channel-sockets event-msg-handler* sente-web-server-adapter)])
+
+(defsystem prod-system
+           [:web (new-web-server (Integer. (env :http-port)) my-ring-handler)
+            :sente (new-channel-sockets event-msg-handler* sente-web-server-adapter
+                                        {:packer (sente-transit/get-flexi-packer :edn)})])

src/cljs/ignorabilis/core.cljs

@@ -0,0 +1,115 @@
+(ns ignorabilis.core
+  (:require
+    [clojure.string  :as str]
+    [cljs.core.async :as async  :refer (<! >! put! chan)]
+    [taoensso.encore :as enc    :refer (tracef debugf infof warnf errorf)]
+    [taoensso.sente  :as sente  :refer (cb-success?)]
+    ;; Optional, for Transit encoding:
+    [taoensso.sente.packers.transit :as sente-transit])
+  (:require-macros
+    [cljs.core.async.macros :as asyncm :refer (go go-loop)]))
+
+;;;; Logging config
+
+;; (sente/set-logging-level! :trace) ; Uncomment for more logging
+;;;; Packer (client<->server serializtion format) config
+(def packer (sente-transit/get-flexi-packer :edn))
+;; (def packer :edn) ; Default packer (no need for Transit dep)
+
+(debugf "ClojureScript appears to have loaded correctly.")
+(let [rand-chsk-type (if (>= (rand) 0.5) :ajax :auto)
+
+      {:keys [chsk ch-recv send-fn state]}
+      (sente/make-channel-socket! "/chsk" ; Note the same URL as before
+                                  {:type   rand-chsk-type})]
+     (debugf "Randomly selected chsk type: %s" rand-chsk-type)
+     (def chsk       chsk)
+     (def ch-chsk    ch-recv) ; ChannelSocket's receive channel
+     (def chsk-send! send-fn) ; ChannelSocket's send API fn
+     (def chsk-state state)   ; Watchable, read-only atom
+     )
+
+;;;; Routing handlers
+
+(defmulti event-msg-handler :id) ; Dispatch on event-id
+;; Wrap for logging, catching, etc.:
+(defn     event-msg-handler* [{:as ev-msg :keys [id ?data event]}]
+          (debugf "Event: %s" event)
+          (event-msg-handler ev-msg))
+
+(defmethod event-msg-handler :default ; Fallback
+           [{:as ev-msg :keys [event]}]
+           (debugf "Unhandled event: %s" event))
+
+(defmethod event-msg-handler :chsk/state
+           [{:as ev-msg :keys [?data]}]
+           (if (= ?data {:first-open? true})
+             (debugf "Channel socket successfully established!")
+             (debugf "Channel socket state change: %s" ?data)))
+
+(defmethod event-msg-handler :chsk/recv
+           [{:as ev-msg :keys [?data]}]
+           (debugf "Push event from server: %s" ?data))
+
+(defmethod event-msg-handler :chsk/handshake
+           [{:as ev-msg :keys [?data]}]
+           (let [[?uid ?csrf-token ?handshake-data] ?data]
+                (debugf "Handshake: %s" ?data)))
+
+;; Add your (defmethod handle-event-msg! <event-id> [ev-msg] <body>)s here...
+
+
+;;;; Client-side UI
+
+(when-let [target-el (.getElementById js/document "btn1")]
+          (.addEventListener target-el "click"
+                             (fn [ev]
+                                 (debugf "Button 1 was clicked (won't receive any reply from server)")
+                                 (chsk-send! [:example/button1 {:had-a-callback? "nope"}]))))
+
+(when-let [target-el (.getElementById js/document "btn2")]
+          (.addEventListener target-el "click"
+                             (fn [ev]
+                                 (debugf "Button 2 was clicked (will receive reply from server)")
+                                 (chsk-send! [:example/button2 {:had-a-callback? "indeed"}] 5000
+                                             (fn [cb-reply] (debugf "Callback reply: %s" cb-reply))))))
+
+(when-let [target-el (.getElementById js/document "btn-login")]
+          (.addEventListener target-el "click"
+                             (fn [ev]
+                                 (let [user-id (.-value (.getElementById js/document "input-login"))]
+                                      (if (str/blank? user-id)
+                                        (js/alert "Please enter a user-id first")
+                                        (do
+                                          (debugf "Logging in with user-id %s" user-id)
+
+                                          ;;; Use any login procedure you'd like. Here we'll trigger an Ajax
+                                          ;;; POST request that resets our server-side session. Then we ask
+                                          ;;; our channel socket to reconnect, thereby picking up the new
+                                          ;;; session.
+
+                                          (sente/ajax-call "/login"
+                                                           {:method :post
+                                                            :params {:user-id    (str user-id)
+                                                                     :csrf-token (:csrf-token @chsk-state)}}
+                                                           (fn [ajax-resp]
+                                                               (debugf "Ajax login response: %s" ajax-resp)
+                                                               (let [login-successful? true ; Your logic here
+                                                                     ]
+                                                                    (if-not login-successful?
+                                                                            (debugf "Login failed")
+                                                                            (do
+                                                                              (debugf "Login successful")
+                                                                              (sente/chsk-reconnect! chsk))))))))))))
+
+(def router_ (atom nil))
+(defn  stop-router! [] (when-let [stop-f @router_] (stop-f)))
+(defn start-router! []
+      (stop-router!)
+      (reset! router_ (sente/start-chsk-router! ch-chsk event-msg-handler*)))
+
+
+(defn start! []
+      (start-router!))
+
+(start!)