A programmer's site

(defn handler [request-req] ;; accept a reuqest-map, return a response-map
  response-map)

;; request-map
{:uri "/index"
 :query-string "a=b"
 :request-method :get
 :headers {"user-agent" "... Chrome/23.0.1271.40 Safari/537.11"
           "cookie" "...."
           "accept-charset" "UTF-8,*;q=0.5"}
 ...}

;; response-map
{:status 200
 :headers {"Content-Type" "text/plain"}
 :body "Hello world from ring"
 :session ...}

;; adapter
(run-server handler {..options..}}

[http-kit "2.0-rc1"] ;; add to project.clj

(defn handler [req-map]
  (async-response respond
    (future (respond {:status 200
                      :headers {"Content-Type" "text/plain"}
                      :body "async hello world"}))))
(run-server handler {:port 8000}}

(def clients (atom {}))

(async-response respond
  ;; save it
  (swap! clients assoc respond (now-seconds)))

(on-fancy-event (fn [e]
                  (doseq [client (keys @clients)]
                    (client {:status 200
                             :body (str "Fancy event!" e)})
                    (swap! clients dissoc client))))

# http-kit runs happily with 128M heap (-Xms128m -Xmx128m), ab confirms that
ab -n 500000 -c 10000 -k http://127.0.0.1:8080/

cd {code-directory} && http-watcher -port=8000
# 详细帮助 http-watcher -h
# 打开浏览器，访问http://127.0.0.1:8000。同事们也可通过你的IP，实时查看

http-watcher -port=8000 －root={代码目录} -proxy={动态程序端口}
# 详细帮助 http-watcher -h
# 打开浏览器，访问http://127.0.0.1:8000。同事们也可通过你的IP，实时查看

[http-kit "2.0-rc1"]
(:require [org.httpkit.client :as http])

; http/post, http/head, http/put, http/delete
; issue http request asynchronous. return a promise, deref to get the response
(http/get url & [options callback])

;; suppoted options
{:timeout 300 ;; read or connect timeout
 :headers {"x-header" "value"}
 :query-params {:ts (System/currentTimeMillis)}
 :user-agent "user-agent-str"
 :basic-auth ["user" "pass"]
 :form-params {:name "http-kit"
               :lang "Clojure"
               :keyword ["async" "concurrent" "fast"]}}

;; get synchronously
(let [{:keys [error status headers body]} @(http/get "http://example.com")]
  ;; handle result or error
  )

;; get concurrently, deal one by one
(let [r1 (http/get "http://example.com?page=1")
      r2 (http/get "http://example.com" {:query-params {:page 2}})]
  ;; other keys: :headers, :request, :error
  (println "First page, status: " (:status @r1) "html: " (:body @r1))
  (println "Second page, status: " (:status @r2) "html: " (:body @r2)))

;; get the real urls concurrently
(let [resps (map http/head twitter-shorttened-urls)]
  (doseq [resp resps]
    (let [{:keys [request headers error]} @resp]
      (if-not error ;; Exception: timeout, network error, etc
        (println (:url request) "=>" (:location headers))
        ;; schedule retry?
        ))))

(let [options {:timeout 300ms
               :headers {"x-header" "value"}
               :query-params {:ts (System/currentTimeMillis)}
               :user-agent "user-agent-str"
               :basic-auth ["user" "pass"]
               :form-params {:name "http-kit"
                             :lang "Clojure"
                             :keyword ["async" "concurrent" "fast"]}}]
  (http/post "http://example.com" options
            ;asynchronous with callback
             (fn [{:keys [status error body headers]}]
               ;; handle result or error
               ;; the callback's return value is delivered to the promise
               )))

nohup java -jar rssminer-standalone.jar # listens on port 8100, reverse proxy by Nginx

lsof -t -sTCP:LISTEN  -i:8100 | xargs kill  # kills old instance

