@@ -23,7 +23,8 @@

    #:extract-timeline

    #:extract-list

    #:extract-stack

-   #:timeline))

+   #:timeline

+   #:tagged-kv-formatter))

 (in-package :cloud-watcher.aws-result)

 (defun find-all-indices (pred str &optional accum (start (or (car accum) 0)))

@@ -55,13 +56,6 @@

                                                                  (list (length v)))))))

     (serapeum:string-join parts "-")))

-(deftest decamelize ()

-  (should be equal "a" (decamelize "A"))

-  (should be equal "a" (decamelize "a"))

-  (should be equal "outputs" (decamelize "Outputs"))

-  (should be equal "outputs-outputs" (decamelize "OutputsOutputs"))

-  (should be equal "a-b-c" (decamelize "ABC")))

-

 (defmacro tagged-kv-formatter (tag)

   `(formatter ,(format nil "~a ~~a ~~a~~%" tag)))

@@ -156,3 +150,11 @@

     (setf s-sdt (initialize-date s-sdt)

           s-edt (initialize-date s-edt)

           s-cdt (initialize-date s-cdt))))

+

+

+(deftest decamelize ()

+  (should be equal "a" (decamelize "A"))

+  (should be equal "a" (decamelize "a"))

+  (should be equal "outputs" (decamelize "Outputs"))

+  (should be equal "outputs-outputs" (decamelize "OutputsOutputs"))

+  (should be equal "a-b-c" (decamelize "ABC")))

@@ -3,7 +3,7 @@

   (:import-from :cloud-watcher.aws-result :start-date-time :end-date-time)

   (:import-from :serapeum :op)

   (:import-from :clon :defsynopsis :group :flag :stropt)

-  (:use :cl)

+  (:use :cl :st)

   (:export options

            #:*cloud-watcher-synopsis*

            #:dump))

@@ -20,6 +20,8 @@

            (stropt :long-name "aws-region" :default-value "us-west-2")

            (flag :short-name "u" :long-name "update"))

     (group (:header "misc")

+           (flag :long-name "rebuild")

+           (flag :long-name "self-test")

            (flag :long-name "help"))))

 (defun stack-parameters-main (name)

@@ -28,6 +30,23 @@

 (defun stack-outputs-main (name)

   (stack-outputs (stack-for-name name)))

+(defun run-tests ()

+  (st:test :package (find-package :cloud-watcher.aws-result))

+  (st:test :package (find-package :cloud-watcher.main))

+  (st:test :package (find-package :cloud-watcher.cli)))

+

+(defun dump ()

+  "Create an executable with the command-line interface defined above."

+  (handler-bind ((sb-ext:name-conflict (lambda (c)

+                                         (declare (ignore c))

+                                         (invoke-restart-interactively 'sb-ext:resolve-conflict))))

+    (let ((sb-ext:*on-package-variance* '(:warn (:cloud-watcher.aws-result

+                                                 :cloud-watcher.main

+                                                 :cloud-watcher.cli)

+                                          :error t)))

+      (asdf:load-system :cloud-watcher :force t)))

+  (clon:dump "cloud-watcher" main))

+

 (defun main ()

   (let* ((context (net.didierverna.clon:make-context :synopsis *cloud-watcher-synopsis*))

          (files (clon:remainder :context context))

@@ -39,8 +58,6 @@

     (cond ((clon:getopt :long-name "help") (clon:help))

           ((clon:getopt :long-name "watch") (cloud-watcher.main:watch-stack (car files)))

           ((clon:getopt :long-name "outputs") (stack-outputs-main (car files)))

-          ((clon:getopt :long-name "parameters") (stack-parameters-main (car files))))))

-

-(defun dump ()

-  "Create an executable with the command-line interface defined above."

-  (clon:dump "cloud-watcher" main))

+          ((clon:getopt :long-name "parameters") (stack-parameters-main (car files)))

+          ((clon:getopt :long-name "self-test") (run-tests))

+          ((clon:getopt :long-name "rebuild") (dump)))))

@@ -43,27 +43,50 @@

     (local-time-duration:timestamp-difference (end-date-time timeline)

                                               (start-date-time timeline))))

+(defun every-five-seconds (cb args &optional (delay-function #'sleep))

+  (loop

+     while (apply cb args)

+     do (funcall delay-function 5)))

+

+(deftest every-five-seconds ()

+  (let ((counter 0)

+        delay)

+    (flet ((fake-delay (num)

+             (incf counter)

+             (setf delay num))

+           (work ()

+             (< counter 10)))

+      (every-five-seconds #'work () #'fake-delay)

+      (should be = 10 counter)

+      (should be = 5 delay))))

+

+(defclass stack-watcher ()

+  ())

+

 (defun watch-stack (name)

   (format t "~&Watching ~s~2%" name)

-  (let ((done? nil)

-        (old-status nil))

-    (loop until done?

-       for the-stack = (stack-for-name name)

-       do

-         (unless old-status

-           (format t "~& PARAMETERS ~%============~%")

-           (stack-parameters the-stack)

-           (format t "~&============~2%"))

-

-         (unless (eql old-status (stack-status the-stack))

-           (format t "~&STATUS ~a~%" (stack-status the-stack))

-           (setf old-status (stack-status the-stack)))

-

-         (if (ends-with-subseq "COMPLETE" (symbol-name (stack-status the-stack)))

-             (progn

-               (format t "~2& OUTPUTS ~%=========~%")

-               (stack-outputs the-stack)

-               (format t "~&=========~%")

-               (return)))

-         (sleep 5)))

+  (block nil

+    (let ((old-status nil))

+      (every-five-seconds

+       (lambda ()

+         (let* ((the-stack (stack-for-name name))

+                (current-status (stack-status the-stack)))

+           (unless old-status

+             (format t "~& PARAMETERS ~%============~%")

+             (stack-parameters the-stack)

+             (format t "~&============~2%"))

+

+           (unless (eql old-status current-status)

+             (format t "~&STATUS ~a~%" current-status)

+             (setf old-status current-status))

+

+           (if (ends-with-subseq "COMPLETE" (symbol-name current-status))

+               (progn

+                 (format t "~2& OUTPUTS ~%=========~%")

+                 (stack-outputs the-stack)

+                 (format t "~&=========~%")

+                 nil)

+               t)))

+       ())))

   (fresh-line))

+