run parameter life cycle tests and run id should be passed at creatio…

…n time

ssclj/jar/src/com/sixsq/slipstream/ssclj/resources/run.clj

@@ -57,9 +57,7 @@
 
 (defmethod crud/new-identifier resource-name
   [json _]
-  #_json                                                    ;TODO uncomment because the run-id should be consistent with SlipStream java server
-  (assoc json :id (str resource-url "/" (u/random-uuid)))   ;TODO REMOVE this line
-  )
+  json)
 
 (defn create-parameter [identity run-parameter]
   (try
@@ -89,7 +87,7 @@
 (defn add-impl [{body :body :as request}]
   (a/can-modify? {:acl collection-acl} request)
   (let [new-run (-> body
-                    u/strip-service-attrs
+                    (dissoc :created :updated :resourceURI :operations)
                     (crud/new-identifier resource-name)
                     (assoc :resourceURI resource-uri)
                     u/update-timestamps

ssclj/jar/src/com/sixsq/slipstream/ssclj/resources/run_parameter.clj

@@ -11,6 +11,7 @@
     [com.sixsq.slipstream.util.response :as r]
     [com.sixsq.slipstream.db.impl :as db]
     [clojure.tools.logging :as log]
+    [com.sixsq.slipstream.ssclj.util.log :as logu]
     [com.sixsq.slipstream.ssclj.util.sse :as sse]
     [clojure.core.async :as async]
     [zookeeper :as zk]
@@ -73,20 +74,28 @@
         node-path (zkru/parameter-znode-path run-id node-name node-index name)]
     (uzk/create-all node-path :persistent? true)
     (uzk/set-data node-path value)
-    response
-    ))
+    response))
 
 (defmethod crud/add resource-name
   [request]
   (add-impl request))
 
-(defn watch-fn [event-ch id name {:keys [event-type path :as zk-event]}]
+(defn transiant-watch-fn [event-ch id name {:keys [event-type path :as zk-event]}]
   (when (= event-type :NodeDataChanged)
-    (let [event {:id   id
-                 :name name
-                 :data (uzk/get-data path :watcher (partial watch-fn event-ch id name))}]
-      (async/>!! event-ch event))))
+    (let [data (uzk/get-data path)]
+      (sse/send-event id name data event-ch)
+      (async/close! event-ch))))
 
+(defn persistent-watch-fn [event-ch id name {:keys [event-type path :as zk-event]}]
+  (when (= event-type :NodeDataChanged)
+    (let [data (uzk/get-data path :watcher (partial persistent-watch-fn event-ch id name))]
+      (sse/send-event id name data event-ch))))
+
+(defn send-event-and-set-watcher
+  [event-ch watch-fn {id :id name :name :as run-parameter}]
+  (let [node-path (zkru/run-parameter-znode-path run-parameter)
+        value (uzk/get-data node-path :watcher (partial watch-fn event-ch id name))]
+    (sse/send-event id name value event-ch)))
 
 (defn retrieve-run-parameter [{{uuid :uuid} :params :as request}]
   (try
@@ -99,22 +108,13 @@
     (catch ExceptionInfo ei
       (ex-data ei))))
 
