initial commit

.gitignore

+/target
+/classes
+/checkouts
+pom.xml
+pom.xml.asc
+*.jar
+*.class
+/.lein-*
+/.nrepl-port
+*.iml
+*.log
+.idea
+.lsp
\ No newline at end of file

README.md

 # clojure_api_and_sockets_example
 
-Example http-kit API server + socket server, internal scheduler, mount parts, honeysql
\ No newline at end of file
+Example http-kit API server with swagger + socket server, internal scheduler, mount parts, honeysql
+
+Need to create .lein-env file or set env variables, crypto keys, java-home if needed, db schema
+
+<pre>
+{
+    :crypt-lock        "some-secret-key3"
+    :socket-admin-pass "44acbaa115989f03632752fa625a2541"
+    :java-home         "/opt/jdk"
+    :cl-database-url   "jdbc:mysql://host:3306/dbname?zeroDateTimeBehavior=CONVERT_TO_NULL&user=username&password=yourpassword&useSSL=false"
+}
+</pre>
\ No newline at end of file

bench/socket.sh

+#!/bin/sh
+
+# Thor is WebSocket benchmarking/load generator.
+# https://github.com/observing/thor
+
+thor --amount 5000 ws://localhost:4444/socket?uid=youruid

build_graalvm.sh

+# native-image -jar ./target/cl.jar -H:Class=cl.main
+
+# static
+native-image -jar ./target/cl.jar --static --libc=glibc -H:Class=cl.main
+
+# mostly static only with glibc external
+# native-image -jar ./target/cl.jar -H:+StaticExecutableWithDynamicLibC -H:Class=cl.main

deploy

+lein with-profile uberjar uberjar

project.clj

+(defproject cl "0.1.0-SNAPSHOT"
+  :description "cl server"
+  :url ""
+  :dependencies [[org.clojure/clojure "1.10.3"]
+                 [environ "1.2.0"]
+                 [ring/ring-json "0.5.1"]
+                 [http-kit "2.5.3"]
+                 [ring/ring-devel "1.9.3"]
+                 [compojure "1.6.2"]
+                 [ring/ring-defaults "0.3.3"]
+                 [ring-cors "0.1.13"]
+                 [mount "0.1.16"]
+                 [mysql/mysql-connector-java "8.0.25"]
+                 ;; _- db conversion
+                 [camel-snake-kebab "0.4.2"]
+                 ;; for compile uberjar
+                 [javax.servlet/servlet-api "2.5"]
+                 ;LOGGING
+                 [com.taoensso/timbre "5.1.2"]
+                 [com.fzakaria/slf4j-timbre "0.3.21"]
+                 ;; scheduler
+                 [im.chit/cronj "1.4.4"]
+                 ;; url utils
+                 [com.cemerick/url "0.1.1"]
+                 [com.github.seancorfield/next.jdbc "1.2.674"]
+                 [com.github.seancorfield/honeysql "2.0.0-rc2"]
+                 [metosin/compojure-api "2.0.0-alpha31"]
+                 [clj-time "0.15.2"]
+                 [lock-key "1.5.0"]
+                 ;; test
+                 ;; nice lib about all
+                 [tupelo "21.06.15"]]
+
+  ;; How to connect to remote REPL + ssh tunnel
+  ;; ssh -L :6666:localhost:6666 sonline.su@p1-0 -N -v
+  ;; (-v is verbose to detect problems)
+  ;; then connect from IDE to local port 6666 as usual
+  :repl-options {:port 6666
+                 :timeout 120000}
+
+  :main cl.main
+  :uberjar-name "cl.jar"
+  ;; See https://github.com/weavejester/lein-ring#web-server-options for the
+  ;; various options available for the lein-ring plugin
+  :ring {:handler cl.handler/-main
+         ;;:async? true
+         :auto-reload? true
+         :auto-refresh? true
+         :nrepl {:start? true
+                 :port 4242}}
+
+  :profiles {:uberjar {:aot :all}
+             :dev
+             {:dependencies
+              [[javax.servlet/servlet-api "2.5"]]}}
+
+  ;; or use global LEIN_JVM_OPTS=-Xms4G -Xmx4G
+  ;; or for prod JVM_OPTS=-Xms4G
+  ;; + remote monitoring
+  ;; Windows users: putty.exe -ssh user@serv -L 1616:p1-0:1616
+  ;; Linux and Mac Users: ssh user@serv -L 1616:p1-0:1616
+  ;; Start jconsole on your computer
+  ;; jconsole localhost:1616
+  :jvm-opts ["-Xmx4g"
+             ; for remote connect thru ssh tunnel
+             "-Dcom.sun.management.jmxremote.port=1616"
+             "-Dcom.sun.management.jmxremote.rmi.port=1616"
+             "-Dcom.sun.management.jmxremote.ssl=false"
+             "-Dcom.sun.management.jmxremote.authenticate=false"
+             "-Dcom.sun.management.jmxremote.local.only=false"
+             "-Djava.rmi.server.hostname=localhost"])

