cloudflock 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77bad0c9dba5e0acc40d97db07f2275c580ccd83
-  data.tar.gz: ea1c657a195ab4a6643e6c8b9267d6db074f7339
+  metadata.gz: 893e1b1d92258582ec865910719ebc50e94c0699
+  data.tar.gz: e9882bb34a21c8b4a863718b10fdaae2056c01e8
 SHA512:
-  metadata.gz: 3a827d7f5a0882d97e6d8d3be223b24e66580d89e59b91123f19e0b1f5bafb15f0ce076876806e6e3b501859a1b2c59d4f24883ccf05605b90218b2307f4fa0e
-  data.tar.gz: 6bc57df99c5cb032eba75095634eb974cea9050f7f063d4195978739391772532acfdefda92e4d711c3fe2fb580cacefcdc842b2f7a04faa14145201844decd5
+  metadata.gz: 763047aa8249b7bff6a305b790a2f66b93377f9acaa7b7756fbf61f89498728f7ab72b5dc4221bd24db831ba7bbf769e184eb3d3162ac115d167335d3d7bb965
+  data.tar.gz: d1ed3d12fcefdf9dcb6be6f0c2bf5eeefa83919dab823433a8f4a7592bed97dae0150082bc9166f6c0d814a0c071c94f83e263fd8f192c73c6768212d301ab2a

data/lib/cloudflock.rb

@@ -4,5 +4,5 @@ require 'cloudflock/errstr'
 # Public: Encapsulate all functionality related to the CloudFlock API and any
 # apps built with such.
 module CloudFlock
-  VERSION = '0.7.3'
+  VERSION = '0.8.0'
 end

data/lib/cloudflock/app.rb

@@ -1,6 +1,7 @@
 require 'optparse'
 require 'cloudflock'
 require 'console-glitter'
+require 'yaml'
 
 module CloudFlock
   # Public: The App module provides any functionality that is expected to be
@@ -79,6 +80,16 @@ module CloudFlock
       options[name] = UI.prompt_yn(prompt, prompt_options)
     end
 
+    def load_config_if_present(options)
+      if File.file?(options[:config_file].to_s)
+        YAML.load_file(options[:config_file]).merge(options)
+      else
+        options
+      end
+    rescue Psych::SyntaxError, NoMethodError
+      options
+    end
+
     # Public: Parse options and expose global options which are expected to be
     # useful in any CLI application.
     #
@@ -95,10 +106,9 @@ module CloudFlock
       opts.separator ''
       opts.separator 'Global Options:'
 
-# TODO: Add config file support.
-#      opts.on('-c', '--config FILE', 'Specify configuration file') do |file|
-#        options[:config_file] = File.expand_path(file)
-#      end
+      opts.on('-c', '--config FILE', 'Specify configuration file') do |file|
+        options[:config_file] = File.expand_path(file)
+      end
 
       opts.on_tail('--version', 'Show Version Information') do
         puts "CloudFlock v#{CloudFlock::VERSION}"
@@ -112,7 +122,7 @@ module CloudFlock
 
       opts.parse!(ARGV)
 
-      options
+      load_config_if_present(options)
     rescue OptionParser::MissingArgument, OptionParser::InvalidOption => error
       puts error.message.capitalize
       puts

data/lib/cloudflock/app/common/servers.rb

@@ -4,6 +4,7 @@ require 'cloudflock/app'
 require 'cloudflock/remote/ssh'
 require 'cloudflock/app/common/rackspace'
 require 'cloudflock/app/common/exclusions'
+require 'cloudflock/app/common/watchdogs'
 require 'cloudflock/app/common/cleanup'
 
 module CloudFlock; module App
@@ -142,6 +143,9 @@ module CloudFlock; module App
       options = {username: nil, password: nil}
       host = self.send(define_method, (host.merge(options)))
       retry
+    rescue Errno::ECONNREFUSED
+      retry_exit("Connection refused from #{host[:hostname]}")
+      retry
     end
 
     # Public: Have the user select from a list of available images to provision
@@ -396,13 +400,15 @@ module CloudFlock; module App
     rescue Net::SSH::Disconnect
       retry_exit('Unable to establish a connection.')
       retry