(loop [i 1]
  (let [pid (str/trim (:out (sh "lsof"
                                "-t" "-sTCP:LISTEN"
                                (str "-i:" (cfg :port)))))]
    (when-not (str/blank? pid)
      ;; old program is runing, kill it
      (info "kill pid" pid i "times, status" (:exit (sh "kill" pid)))))
  (let [r (try
            ;; bind socket, start web server
            (reset! server (run-server (app) {:port (cfg :port)
                                              :ip (cfg :bind-ip)
                                              :worker-name-prefix "w"
                                              :thread (cfg :worker)}))
            1 ;; return 1 means success
            (catch java.net.BindException e
              (if (> i 30)    ; wait about 4.5s
                (do
                  (info "giving up" e)
                  (throw e))
                (Thread/sleep 150))))]
    (when-not r
      (recur (inc i)))))

for in in {1..100}; do java -jar rssminer-standalone.jar; done

package btree
import (
        "bytes"
        "fmt"
)
type Key int
type Node struct {
        Leaf     bool
        N        int
        Keys     []Key
        Children []*Node
}
func (x *Node) Search(k Key) (n *Node, idx int) {
        i := 0
        for i < x.N && x.Keys[i] < k {
                i += 1
        }
        if i < x.N && k == x.Keys[i] {
                n, idx = x, i
        } else if x.Leaf == false {
                n, idx = x.Children[i].Search(k)
        }
        return
}
func newNode(n, branch int, leaf bool) *Node {
        return &Node{
                Leaf:     leaf,
                N:        n,
                Keys:     make([]Key, branch*2-1),
                Children: make([]*Node, branch*2),
        }
}
func (parent *Node) Split(branch, idx int) { //  idx is Children's index
        full := parent.Children[idx]
        // make a new node, copy full's right most to it
        n := newNode(branch-1, branch, full.Leaf)
        for i := 0; i < branch-1; i++ {
                n.Keys[i] = full.Keys[i+branch]
                n.Children[i] = full.Children[i+branch]
        }
        n.Children[branch-1] = full.Children[2*branch-1] // copy last child
        full.N = branch - 1 // is half full now, copied to n(new one)
        // shift parent, add new key and children
        for i := parent.N; i > idx; i-- {
                parent.Children[i] = parent.Children[i-1]
                parent.Keys[i+1] = parent.Keys[i]
        }
        parent.Keys[idx] = full.Keys[branch-1]
        parent.Children[idx+1] = n
        parent.N += 1
}
func (tree *Btree) Insert(k Key) {
        root := tree.Root
        if root.N == 2*tree.branch-1 {
                s := newNode(0, tree.branch, false)
                tree.Root = s
                s.Children[0] = root
                s.Split(tree.branch, 0)
                s.InsertNonFull(tree.branch, k)
        } else {
                root.InsertNonFull(tree.branch, k)
        }
}
func (x *Node) InsertNonFull(branch int, k Key) {
        i := x.N
        if x.Leaf {
                for i > 0 && k < x.Keys[i-1] {
                        x.Keys[i] = x.Keys[i-1]
                        i -= 1
                }
                x.Keys[i] = k
                x.N += 1
        } else {
                for i > 0 && k < x.Keys[i-1] {
                        i -= 1
                }
                c := x.Children[i]
                if c.N == 2*branch-1 {
                        x.Split(branch, i)
                        if k > x.Keys[i] {
                                i += 1
                        }
                }
                x.Children[i].InsertNonFull(branch, k)
        }
}
func space(n int) string {
        s := ""
        for i := 0; i < n; i++ {
                s += " "
        }
        return s
}
func (x *Node) String() string {
        return fmt.Sprintf("{n=%d, Leaf=%v, Keys=%v, Children=%v}\n",
                x.N, x.Leaf, x.Keys, x.Children)
}
func (tree *Btree) String() string {
        return tree.Root.String()
}
type Btree struct {
        Root   *Node
        branch int
}
func New(branch int) *Btree {
        return &Btree{Root: newNode(0, branch, true), branch: branch}
}
func (tree *Btree) Search(k Key) (n *Node, idx int) {
        return tree.Root.Search(k)
}