Use Cheshire for json operations.

project.clj

@@ -4,16 +4,16 @@
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.5.1"]
-                 [org.clojure/data.json "0.2.3"]
+                 [cheshire "5.2.0"]
                  [clj-http "0.7.7"]
                  [com.taoensso/timbre "3.0.0-RC2"]]
   :repositories [["releases" {:url "https://clojars.org/repo"
                               :creds :gpg}]]
   :repl-options {
-    :init-ns openstack.api}
+                 :init-ns openstack.api}
   :profiles {
-    :dev {
-      :dependencies [[org.clojure/tools.namespace "0.2.3"]
-                     [org.clojure/java.classpath "0.2.0"]]}
-    :testing {
-      :dependencies [[leiningen "2.3.3"]]}})
+             :dev {
+                   :dependencies [[org.clojure/tools.namespace "0.2.3"]
+                                  [org.clojure/java.classpath "0.2.0"]]}
+             :testing {
+                       :dependencies [[leiningen "2.3.3"]]}})

src/openstack/compute.clj

@@ -1,27 +1,28 @@
 (ns openstack.compute
-  (:require [clojure.data.json :as json]
+  (:require [cheshire.core :refer :all :as json]
             [clj-http.client :as http]
             [openstack.const :as const]
             [openstack.identity :as identity]
             [openstack.services :as services]))
 
 (defn get-new-server-payload [server-name image-id flavor-id]
-  {:body (json/write-str {:server
-                          {:name server-name
-                           :imageRef image-id
-                           :flavorRef flavor-id}})
+  {:body (json/encode {:server
+                       {:name server-name
+                        :imageRef image-id
+                        :flavorRef flavor-id}})
+   :headers {"Content-Type" "application/json"}
    :content-type :json})
 
 (defn create-server [identity-response region server-name image-id flavor-id]
   (let [base-url (services/get-cloud-servers-region-url identity-response region)]
     (http/post
-      (str base-url const/server-path)
-      {:content-type :json
-       :headers {const/x-auth-token (identity/get-token identity-response)}})))
+     (str base-url const/server-path)
+     {:content-type :json
+      :headers {const/x-auth-token (identity/get-token identity-response)}})))
 
 (defn get-server-list [identity-response region]
   (let [base-url (services/get-cloud-servers-region-url identity-response region)]
     (http/get
-      (str base-url const/server-detail-path)
-      {:accept :json
-       :headers {const/x-auth-token (identity/get-token identity-response)}})))
+     (str base-url const/server-detail-path)
+     {:accept :json
+      :headers {const/x-auth-token (identity/get-token identity-response)}})))

src/openstack/identity.clj