+    rescue Errno::ECONNREFUSED
+      retry_exit("Connection refused from #{host[:hostname]}")
+      retry
     rescue ArgumentError
       retry_exit('Incorrect passphrase provided for ssh key.')
 
       host.delete(:passphrase)
       check_option_pw(host, :passphrase, "Key passphrase", default_answer: '',
                       allow_empty: true)
-      retry
     end
 
     # Public: Get details for a Fog::Compute instance.
@@ -432,9 +438,11 @@ module CloudFlock; module App
       rsync = prepare_source_rsync(source_shell, dest_shell)
       dest_address = prepare_source_servicenet(source_shell, dest_shell)
 
+      watchdogs = create_watchdogs(source_shell, dest_shell)
       rsync = "#{rsync} -azP -e 'ssh #{SSH_ARGUMENTS} -i #{PRIVATE_KEY}' " +
               "--exclude-from='#{EXCLUSIONS}' / #{dest_address}:#{MOUNT_POINT}"
-      rsync_migrate(source_shell, rsync)
+      rsync_migrate(watchdogs, source_shell, rsync)
+      stop_watchdogs(watchdogs)
     end
 
     # Public: Generate a new ssh keypair to be used for the migration.
@@ -499,24 +507,46 @@ module CloudFlock; module App
       retry
     end
 
+    def rsync_migrate(watchdogs, shell, rsync)
+      UI.spinner('Waiting for all hosts to appear to be in a healthy state') do
+        ensure_no_watchdog_alerts(watchdogs)
+      end
+      UI.spinner('Performing rsync migration') do
+        worker = Thread.new do
+          rsync_migrate_thread(shell, rsync)
+          Thread.current[:complete] = true
+        end
+        set_watchdog_alerts(watchdogs, worker)
+        worker.join
+        raise WatchdogAlert unless worker[:complete]
+      end
+    rescue WatchdogAlert
+      retry
+    end
+
     # Public: Wrap performing an rsync migration.
     #
     # shell - SSH object logged in to the source host.
     # rsync - Command to be run on the source host.
     #
     # Returns nothing.
-    def rsync_migrate(shell, rsync)
-      UI.spinner('Performing rsync migration') do
-        2.times do
-          rsync_migrate_commands(shell, rsync)
-        end
-        shell.logout!
+    def rsync_migrate_thread(shell, rsync)
+      2.times do
+        rsync_migrate_commands(shell, rsync)
       end
+      shell.logout!
     rescue Timeout::Error
       retry if retry_prompt('Server sync is taking a very long time')
       exit
     end
 
+    def ensure_no_watchdog_alerts(watchdogs)
+      raise WatchdogAlert if watchdogs.map(&:triggered_alarms).flatten.any?
+    rescue WatchdogAlert
+      sleep 30
+      retry
+    end
+
     # Public: Issue an rsync command, keeping track of how many times a timeout
     # has occurred, raising an error past a threshhold of 3 timeouts.
     #
@@ -542,8 +572,9 @@ module CloudFlock; module App
     #
     # Returns a String containing the host's new ssh public key.
     def generate_keypair(shell)
+      keygen_command = "ssh-keygen -b 4096 -q -t rsa -f #{PRIVATE_KEY} -P ''"
       shell.as_root("mkdir #{DATA_DIR}")
-      shell.as_root("ssh-keygen -b 4096 -q -t rsa -f #{PRIVATE_KEY} -P ''")
+      shell.as_root(keygen_command, 3600)
       shell.as_root("cat #{PUBLIC_KEY}")
     end
 
@@ -670,6 +701,94 @@ module CloudFlock; module App
       retry
     end
 