run

+#!/bin/sh
+lein run
\ No newline at end of file

run-dev

+#!/bin/sh
+(echo "(start)"; cat <&0) | lein do clean, repl
\ No newline at end of file

run-prod

+#!/bin/sh
+java -cp ./cl.jar -Dclojure.server.repl="{:port 5555 :accept clojure.core.server/repl}" cl.main
+
+# then you can use REPL
+#   rlwrap nc localhost 5555
+# or use unravel repl
+#   unravel localhost 5555
+
+
+#(clojure.core/require '[clojure.tools.namespace.repl :refer [refresh]])
+#user=> (refresh)
+
+#(clojure.core/require '[clojure.repl :as r :refer [doc]])
\ No newline at end of file

src/cl/core.clj

+(ns cl.core
+  (:require
+    [org.httpkit.server :as httpkit :refer [run-server]]
+    [ring.middleware.cors :as ring-cors :refer [wrap-cors]]
+    [ring.middleware.cookies :refer [wrap-cookies]]         ;; for cookie store
+    ;[clj-redis-session.core :only [redis-store]]           ;; for redis store, if cluster
+    [ring.middleware.params :refer [wrap-params]]
+    [ring.middleware.reload :as ring-reload]
+    [ring.util.response :as ring-response]
+    [ring.util.request :as ring-request]
+    [mount.core :as mount :refer [defstate]]
+    [clojure.tools.namespace.repl :refer [refresh refresh-all]]
+    [ring.middleware.json :refer [wrap-json-response]]
+    [ring.middleware.keyword-params :refer [wrap-keyword-params]]
+    [compojure.api.sweet :refer [defroutes]]
+    [compojure.route :as route]
+    [ring.middleware.session :as session :refer [wrap-session]]
+    [ring.middleware.session.memory :refer [memory-store]]
+    [environ.core :refer [env]]
+    [clojure.string :as str]
+    [lock-key.core :refer [decrypt decrypt-as-str decrypt-from-base64
+                           encrypt encrypt-as-base64]]
+    [cl.log :as log]
+    [cl.routes.ws-routes :as ws-routes]
+    [cl.routes.http-routes :as http-routes]
+    [cl.libs.main :refer [string-to-bytes]]
+    [cl.models.user :as user]
+    [tupelo.core :refer [discarding-system-err]]
+    [cl.libs.api :as api]
+    [ring.util.http-response :as http :refer :all]))
+
+;discarding-system-out
+
+;; clj-redis-session use Carmine as its Redis client
+;; if needed
+;(def redis-conn
+;  {:pool {}
+;   :spec {:uri "redis://clsession:1foo12bare2@localhost:9836/"}})
+
+(defroutes app-routes
+  ws-routes/ws-routes
+  http-routes/http-routes
+  (route/not-found (ring-response/response {:error "Route not found"})))
+
+(defn wrap-history
+  "Middleware that stores last 20 visited urls in session"
+  [handler]
+  (fn [req]
+    (let [resp            (handler req)
+          session         (or (:session resp) (:session req))
+          updated-session (assoc session :history
+                                         (vec (take-last 20 (concat (:history session) [(ring-request/request-url req)]))))]
+      (assoc resp :session updated-session))))
+
+(defn wrap-auth
+  "Middleware user auth + cache it in session for fun"
+  [handler]
+  (fn [req]
+    (let [resp            (handler req)
+          session         (or (:session resp) (:session req))
+          headers         (get req :headers)
+          apikey          (get headers "apikey")
+          user-session    (get session :user)
+          apikey-info     (if-not (empty? apikey)
+                            (try
+                              (let [decoded  (decrypt-from-base64
+                                               apikey (env :crypt-lock))
+                                    splitted (when-not (empty? decoded)
+                                               (str/split decoded #"\|"))]
+                                splitted)
+                              (catch Exception e (do
+                                                   (println "Decode apikey error: " (.getMessage e))
+                                                   ;(throw (ex-info (str (api/answer http/forbidden "invalid-apikey" "Invalid apikey in headers" false)) {}))
+                                                   false
+                                                   ))))
+          updated-session (if-not (false? apikey-info)
+                            (if-not (nil? apikey-info)
+                              (if (= (str (get user-session :id)) (first apikey-info))
+                                (let [count             (:user-cached-count session 0)
+                                      user-cached-count {:user-cached-count (inc count)}]
+                                  (println "CACHED FROM SESSION: " (str (inc count)))
+                                  user-cached-count)
+                                (let [u (user/get-user-info (first apikey-info))]
+                                  (println "NEW GET FROM DB")
+                                  {:user u}))
+                              (do
+                                (println "ASSIGN REQ NIL")
+                                {:user              nil
+                                 :user-cached-count 0}
+                                )))
+          ]
+      (if (false? apikey-info)
+        (api/simple-answer 401 "invalid-apikey" "Invalid apikey in headers" "")
+        (assoc resp :session (merge session updated-session))))))
+
+;(do (mount/stop #'cl.core/my-server)
+;    (mount/start #'cl.core/my-server))
+
+(defn in-dev? [] true)
+
+(defn args->server-config [args]
+  {:port          (Integer/parseInt
+                    (or (first args)
+                        (System/getenv "PORT")
+                        "4444"))
+   :join?         false
+   :server-header nil
+   :queue-size    204800})
+
+(defn start-server [server-config]
+  (let [handler (if (in-dev?)
+                  (ring-reload/wrap-reload #'app-routes)
+                  #'app-routes)]
+    (when-let [server (httpkit/run-server
+                        (-> handler
+                            (ring.middleware.json/wrap-json-body {:keywords? true})
+                            (ring.middleware.json/wrap-json-response)
+                            (ring.middleware.keyword-params/wrap-keyword-params)
+                            (ring.middleware.params/wrap-params)
+                            (ring.middleware.json/wrap-json-params)
+                            (ring-cors/wrap-cors
+                              :access-control-allow-origin #".+")
+                            (wrap-auth)
+                            (wrap-history)
+                            (wrap-session {
+                                           ;:store        use other store than default memory
+                                           :cookie-name  "session"
+                                           :root         "/"
+                                           :cookie-attrs {
+                                                          :max-age   3600
+                                                          :http-only true
+                                                          }})
+                            )
+                        server-config)]
+      (log/info "Server has started! =)")
+      server)))
+
+;All state changing without server restart is experimental now
+(defstate                                                   ; ^{:on-reload :noop}
+          my-server
+          :start (start-server (args->server-config
+                                 (mount/args)))
+          :stop (do
+                  (my-server :timeout 10000)
+                  (log/info "Server has stopped...")))

src/cl/db.clj

+(ns cl.db
+  (:require [environ.core :refer [env]]
+            [next.jdbc :as jdbc]
+            [next.jdbc.result-set :as rs]
+            [honey.sql :as sql]
+            [mount.core :refer [defstate]]))
+
+(def db (env :cl-database-url))
+
+;; to start all the states call mount/start in handler.clj
+
+(defstate ^:dynamic *db*
+          :start (jdbc/get-datasource db)
+          :stop (print "stop"))
+
+(defn queryAll
+  [sql-statement]
+  (with-open [connection (jdbc/get-connection db)]
+    (let [sql (sql/format sql-statement {:dialect :mysql})]
+      (jdbc/execute! connection sql
+                     {:builder-fn rs/as-unqualified-lower-maps}))))
+
+(defn queryOne
+  [sql-statement]
+  (with-open [connection (jdbc/get-connection db)]
+    (let [sql (sql/format sql-statement {:dialect :mysql})]
+      (jdbc/execute-one! connection sql
+                         {:builder-fn rs/as-unqualified-lower-maps}))))

src/cl/libs/api.clj

+(ns cl.libs.api
+  (:require
+    [ring.util.http-response :refer :all]
+    [clojure.main :refer [demunge]]
+    ))
+
+(defn internal-fn-name
+  [f]
+  (as-> (str f) $
+        (demunge $)
+        (or (re-find #"(.+)--\d+@" $)
+            (re-find #"(.+)@" $))
+        (last $))
+  )
+
+(defn answer [http-code-name-fn
+              internal-code
+              desc
+              body]
+  "HTTP api standard answer"
+  (let [status-fn (http-code-name-fn)]
+    (http-code-name-fn {
+                        :status        (:status status-fn)
+                        :status-name   (clojure.string/replace
+                                         (internal-fn-name http-code-name-fn)
+                                         #"ring.util.http-response/" "")
+                        :internal-code internal-code
+                        :desc          desc
+                        :body          body                 ;; result data
+                        })))
+
+(defn simple-answer [status
+                     internal-code
+                     desc
+                     body]
+  "HTTP api simpler standard answer"
+  {
+   :status        status
+   :headers       {}
+   :internal-code internal-code
+   :desc          desc
+   :body          body                                      ;; result data
+   })
\ No newline at end of file

src/cl/libs/main.clj

+(ns cl.libs.main)
+
+(defn string-to-bytes [s] (.getBytes s))

src/cl/log.clj

+(ns cl.log
+  (:require
+    [taoensso.timbre :as timbre]
+    [taoensso.timbre.appenders.3rd-party.rotor :as rotor]))
+
+; set up timbre aliases
+;(timbre/refer-timbre)
+
+;rotor log
+(timbre/merge-config! {:appenders {:spit    (rotor/rotor-appender {:path "./cl.log" :max-size (* 1024 1024), :backlog 5})}})
+
+(timbre/merge-config!
+  {:timestamp-opts
+   {:pattern "yyyy-MM-dd HH:mm:ss ZZ"
+    :locale (java.util.Locale. "ru_RU")
+    :timezone (java.util.TimeZone/getTimeZone "Europe/Moscow")}})
+
+; Set the lowest-level
+(timbre/set-level! :info)
+
+(defn info [message]
+  (timbre/info message))

src/cl/main.clj

+(ns cl.main
+  (:require
+    [cl.core :as core]
+    [cl.scheduler :as scheduler]
+    [mount.core :as mount :refer [start start-with-args]])
+  (:gen-class))
+
+;; for prod only, dev use his own (mount/start) in run-dev script
+
+(defn parse-args [args]
+  ;; parse args here to return what's needed
+  args)
+
+(defn -main [& args]
+  (-> args
+      parse-args
+      start-with-args))

src/cl/methods/get.clj

+(ns cl.methods.get
+  (:require
+    [schema.core :as s]
+    [cl.log :as log]
+    [cl.models.user :as user]
+    [cl.libs.api :as api]
+    [ring.util.http-response :as http :refer :all]))
+
+(defn get-test [request session]
+  ;(println session)
+
+  ;(let [count   (:cached-count session 0)
+  ;      session (assoc session :cached-count (inc count))]
+  ;  (->
+  ;    (if (user/is-authenticated? session)
+  ;      (api/answer http/ok "test-ok-auth" "The test is ok, auth" "Auth")
+  ;      (api/answer http/ok "test-ok-no-auth" "The test is ok, no auth" "NO Auth"))
+  ;    (assoc :session session)))
+
+  (-> (if (user/is-authenticated? session)
+        (api/answer http/ok "test-ok-auth" "The test is ok, auth" "Auth")
+        (api/answer http/ok "test-ok-no-auth" "The test is ok, no auth" "NO Auth"))
+      ;(assoc :session session)
+      )
+  )
+
+(defn get-session-count-test [session]
+  (let [count   (:count session 0)
+        session (assoc session :count (inc count))]
+    (->
+      (api/answer http/ok "count" "Counter" {:foo "Bar", :count (:count session)})
+      (assoc :session session))))
+
+(defn get-plus [x y]
+  (api/answer http/ok "plus" "Plus calculation" (+ x y)))
\ No newline at end of file

src/cl/methods/post.clj

+(ns cl.methods.post
+  (:require
+    [schema.core :as s]
+    [cl.log :as log]
+    [cl.models.user :as user]
+    [cl.libs.api :as api]
+    [ring.util.http-response :as http :refer :all]))
+
+(defn post-bot [challenge]
+  (api/answer http/ok "good" "Challenge answer" (str "Answer: " challenge)))

src/cl/models/user.clj

+(ns cl.models.user
+  (:require [cl.db :as db]
+            [schema.core :as s]
+            [honey.sql :as sql]
+            [ring.swagger.json-schema :refer [field]]))
+
+(s/defschema User
+  {:id (field s/Int {:example 1})})
+
+(defn- clear-user-private-data [user]
+  (-> user
+    (dissoc :password)))
+
+(defn is-authenticated? [request]
+  ;(println request)
+  (get-in request [:user :id] false))
+
+(defn get-user-info [id]
+  (-> (db/queryOne
+        {:select [:*]
+         :from   [:users]
+         :where  [:= :id id]})
+      (clear-user-private-data)))
+
+;(get-user-info 1)

src/cl/routes/http_routes.clj

+(ns cl.routes.http-routes
+  (:require
+    [compojure.api.sweet :refer :all]
+    [ring.swagger.swagger2 :refer :all]
+    [cl.methods.get :as api-get]
+    [cl.methods.post :as api-post]
+    [ring.util.http-response :as http :refer :all]
+    [schema.core :as s]
+    [ring.swagger.json-schema :refer [field]]))
+
+(defn api-result [result]
+  (assoc {:http-code      (field s/Int {:example 200})
+          :http-code-name (field s/Str {:example "ok"})
+          :internal-code  (field s/Str {:example "some-unique-code"})
+          :desc           (field s/Str {:example "Description"})}
+    :result result)
+  )
+
+(defroutes http-routes
+  ; Simple api test for correct auth
+  (GET "/api/test" request (api-get/get-test request (:session request)))
+  ;(GET "/api/test" {session :session} (api-get/get-test session))
+  ; Simple api session counter test
+  (GET "/api/session-count-test" {session :session} (api-get/get-session-count-test session))
+  ; swagger powered real api
+  (api
+    {
+     :swagger
+     {:ui   "/api-editor"
+      :spec "/swagger.json"
+      :data {:info {:title       "Hello"
+                    :description "Api self documentation"}}
+      :tags [{:name "api", :description "api"}]}}
+    (context "/api" []
+      :tags ["api"]
+
+      ;; GET
+      (GET "/plus" []
+        :return (api-result s/Int)
+        :query-params [x :- s/Int, y :- s/Int]
+        :summary "Adds two numbers together"
+        (api-get/get-plus x y))
+
+      ;; POST
+      (POST "/bot" [challenge]
+        :return (api-result String)
+        :query-params [challenge]
+        (api-post/post-bot challenge))))
+  )

src/cl/routes/ws_routes.clj

+(ns cl.routes.ws-routes
+  (:use [compojure.core :only (defroutes GET)]
+        ring.util.response
+        ring.middleware.cors
+        ring.middleware.cookies
+        [ring.util.codec :only (form-decode)]
+        org.httpkit.server
+        clojure.walk)
+  (:require
+    [cheshire.core :refer :all]
+    [clojure.string :as str]
+    [cl.log :as log]
+    [lock-key.core :refer [decrypt decrypt-as-str decrypt-from-base64
+                           encrypt encrypt-as-base64]]
+    [environ.core :refer [env]]))
+
+(defn get-uid-from-encrypted-string
+  "Get uid from encrypted string, tune it for your needs"
+  [uid-str]
+  (decrypt-from-base64
+              uid-str (env :crypt-lock)))
+
+(def connections
+  "All socket connections"
+  (atom {}))
+
+(defn reset-all-connections
+  "Reset connections"
+  []
+  (log/info "Reset connections")
+  (reset! connections {}))
+
+;actions
+(defmulti ws-action (fn [params conn]
+                      (keyword (:action params))))
+
+(defmethod ws-action :test [params conn]
+  (log/info "test action")
+  (send! conn (generate-string {:test true}) false))
+
+(defmethod ws-action :user-connected
+  [params conn]
+  "Just connected")
+
+(defmethod ws-action :reset-server
+  [params _]
+  "Restart socket server and reset connections"
+  (log/info "reset-connections-by-command")
+  (reset-all-connections))
+;(sys/restart-http-server)
+
+(defn not-authorized [conn]
+  (log/info "Auth error")
+  (send! conn
+         (generate-string
+           {:connected false
+            :message   "not authorized"}) false))
+
+(defn ws-handler
+  [req]
+  (with-channel
+    req conn
+    (if (:query-string req)
+      (let [query-map  (keywordize-keys (form-decode (:query-string req)))
+            server-key (:server-key query-map)]
+
+        (if (= server-key (env :socket-admin-pass))
+          (do
+            (swap! connections assoc conn