-(defn send-param-value-and-set-watcher [event-ch {id :id name :name :as run-parameter}]
-  (try ; if znode not found do nothing for the moment
-    (let [node-path (zkru/run-parameter-znode-path run-parameter)
-          event {:id   id
-                 :name name
-                 :data (uzk/get-data node-path :watcher (partial watch-fn event-ch id name))}]
-      (async/>!! event-ch event))
-    (catch Exception e
-      (log/warn (ex-data e))
-      )))
-
 (def retrieve-sse-impl
   (sse/event-channel-handler
     (fn [request response raise event-ch]
-      (let [{id :id name :name :as run-parameter} (retrieve-run-parameter request)]
-        (send-param-value-and-set-watcher event-ch run-parameter)))
+      (let [{id :id name :name :as run-parameter} (retrieve-run-parameter request)
+            node-path (zkru/run-parameter-znode-path run-parameter)
+            value (uzk/get-data node-path)]
+        (send-event-and-set-watcher event-ch transiant-watch-fn run-parameter)))
     {:on-client-disconnect #(log/debug "sse/on-client-disconnect: " %)}))
 
 (defn retrieve-json-impl [request]
@@ -128,22 +128,21 @@
 
 (defn edit-impl
   [{{uuid :uuid} :params body :body :as request}]
-  (try
-    (let [current (-> (str (u/de-camelcase resource-name) "/" uuid)
-                      (db/retrieve request)
-                      (a/can-modify? request))
-          merged (merge current body)
-          value (:value merged)]
-      (-> merged
-          (u/update-timestamps)
-          (crud/validate)
-          (dissoc :value)
-          (db/edit request))
-      (when value
-        (uzk/set-data (zkru/run-parameter-znode-path merged) value)) ;TODO what if znode not found
-      )
-    (catch ExceptionInfo ei
-      (ex-data ei))))
+  (let [current (-> (str (u/de-camelcase resource-name) "/" uuid)
+                    (db/retrieve request)
+                    (a/can-modify? request))
+        merged (merge current body)
+        value (:value merged)]
+    (-> merged
+        (u/update-timestamps)
+        (crud/validate)
+        (dissoc :value)
+        (db/edit request))
+    (when value
+      (let [name (:name merged)]
+        (if (contains? #{"state" "vmstate"} name)
+          (logu/log-and-throw-400 (str "run parameter " name " cannot be set"))
+          (uzk/set-data (zkru/run-parameter-znode-path merged) value)))))) ;TODO what if znode not found
 
 (defmethod crud/edit resource-name
   [request]
@@ -161,7 +160,7 @@
       (a/can-view? {:acl collection-acl} request)
       (let [options (select-keys request [:identity :query-params :cimi-params :user-name :user-roles])
             [count-before-pagination entries] (db/query resource-name options)]
-        (doall (map (partial send-param-value-and-set-watcher event-ch) entries))))
+        (doall (map (partial send-event-and-set-watcher event-ch persistent-watch-fn) entries))))
     {:on-client-disconnect #(log/debug "sse/on-client-disconnect: " %)}))
 
 (def query-json-impl (std-crud/query-fn resource-name collection-acl collection-uri resource-tag))

ssclj/jar/src/com/sixsq/slipstream/ssclj/resources/spec/run.cljc

@@ -56,7 +56,7 @@
 
 (s/def :cimi.run/nodes (su/constrained-map keyword? :cimi.run/node))
 
-(def run-attrs {:req-un [#_:cimi.common/id                  ;TODO uncomment
+(def run-attrs {:req-un [:cimi.common/id
                          :cimi.run/module-resource-uri
                          :cimi.run/type
                          :cimi.run/category

ssclj/jar/src/com/sixsq/slipstream/ssclj/resources/zk/run/state_machine.clj

@@ -21,6 +21,7 @@
 
 ;; State machine states
 (def initial-state "init")
+
 (def valid-transitions
   {initial-state ["provisioning"]
    "provisioning" ["executing"]

ssclj/jar/src/com/sixsq/slipstream/ssclj/util/sse.clj

@@ -5,8 +5,7 @@
             [ring.core.protocols :as ring]
             [ring.util.response :as ring-response]
             [manifold.stream :as s]
-            [manifold.deferred :as d])
-  )
+            [manifold.deferred :as d]))
 
 (def CRLF "\r\n")
 (def EVENT_FIELD "event: ")
@@ -36,7 +35,13 @@
      (.append sb CRLF)
      (str sb))))
 
-(defn send-event
+(defn send-event [id name data event-ch]
+  (let [event {:id   id
+               :name name
+               :data data}]
+    (async/>!! event-ch event)))
+
+(defn- send-event-on-response-ch
   [channel name data id put-fn raise]
   (try
     (put-fn channel (mk-data name data id))
@@ -66,7 +71,7 @@
                 (if (map? event)
                   (reduce (fn [agg [k v]] (assoc agg k (str v))) {} event)
                   {:data (str event)})]
-            (when (send-event response-channel event-name event-data event-id async/put! raise)
+            (when (send-event-on-response-ch response-channel event-name event-data event-id async/put! raise)
               (recur))))))
     (async/close! event-channel)
     (async/close! response-channel)

ssclj/jar/test/com/sixsq/slipstream/ssclj/resources/run_lifecycle_test.clj

@@ -24,7 +24,7 @@
   (t/make-ring-app (t/concat-routes routes/final-routes)))
 
 (def valid-entry
-  {:id                  (str resource-url "run/dfd34916-6ede-47f7-aaeb-a30ddecbba5b")
+  {:id                  (str resource-url "/dfd34916-6ede-47f7-aaeb-a30ddecbba5b")
    :resourceURI         resource-uri
    :module-resource-uri "module/examples/tutorials/service-testing/system/1940"
    :category            "Deployment"
@@ -69,7 +69,6 @@
                           (t/body->edn)
                           (t/is-status 200))]
 
-
       (is (not (uzk/exists (str ru/znode-separator run-id))))
 
       (let [start-uri (str p/service-context (t/get-op created-run "http://schemas.dmtf.org/cimi/2/action/start"))

ssclj/jar/test/com/sixsq/slipstream/ssclj/resources/run_parameter_lifecycle_test.clj

@@ -0,0 +1,81 @@
+(ns com.sixsq.slipstream.ssclj.resources.run-parameter-lifecycle-test
+  (:require
+    [clojure.test :refer :all]
+    [clojure.data.json :as json]
+    [peridot.core :refer :all]
+    [ring.util.codec :as rc]
+    [com.sixsq.slipstream.ssclj.resources.run-parameter :refer :all]
+    [com.sixsq.slipstream.ssclj.resources.lifecycle-test-utils :as t]
+    [com.sixsq.slipstream.ssclj.middleware.authn-info-header :refer [authn-info-header]]
+    [com.sixsq.slipstream.ssclj.app.routes :as routes]
+    [com.sixsq.slipstream.ssclj.app.params :as p]
+    [com.sixsq.slipstream.ssclj.resources.common.utils :as u]
+    [com.sixsq.slipstream.ssclj.util.zookeeper :as uzk]
+    [com.sixsq.slipstream.ssclj.resources.zk.run.utils :as ru]
+    [com.sixsq.slipstream.ssclj.resources.zk.run.utils :as zkru]))
+
+(use-fixtures :each t/with-test-client-fixture)
+
+(use-fixtures :once t/setup-embedded-zk)
+
+(def base-uri (str p/service-context resource-url))
+
+(defn ring-app []
+  (t/make-ring-app (t/concat-routes routes/final-routes)))
+
+(def session-user (-> (session (ring-app))
+                      (content-type "application/json")
+                      (header authn-info-header "jane USER ANON")))
+
+(deftest create-run-parameter-xyz
+  (let [run-id "run/abc34916-6ede-47f7-aaeb-a30ddecbba5b"
+        valid-entry {:run-id run-id :node-name "machine" :node-index 1 :name "xyz" :value "XYZ"}
+        znode-path (zkru/run-parameter-znode-path valid-entry)
+        run-parameter-id (-> session-user
+                             (request base-uri
+                                      :request-method :post
+                                      :body (json/write-str valid-entry))
+                             (t/body->edn)
+                             (t/is-status 201)
+                             (t/location))
+        abs-uri (str p/service-context (u/de-camelcase run-parameter-id))
+        created-run-parameter (-> session-user
+                                  (request abs-uri)
+                                  (t/body->edn)
+                                  (t/is-status 200))]
+
+    (is (= "XYZ" (uzk/get-data znode-path)))
+
+    (-> session-user
+        (request abs-uri :request-method :put
+                 :body (json/write-str {:value "newvalue"}))
+        (t/body->edn)
+        (t/is-status 200))
+
+    (is (= "newvalue" (uzk/get-data znode-path)) "run parameter can be updated")))
+
+(deftest create-run-parameter-state
+  (let [run-id "run/def34916-6ede-47f7-aaeb-a30ddecbba5b"
+        valid-entry {:run-id run-id :name "state" :value "init"}
+        run-parameter-id (-> session-user
+                             (request base-uri
+                                      :request-method :post
+                                      :body (json/write-str valid-entry))
+                             (t/body->edn)
+                             (t/is-status 201)
+                             (t/location))
+        abs-uri (str p/service-context (u/de-camelcase run-parameter-id))
+        created-run-parameter (-> session-user
+                                  (request abs-uri)
+                                  (t/body->edn)
+                                  (t/is-status 200))]
+
+    (is (= "init" (uzk/get-data (str ru/znode-separator run-id "/state"))) "znode state is created")
+
+    (-> session-user
+        (request abs-uri :request-method :put
+                 :body (json/write-str {:value "newvalue"}))
+        (t/body->edn)
+        (t/is-status 400))
+
+    (is (= "init" (uzk/get-data (str ru/znode-separator run-id "/state"))) "run parameter state can't be updated")))