+    # Public: For each watchdog in a collection, stop the watchdog.
+    #
+    # watchdogs - Hash containing name => Watchdog mappings.
+    #
+    # Returns nothing.
+    def stop_watchdogs(watchdogs)
+      watchdogs.each { |watchdog| stop_watchdog(watchdog) }
+    end
+
+    # Public: Stop a given watchdog, reporting on the status.
+    #
+    # watchdog - Watchdog object to be stopped.
+    #
+    # Returns nothing.
+    def stop_watchdog(watchdog)
+      UI.spinner("Stopping watchdog: #{watchdog.name}") { watchdog.stop }
+    rescue Timeout::Error
+    end
+
+    # Public: Start all watchdogs for a migration.
+    #
+    # source_shell - SSH object logged in to the source host.
+    # dest_shell   - SSH object logged in to the destination host.
+    #
+    # Returns a Hash containing name => Watchdog mappings.  Watchdogs will have
+    # no alarms set.
+    def create_watchdogs(source_shell, dest_shell)
+      source_watchdogs(source_shell) + dest_watchdogs(dest_shell)
+    end
+
+    # Public: Start all watchdogs to monitor a source host.
+    #
+    # source - SSH object logged in to the source host.
+    #
+    # Returns a Hash containing name => Watchdog mappings.  Watchdogs will have
+    # no alarms set.
+    def source_watchdogs(shell)
+      [:system_load,:utilized_memory].map do |e|
+        start_watchdog(:source, e, shell)
+      end
+    end
+
+    # Public: Start all watchdogs to monitor a destination host.
+    #
+    # source - SSH object logged in to the destination host.
+    #
+    # Returns a Hash containing name => Watchdog mappings.  Watchdogs will have
+    # no alarms set.
+    def dest_watchdogs(shell)
+      [:system_load,:utilized_memory, :used_space].map do |e|
+        start_watchdog(:destination, e, shell)
+      end
+    end
+
+    # Public: Start a watchdog on a given host.
+    #
+    # location - Symbol or String containing the name of the location where the
+    #            watshdog should be run.
+    # name     - Symbol or String describing the watchdog in question.
+    # source   - SSH object logged in to the host which the watchdog should
+    #            monitor.
+    #
+    # Returns a Hash containing name => Watchdog mappings.  Watchdogs will have
+    # no alarms set.
+    def start_watchdog(location, name, shell)
+      display = "#{location} #{name}".capitalize
+      UI.spinner("Starting watchdog: #{display}") do
+        Watchdogs.send(name, shell, display)
+      end
+    rescue Timeout::Error
+      failed = name.to_s.gsub(/_/, ' ').capitalize
+      retry_exit("Timed out starting the #{failed} watchdog.")
+      retry
+    end
+
+    # Public: Set watchdogs up with default alarms.
+    #
+    # watchdogs - Array containing all default watchdogs.
+    # worker    - Thread containing the migration worker.
+    #
+    # Returns nothing.
+    def set_watchdog_alerts(watchdogs, worker)
+      watchdogs.each do |watchdog|
+        method = watchdog.name.split(/ /).last
+        Watchdogs.send("set_alarm_#{method}", watchdog, worker)
+      end
+    end
+
     # Public: Determine what address should be used when connecting from source
     # to destination for the purpose of a migration.  Prefer RFC1918 networks.
     #

data/lib/cloudflock/app/common/watchdogs.rb