@@ -1,5 +1,5 @@
 (ns openstack.identity
-  (:require [clojure.data.json :as json]
+  (:require [cheshire.core :refer :all :as json]
             [clojure.string :as string]
             [clj-http.client :as http]
             [openstack.const :as const]
@@ -8,7 +8,7 @@
 
 
 (defn password-auth-payload [username password]
-  {:body (json/write-str {:auth
+  {:body (json/encode {:auth
                           {:passwordCredentials
                            {:username username
                             :password password}}})

src/openstack/servers.clj

@@ -1,24 +1,24 @@
 (ns openstack.servers
   (:require [clj-http.client :as http]
-            [clojure.data.json :as json]
+            [cheshire.core :refer :all :as json]
             [openstack.const :as const]))
 
-; XXX NOTE!!!
-; This file is basically useless right now.
-; It is a vestiage of the original code from which this project was cloned.
-; This file will slowly have its parts updated, but for now, consider it
-; completely broken!
+;; XXX NOTE!!!
+;; This file is basically useless right now.
+;; It is a vestiage of the original code from which this project was cloned.
+;; This file will slowly have its parts updated, but for now, consider it
+;; completely broken!
 
 (defstruct rs-response :value)
 
 (defstruct rs-session :url :token)
 
 (defn- basic-get [session arg]
   (try
-   (let [response (http/get (str (session :url) arg)
-         {const/x-auth-token (session :token)})]
-     (with-meta (json/read-str (first (response :body-seq))) response))
-   (catch Exception e (println e))))
+    (let [response (http/get (str (session :url) arg)
+                             {const/x-auth-token (session :token)})]
+      (with-meta (json/decode (first (response :body-seq))) response))
+    (catch Exception e (println e))))
 
 (defn list-servers
   "Returns running servers. Pass id as an argument to view specific
@@ -50,35 +50,35 @@
                    :flavorId flavor-id}
         server {:server (if (not= nil metadata)
                           (-> json-vals (assoc :metadata metadata))
-                json-vals)}
-        json-data (json/write-str server)
+                          json-vals)}
+        json-data (json/encode server)
         response (http/post (str (session :url) "/servers")
-                  {const/x-auth-token (session :token)
-          "Content-type" "application/json"}
-         json-data)]
-    (with-meta ((json/read-str (first (response :body-seq))) "server") response)))
+                            {const/x-auth-token (session :token)
+                             "Content-type" "application/json"}
+                            json-data)]
+    (with-meta ((json/decode (first (response :body-seq))) "server") response)))
 
 (defn rename-server
   "Rename server."
   [session server-id name]
   (let [json-vals {:server {:name name}}
-  json-data (json/write-str json-vals)
-  response (http/put (str (session :url) "/servers/" server-id)
-        {const/x-auth-token (session :token)
-         "Content-type" "application/json"}
-        json-data)]
+        json-data (json/encode json-vals)
+        response (http/put (str (session :url) "/servers/" server-id)
+                           {const/x-auth-token (session :token)
+                            "Content-type" "application/json"}
+                           json-data)]
     (with-meta (struct rs-response (if (= (response :msg) "No Content")
-             true
-             false)) response)))
+                                     true
+                                     false)) response)))
 
 (defn delete-server
   "Delete server."
   [session id]
   (let [response (http/delete (str (session :url) "/servers/" id)
-           {const/x-auth-token (session :token)})]
+                              {const/x-auth-token (session :token)})]
     (with-meta (struct rs-response (if (= (response :msg) "Accepted")
-             true
-             false)) response)))
+                                     true
+                                     false)) response)))
 
 (defn list-addresses
   "List IPs associated with server id. meta data includes the original
@@ -87,33 +87,33 @@
    visibility: Either :public, :private or empty for both"
   [session id & [visibility]]
   (let [v (cond (= visibility :public) "/public"
-    (= visibility :private) "/private"
-    :else nil)
-  response (http/get (str (session :url) "/servers/" id "/ips" v)
-        {const/x-auth-token (session :token)})]
-    (with-meta (json/read-str (first (response :body-seq))) response)))
+                (= visibility :private) "/private"
+                :else nil)
+        response (http/get (str (session :url) "/servers/" id "/ips" v)
+                           {const/x-auth-token (session :token)})]
+    (with-meta (json/decode (first (response :body-seq))) response)))
 
 
 (defn- action [session url-args action type action-args]
   (let [response (http/post (str (session :url) url-args)
-         {const/x-auth-token (session :token)
-          "Content-type" "application/json"}
-         (json/write-str {action {type action-args}}))]
+                            {const/x-auth-token (session :token)
+                             "Content-type" "application/json"}
+                            (json/encode {action {type action-args}}))]
     (with-meta (struct rs-response (if (= (response :msg) "Accepted")
-             true
-             false)) response)))
+                                     true
+                                     false)) response)))
 
 (defn reboot-server
   "Reboot server. Type can be either :hard or :soft."
   [session id type]
   (let [t (cond (= type :hard) "HARD"
-    (= type :soft) "SOFT"
-    :else
-    (throw (new Exception "Type argument is not an available type.")))]
+                (= type :soft) "SOFT"
+                :else
+                (throw (new Exception "Type argument is not an available type.")))]
     (action session (str "/servers/" id "/action") :reboot :type t)))
 
 (defn rebuild-server
   "Rebuilds server."
   [session id image-id]
   (action session (str "/servers/" id "/action")
-    :rebuild :imageId image-id))
+          :rebuild :imageId image-id))

src/openstack/services.clj

@@ -1,5 +1,5 @@
 (ns openstack.services
-  (:require [clojure.data.json :as json]
+  (:require [cheshire.core :refer :all :as json]
             [clojure.string :as string]
             [clj-http.client :as http]
             [openstack.const :as const]
@@ -9,12 +9,12 @@
 
 (defn get-service-catalog [identity-response]
   (((util/parse-json-body identity-response) :access) :serviceCatalog))
-  
+
 (defn get-service [identity-response service-type]
   (first
-    (filter
-      (fn [x] (if (= (x :name) service-type) x))
-      (get-service-catalog identity-response))))
+   (filter
+    (fn [x] (if (= (x :name) service-type) x))
+    (get-service-catalog identity-response))))
 
 (defn get-cloud-servers-v1 [identity-response]
   (get-service identity-response (const/services :servers-v1)))
@@ -35,16 +35,16 @@
   "This is only valid for cloud servers v2."
   [identity-response]
   (map
-    (fn [x] (keyword (string/lower-case (x :region))))
-    (get-cloud-servers-endpoints identity-response :version 2)))
+   (fn [x] (keyword (string/lower-case (x :region))))
+   (get-cloud-servers-endpoints identity-response :version 2)))
 
 (defn get-cloud-servers-region
   "This is only valid for cloud servers v2."
   [identity-response region]
   (first
-    (filter
-      (fn [x] (if (= (x :region) (const/regions region)) x))
-      (get-cloud-servers-endpoints identity-response :version 2))))
+   (filter
+    (fn [x] (if (= (x :region) (const/regions region)) x))
+    (get-cloud-servers-endpoints identity-response :version 2))))
 
 (defn get-cloud-servers-region-url [identity-response region]
   (:publicURL (get-cloud-servers-region identity-response region) ))

src/openstack/util.clj

@@ -1,9 +1,9 @@
 (ns openstack.util
-  (:require [clojure.data.json :as json]))
+  (:require [cheshire.core :refer :all :as json]))
 
 
 (defn parse-json-body [response]
-  (json/read-str (response :body) :key-fn keyword))
+  (json/decode (response :body) true))
 
 (defn create-temp-file
   ([] (create-temp-file "clj-rax-" ".tmp"))