A programmer's site

# edit file: /etc/ssh/sshd_config
ChallengeResponseAuthentication no
PasswordAuthentication no
UsePAM no
PermitRootLogin no

ssh -p 2323 -C 

Host example
    HostName example.com
    User someone
    Port 2323
    Compression yes

ControlMaster auto
ControlPath /tmp/ssh_mux_%h_%p_%r
ControlPersist 10h

ssh -p 2323 -C -X -Y 

ssh -L localhost:3306:localhost:3306 -Nf 

ssh -R :3389:localhost:3389 -Nf 

ssh -D :3128 

ssh  uname

(defn handler [req]
  ;; return a map of keys [:status :body :headers]
  )

;;; get the params
(let [{:keys [id tag]} (:params req)
      limit (min 30 (to-int (or (:limit (:params req)) 15)))
      offset (to-int (or (:offset (:params req)) 0))]
  ;; do work with these params
  )

(defmacro defhandler [handler bindings & body]
  (let [req (bindings 0)
        bindings (rest bindings)
        ks (map (fn [s] (keyword (name s))) bindings)
        vals (map (fn [k]
                    ;; limit and offset are special, set the default value, guard large
                    ;; limit, convert them to int
                    (cond (= :limit k) `(min 30 (to-int (or (~k (:params ~req)) 15)))
                          (= :offset k) `(to-int (or (~k (:params ~req)) 0))
                          ;; more pattens here, something like
                          ;; (= :uid k) code to get user id
                          :else `(~k (:params ~req)))) ks)]
    `(defn ~handler [~req]
       (let [~@(interleave bindings vals)]
         ~@body))))

(defhandler list-feeds [req id limit offset]
  {:status 200
   :body (str "the subscription id: " id
              "limit:" limit
              "offset:" offset)})

(defn list-feeds [req]
  (let [id (:id (:params req))
        limit (min 30 (to-int (or (:limit (:params req)) 15)))
        offset (to-int (or (:offset (:params req)) 0))]
    {:status 200
     :body (str "the subscription id: " id
                "limit:" limit
                "offset:" offset)}))

(defn to-int [s] (cond
                  (string? s) (Integer/parseInt s)
                  (instance? Integer s) s
                  (instance? Long s) (.intValue ^Long s)
                  :else 0))

(global-set-key (kbd "M-i") 'feng-highlight-at-point)

(require 'thingatpt)

(defface feng-highlight-at-point-face
  `((((class color) (background light))
     (:background "light green"))
    (((class color) (background dark))
     (:background "royal blue")))
  "Face for highlighting variables"
  :group 'feng-highlight)

(defvar current-highlighted nil)
(make-variable-buffer-local 'current-highlighted)

(defun feng-at-point-prev ()
  (interactive)
  (when current-highlighted
    (unless (re-search-backward
             (concat "\\<" (regexp-quote current-highlighted) "\\>") nil t)
      (message "search hit TOP, continue from BOTTOM")
      (goto-char (point-max))
      (feng-at-point-prev))))

(defun feng-at-point-next ()
  (interactive)
  (when current-highlighted
    (forward-char (+ 1 (length current-highlighted))) ; more out of current
    (if (re-search-forward
         (concat "\\<" (regexp-quote current-highlighted) "\\>") nil t)
        (backward-char (length current-highlighted))
      (backward-char (+ 1 (length current-highlighted)))
      (message "search hit BOTTOM, continue from TOP")
      (goto-char (point-min))
      (feng-at-point-next))))

(defun feng-at-point-replace ()
  (interactive)
  (when current-highlighted
    (save-excursion
      (goto-char (point-min))           ;; back to top
      (feng-at-point-next)              ;; find first
      (setq isearch-string current-highlighted)
      (isearch-query-replace))))

(defvar feng-highlight-at-point-keymap
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "M-n") 'feng-at-point-next)
    (define-key map (kbd "M-r") 'feng-at-point-replace)
    (define-key map (kbd "M-p") 'feng-at-point-prev)
    map))

(defun feng-highlight-at-point ()
  (interactive)
  (remove-overlays (point-min) (point-max) 'feng-highlight t)
  (let* ((target-symbol (symbol-at-point))
         (target (symbol-name target-symbol)))
    (when target-symbol
      (setq current-highlighted target)
      (save-excursion
        (goto-char (point-min))
        (let* ((regexp (concat "\\<" (regexp-quote target) "\\>"))
               (len (length target))
               (end (re-search-forward regexp nil t)))
          (while end
            (let ((ovl (make-overlay (- end len) end)))
              (overlay-put ovl 'keymap feng-highlight-at-point-keymap)
              (overlay-put ovl 'face 'feng-highlight-at-point-face)
              (overlay-put ovl 'feng-highlight t))
            (setq end (re-search-forward regexp nil t))))))))

(provide 'feng-highlight)