@@ -0,0 +1,89 @@
+require 'console-glitter'
+require 'cloudflock/app'
+require 'cloudflock/remote/ssh'
+require 'cloudflock/remote/ssh/watchdog'
+
+module CloudFlock; module App
+  # Public: The Watchdogs module provides commonly used watchdogs.
+  module Watchdogs extend self
+    # Public: Create a Watchdog which monitors the used disk space on a given
+    # host.
+    #
+    # ssh  - SSH session which the Watchdog should monitor.
+    # name - String describing the Watchdog.
+    #
+    # Returns a Watchdog.
+    def used_space(ssh, name)
+      CloudFlock::Remote::SSH::Watchdog.new(name, ssh, 'df', 60) do |df|
+        lines = df.lines.select { |line| /^[^ ]*(?:\s+\d+){2,}/.match line }
+        total = lines.map { |line| line.split(/\s+/)[1].to_i }.reduce(&:+)
+        used  = lines.map { |line| line.split(/\s+/)[2].to_i }.reduce(&:+)
+        used.to_f / total
+      end
+    end
+
+    # Public: Create a Watchdog which monitors the system load average on a
+    # given host.
+    #
+    # ssh  - SSH session which the Watchdog should monitor.
+    # name - String describing the Watchdog.
+    #
+    # Returns a Watchdog.
+    def system_load(ssh, name)
+      CloudFlock::Remote::SSH::Watchdog.new(name, ssh, 'uptime', 15) do |uptime|
+        uptime.split(/\s+/)[-3].to_f
+      end
+    end
+
+    # Public: Create a Watchdog which monitors the memory in use on a given
+    # host.
+    #
+    # ssh  - SSH session which the Watchdog should monitor.
+    # name - String describing the Watchdog.
+    #
+    # Returns a Watchdog.
+    def utilized_memory(ssh, name)
+      CloudFlock::Remote::SSH::Watchdog.new(name, ssh, 'free', 15) do |free|
+        lines = free.lines.select { |line| /Swap/.match line }
+        total,used = lines.empty? ? [0,0] : lines.map(&:to_f)[1..2]
+        total > 0 ? free / total : 0.0
+      end
+    end
+
+    # Public: Set up a default alert for if free space on the host falls below
+    # 5%, killing a given thread if it reaches that threshhold.
+    #
+    # watchdog  - Watchdog to which the alarm should be added.
+    # thread    - Thread to kill if the alarm fires.
+    #
+    # Returns nothing.
+    def set_alarm_used_space(watchdog, thread)
+      watchdog.create_alarm('out_of_space') { |space| space > 0.95 }
+      watchdog.on_alarm('out_of_space')     { |space| thread.kill }
+    end
+
+    # Public: Set up a default alert for if the system load is >10, killing a
+    # given thread if it reaches that threshhold.
+    #
+    # watchdog  - Watchdog to which the alarm should be added.
+    # thread    - Thread to kill if the alarm fires.
+    #
+    # Returns nothing.
+    def set_alarm_system_load(watchdog, thread)
+      watchdog.create_alarm('load_too_high') { |waitq| waitq > 10 }
+      watchdog.on_alarm('load_too_high')     { |waitq| thread.kill }
+    end
+
+    # Public: Set up a default alert for when swap used is > 25%, killing a
+    # given thread if it reaches that threshhold.
+    #
+    # watchdog  - Watchdog to which the alarm should be added.
+    # thread    - Thread to kill if the alarm fires.
+    #
+    # Returns nothing.
+    def set_alarm_utilized_memory(watchdog, thread)
+      watchdog.create_alarm('swapping') { |swap| swap > 0.25 }
+      watchdog.on_alarm('swapping')     { |swap| thread.kill }
+    end
+  end
+end; end

data/lib/cloudflock/app/server-migrate.rb

@@ -11,31 +11,83 @@ module CloudFlock; module App
     include CloudFlock::App::Common
     include CloudFlock::Remote
 
-    # Public: Perform the steps necessary to migrate a Unix host to a standing
-    # host or to a newly provisioned Rackspace Cloud server.
+    # Public: Obtain information needed to migrate one or more Unix hosts, and
+    # perform the migrations.
     def initialize
-      options = parse_options
+      options   = parse_options
+      servers   = options[:servers]
+      servers ||= [options]
+
+      sources  = servers.map(&method(:define_source))
+      profiles = sources.map do |host|
+        source_host = ssh_connect(host)
+        fetch_profile(source_host)
+      end
 
-      source_host = source_connect(options)
-      profile = fetch_profile(source_host)
+      api,managed = get_api_and_service_level unless options[:resume]
 
-      puts generate_recommendation(profile)
+      destinations = profiles.zip(sources).map do |profile, host|
+        destination_info(host, profile, options[:resume], managed, api)
+      end
 
-      dest_host = destination_connect(options, profile)
-      exclusions = build_exclusions(profile.cpe)
-      migrate_server(source_host, dest_host, exclusions)
+      exclusions = profiles.
+        zip(destinations).
+        zip(sources).
+        map(&:flatten).map do |profile, dest, host|
+        puts UI.green { "#{host[:hostname]} -> #{dest[:hostname]}" }
+        build_exclusions(profile.cpe)
+      end
 
-      cleanup_destination(dest_host, profile.cpe)
-      configure_ips(dest_host, profile)
+      results = sources.
+        zip(destinations).
+        zip(exclusions).
+        zip(profiles).
+        map(&:flatten).
+        map { |params| do_migration(*params) }
 
