endpoints_session_user.clj

(ns overseer.component.endpoints-session-user
  (:require [clojure.tools.logging :refer [info error]]
            [clojure.core.async :as async]
            [com.stuartsierra.component :as component]
            [de.mpg.shh.util-message-server.helpers :as message-helpers]
            [de.mpg.shh.util-overseer.server :as overseer-server]
            [overseer.utils :as utils]))

(defrecord EndpointsSessionUser [response-context response-address request-channel overseer session-id hostname]
  component/Lifecycle
  (start [this]
         (let [reply (fn [request-channel target message]
                       (message-helpers/synch-send request-channel
                                                   (:host response-context)
                                                   (:port response-context)
                                                   (:username response-context)
                                                   (:password response-context)
                                                   response-address
                                                   message
                                                   :properties (merge {"origin" "overseer"}
                                                                      (when-not (nil? target)
                                                                        {"target" target}))

                                                   :timeout 1
                                                   :send-meta true))
               receive (fn [conn-overseer destination data]
                         (try
                           (overseer-server/receive conn-overseer (assoc data :destination destination))
                           (catch Throwable t
                             (error "failed to receive '" (pr-str destination) "' message " (pr-str data) " " (utils/stack-trace-to-string t)))))
               conn-overseer (:conn overseer)]
         {
  :error
  (fn [request-channel message]
    (error "error session endpoint received: " message))
  :ping
  (fn [request-channel message]
    ;;(info "got ping: " message)
    (reply request-channel (:client-id message) [:pong {}]))
  ;; Overseer client api calls, e.g. registering a runtime or accepting a task
  :status
  (fn [request-channel message]
    (let [;;_ (info "got status: " (pr-str message))
          result (try
                   {:data (overseer-server/status conn-overseer)}
                   (catch Throwable t
                     {:error (utils/stack-trace-to-string t)}))]
      (reply request-channel
                     (:client-id message)
                     [:message (merge result (select-keys message [:session-request-id]))])))
  :register-resource
  (fn [request-channel {data :data :as message}]
    (let [_ (info "got register-resource: " (pr-str message))
          result (try
                   {:data (overseer-server/register-resource conn-overseer data)}
                   (catch Throwable t
                     {:error (utils/stack-trace-to-string t)}))]
      (reply request-channel
             (:client-id message)
             [:resource-session result])))
  :deregister-resource
  (fn [request-channel {data :data :as message}]
    (overseer-server/deregister-resource conn-overseer data))
  :workflow-task-accept
  (fn [request-channel {data :data :as message}]
    (receive conn-overseer :workflow-task-accept data))
  :workflow-task-done
  (fn [request-channel {data :data :as message}]
    (receive conn-overseer :workflow-task-done data))
  :workflow-task-failed
  (fn [request-channel {data :data :as message}]
    (receive conn-overseer :workflow-task-failed data))
  :workflow-task-running
  (fn [request-channel {data :data :as message}]
    (receive conn-overseer :workflow-task-running data))
  :stop
  (fn [request-channel message]
    (info "got stop message: " message))}))
  (stop [this]))