(ns core
  (:use [pallet core compute]
        [pallet.phase :only [phase-fn]]
        [pallet.action.exec-script :only [exec-script]]))

(def c2 (compute-service-from-config-file :appapp))
(def n2 (nodes c2))


(def pa-node-spec
     (node-spec
      :image nil))

(def pa-server-spec
     (server-spec
      :phases {:configure (phase-fn
                           (exec-script
                            (touch hello)))}))

(def pa-group-spec
     (group-spec "jasontest" :node-spec pa-node-spec))

#_ (lift pa-group-spec :compute c2 :phase :configure)

(ns pallet.compute.appapp
  (:require
   [clojure.java.io :as io]
   [clojure.string :as string]
   [clojure.tools.logging :as logging]
   [pallet.action-plan :as action-plan]
   [pallet.blobstore :as blobstore]
   [pallet.common.filesystem :as filesystem]
   [pallet.compute :as compute]
   [pallet.compute.implementation :as implementation]
   [pallet.compute.jvm :as jvm]
   [pallet.environment :as environment]
   [pallet.execute :as execute]
   [pallet.utils :as utils]
   [pallet.futures :as futures]
   [pallet.script :as script]
   [pallet.stevedore :as stevedore]
   [pallet.utils :as utils]
   [slingshot.core :as slingshot]))

(defn foo [s]
  (def foo-s s)
  s
  )

#_ (keys foo-s)
#_ (:selected-nodes foo-s)
#_ (:groups foo-s)

(def env
     {
      :user (utils/make-user "jackson")
      :algorithms
      {:lift-fn pallet.core/sequential-lift
       ;;:lift-fn foo
       ;;:vmfest {:create-nodes-fn pallet.compute.vmfest/parallel-create-nodes}
       ;;:converge-fn pallet.core/parallel-adjust-node-counts
       :converge-fn nil
       }})

(deftype AppAppNode
  []
  pallet.compute/Node
  (ssh-port [node] 22)
  (primary-ip [node] "10.35.10.118")
  (private-ip [node] "10.35.10.118")
  (is-64bit? [node] true)
  (group-name [node] "jasontest")
  (hostname [node] "smfd-akg-19-sr3.devel.twitter.com")
  (os-family [node] :debian)
  (os-version [node] "10.5")
  (running? [node] true)
  (terminated? [node] false)
  (id [node] "smfd-akg-19-sr3.devel.twitter.com"))

(deftype AppAppService
  []
  pallet.compute/ComputeService
  (nodes [compute] [(AppAppNode.)])
  (run-nodes [compute group-spec node-count user init-script]
             (println "run-nodes"))
  (reboot [compute nodes] )
  (boot-if-down [compute nodes])
  (shutdown-node [compute node user])
  (shutdown [compute nodes user])
  (ensure-os-family [compute-service group] group)
  (destroy-nodes-in-group [compute group-name])
  (destroy-node [compute node])
  (images [compute])
  (close [compute])

  pallet.environment.Environment
  (environment [_] env)
  )


;;;; Compute service
(defmethod implementation/service :appapp
  [_ _]
  (AppAppService.))