-      puts UI.bold { UI.blue { "Migration complete to #{dest_host.hostname}"} }
-    rescue
-      puts UI.red { 'An unhandled error was encountered.  Details follow:' }
-      raise
+      puts results.join("\n")
     end
 
     private
 
+    # Internal: Perform the steps necessary to migrate one Unix host to another.
+    #
+    # source_host - Information necessary to log in to the source host.
+    # dest_host   - Information necessary to log in to the destination host.
+    # exclusions  - String containing paths to exclude from the migration.
+    # profile     - ServerProfile for the source host.
+    #
+    # Returns a String containing information regarding the success or failure
+    # of the migration.
+    def do_migration(source_host, dest_host, exclusions, profile)
+      source_ssh = ssh_connect(source_host)
+      dest_ssh = ssh_connect(dest_host)
+
+      migrate_server(source_ssh, dest_ssh, exclusions)
+      cleanup_destination(dest_ssh, profile.cpe)
+      configure_ips(dest_ssh, profile)
+
+      UI.bold { UI.blue { "Migration complete to #{dest_host[:hostname]}"} }
+    rescue => e
+      UI.red { 'An unhandled error was encountered.  Details follow:' } +
+      UI.red { e.display + e.backtrace }
+    end
+
+    # Internal: Obtain information relevant to a Rackspace account.
+    #
+    # Returns an Array containing a Fog::Itendity object and a boolean
+    # determining whether the account is managed.
+    def get_api_and_service_level
+      api = define_rackspace_api
+      Fog::Identity.new(api)
+      managed = UI.prompt_yn('Managed Account? (Y/N)', default_answer: 'N')
+
+      [api, managed]
+    rescue Excon::Errors::Unauthorized
+      retry if UI.prompt_yn('Login failed.  Retry? (Y/N)', default_answer: 'Y')
+      exit
+    end
+
     # Internal: Profile a server in order to make accurate recommendations.
     #
     # source_ssh - SSH object connected to a Unix host.
@@ -47,15 +99,28 @@ module CloudFlock; module App
       end
     end
 
-    # Internal: Collect information needed to connect to the source host for a
-    # migration.  Connect to the target host.
+    # Internal: Display a recommendation to the user, then obtain information
+    # needed to log into a target host, creating a new cloud server if
+    # necessary.
     #
-    # options - Hash containing information to connect to an existing host.
+    # host    - Hash containing information regarding the destination host,
+    #           if given.
+    # profile - ServerProfile for the source host.
+    # resume  - Boolean value denoting whether a migration will be resumed.
+    # managed - Boolean value denoting whether the account in question is
+    #           managed.
+    # api     - Fog::Identity object used to make API calls.
     #
-    # Returns an SSH object connected to the source host.
-    def source_connect(options)
-      source_host = define_source(options)
-      ssh_connect(source_host)
+    # Returns a Hash containing information needed to log in to the destination
+    # host.
+    def destination_info(host, profile, resume, managed, api)
+      puts generate_recommendation(profile)
+
+      if resume
+        define_destination(host)
+      else
+        create_cloud_instance(api, profile, managed)
+      end
     end
 
     # Internal: Collect information needed to either connect to an existing
@@ -67,18 +132,7 @@ module CloudFlock; module App
     #
     # Returns an SSH object connected to the target host.
     def destination_connect(options, profile)
-      if options[:resume]
-        dest_host = define_destination(options)
-      else
-        api = define_rackspace_api
-        managed = UI.prompt_yn('Managed account? (Y/N)', default_answer: 'N')
-        dest_host = create_cloud_instance(api, profile, managed)
-      end
-
       ssh_connect(dest_host)
-    rescue Excon::Errors::Unauthorized
-      retry if UI.prompt_yn('Login failed.  Retry? (Y/N)', default_answer: 'Y')
-      exit
     end
 
     # Internal: Provision a new instance on the Rackspace cloud and return

data/lib/cloudflock/app/server-profile.rb

@@ -13,21 +13,37 @@ module CloudFlock; module App
     # information.
     def initialize
       options     = parse_options
-      source_host = options.dup
+      servers     = options[:servers]
+      save_option = true unless servers
+      servers   ||= [options]
+
+      results = servers.map { |server| profile_host(server.dup, save_option) }
+      printable = results.map do |hash|
+        name = hash.keys.first
+        profile = hash[name]
+        UI.bold { UI.green { "#{name}\n" } } +
+        generate_report(profile) +
+        (options[:verbose] ? profile.process_list.to_s : "")
+      end
+
+      puts printable.join("\n\n")
+    end
+
+    private
+
+    def profile_host(source_host, save_option)
+      source_host = define_source(source_host)
+      save_config(source_host) if save_option && save_config?
 
-      source_host = define_source(options)
       source_ssh  = connect_source(source_host)
 
       profile = UI.spinner("Checking source host") do
         CloudFlock::Task::ServerProfile.new(source_ssh)
       end
 
-      puts generate_report(profile)
-      puts profile.process_list if options[:verbose]
+      {source_host[:hostname] => profile}
     end
 
-    private
-
     # Internal: Generate a "title" String (bold, 15 characters wide).
     #
     # tag - String to be turned into a title.
@@ -81,6 +97,40 @@ module CloudFlock; module App
       warnings
     end
 
+    def save_config?
+      UI.prompt_yn('Save to a config file? (Y/N)', default_answer: 'Y')
+    end
+
+    # Internal: Save a configuration file based on the user's earlier answers.
+    #
+    # source_host - Hash containing parameters to use to log in to a server.
+    #
+    # Returns nothing.
+    def save_config(source_host)
+      config_location = determine_config_location(source_host[:hostname])
+      if File.exists?(config_location)
+        clobber = UI.prompt_yn('Overwrite? (Y/N)', default_answer: 'Y')
+        old_config = YAML.load_file(config_location) unless clobber
+      end
+      old_config ||= {}
+
+      File.open(config_location, 'w') do |file|
+        new_servers = old_config[:servers].to_a + [source_host]
+        file.write(YAML.dump(old_config.merge({servers: new_servers})))
+      end
+    end
+
+    # Internal: Prompt the user for a location to save a configuration file.
+    #
+    # hostname - String containing the hostname of the host.
+    #
+    # Returns a String containing a filesystem path.
+    def determine_config_location(hostname)
+      location = File.join(Dir.home, 'cloudflock_' + hostname + '.yaml')
+      UI.prompt_filesystem('Configuration file Location',
+                           default_answer: location)
+    end
+
     # Internal: Set up an OptionParser object to recognize options specific to
     # profiling a remote host.
     #

data/lib/cloudflock/error.rb

@@ -2,6 +2,7 @@ module CloudFlock
   module App
     module Common
       class NoRsyncAvailable < StandardError; end
+      class WatchdogAlert    < StandardError; end
     end
   end
 

data/lib/cloudflock/remote/ssh.rb

@@ -109,6 +109,10 @@ module CloudFlock; module Remote
     rescue EOFError
       start_session
       retry
+    rescue IO::EAGAINWaitReadable
+      sleep 10
+      start_session
+      retry
     end
 
     # Public: Call query on a list of commands, allowing optional timeout and

data/lib/cloudflock/remote/ssh/watchdog.rb

@@ -0,0 +1,129 @@
+require 'cloudflock'
+require 'net/ssh'
+require 'thread'
+
+module CloudFlock; module Remote; class SSH
+  # The Watchdog Class allows for the creation of custom watchdogs to allow the
+  # status of an ongoing migration as well as the health of the hosts involved
+  # to be monitored.
+  #
+  # Examples
+  #
+  #   # Create a Watchdog to monitor system load, the state will be tracked as
+  #   a float and updated every 15 seconds (roughly 3 refreshes by default.)
+  #   # The state of the Watchdog can be accessed via the Watchdog#state method.
+  #   system_load = Watchdog.new(ssh, 'uptime', 15) do |wait|
+  #     wait.gsub(/^.*(\d+\.\d+).*$/, '\\1').to_f
+  #   end
+  #
+  #   # Alerts can be created, so that action can be taken automatically.
+  #   system_load.create_alarm('high_load') { |wait| wait > 10 }
+  #   system_load.on_alarm('high_load') { |wait| puts "Load is #{wait}!"; exit }
+  class Watchdog
+    attr_reader :state
+    attr_reader :name
+
+    # Public: Create a new Watchdog to keep track of some aspect of a given
+    # host's state.
+    #
+    # name     - String containing the watchdog's name.
+    # ssh      - SSH session which the Watchdog should monitor.
+    # command  - String to run periodically on the target SSH session to
+    #            determine the host's state.
+    # interval - Number of seconds to wait between command invocations.
+    #            (default: 30)
+    # block    - Optional block to be passed the results of the command to
+    #            transform the data and make it more easily consumable.
+    #            (default: identity function)
+    def initialize(name, ssh, command, interval = 30, &block)
+      @name      = name
+      @ssh       = ssh
+      @command   = command
+      @interval  = interval
+      @transform = block
+      @thread    = start_thread
+      @alarms    = {}
+      @actions   = {}
+    end
+
+    # Public: Stop the Watchdog from running.
+    #
+    # Returns nothing.
+    def stop
+      thread.kill
+    end
+
+    # Public: Create a new named alarm, providing a predicate to indicate that
+    # the alarm should be considered active.
+    #
+    # name  - Name for the alarm.
+    # block - Block to be evaluated in order to determine if the alarm is
+    #         active.  The block should accept one argument (the current state
+    #         of the Watchdog).
+    #
+    # Returns nothing.
+    def create_alarm(name, &block)
+      alarms[name] = block
+    end
+
+    # Public: Define the action which should be taken when an alarm is
+    # triggered.
+    #
+    # name  - Name of the alarm.
+    # block - Block to be executed when an alarm is determined to be triggered.
+    #         The block should accept one argument (the current state of the
+    #         Watchdog).
+    #
+    # Returns nothing.
+    def on_alarm(name, &block)
+      actions[name] = block
+    end
+
+    # Public: Determine whether a given alarm is presently active.
+    #
+    # name  - Name of the alarm.
+    #
+    # Returns false if the alarm is not defined, or the result of the alarm
+    # predicate otherwise.
+    def alarm_active?(name)
+      triggered = alarms[name].nil? ? false : alarms[name]
+    end
+
+    # Public: Return the state of all active alarms.
+    #
+    # Returns an Array of active alarms.
+    def triggered_alarms
+      alarms.select { |k,v| v[state] }.map(&:first)
+    end
+
+    private
+
+    attr_reader :ssh, :command, :interval, :thread, :transform, :alarms
+    attr_reader :actions
+    attr_writer :state
+
+    # Internal: Create a thread to periodically poll the server and determine
+    # if any alerts should be considered active.
+    #
+    # Returns the newly created thread.
+    def start_thread
+      Thread.new do
+        loop do
+          result = ssh.query(command)
+          state  = transform.nil? ? result : transform[result]
+
+          respond_to_alarms
+          sleep interval
+        end
+      end
+    end
+
+    # Internal: For each alert for which a triggered behavior exists, determine
+    # if the alarm is considered fired.
+    #
+    # Returns nothing.
+    def respond_to_alarms
+      triggered_alarms.each { |key| actions[key].call if actions[key] }
+    end
+  end
+end; end; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cloudflock
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
-- Tina Wuest
+- Chris Wuest
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-10 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog-json
@@ -85,7 +85,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.2.1
 description: CloudFlock is a library and toolchain focused on migration
-email: tina@wuest.me
+email: chris@chriswuest.com
 executables:
 - cloudflock
 - cloudflock-files
@@ -111,6 +111,7 @@ files:
 - lib/cloudflock/app/common/platform_action.rb
 - lib/cloudflock/app/common/rackspace.rb
 - lib/cloudflock/app/common/servers.rb
+- lib/cloudflock/app/common/watchdogs.rb
 - lib/cloudflock/app/files-migrate.rb
 - lib/cloudflock/app/server-migrate.rb
 - lib/cloudflock/app/server-profile.rb
@@ -118,6 +119,7 @@ files:
 - lib/cloudflock/errstr.rb
 - lib/cloudflock/remote/files.rb
 - lib/cloudflock/remote/ssh.rb
+- lib/cloudflock/remote/ssh/watchdog.rb
 - lib/cloudflock/target/servers/platform.rb
 - lib/cloudflock/target/servers/profile.rb
 - lib/cloudflock/task/server-profile.rb