cloudflock 0.4.0

data/lib/cloudflock/interface/cli/app/servers/profile.rb

@@ -0,0 +1,88 @@
+require 'cloudflock/target/servers'
+require 'cloudflock/interface/cli/app/common/servers'
+
+# Public: The Profile class provides the interface to produces profiles
+# describing servers running Unix-like operating systems.
+class CloudFlock::Interface::CLI::App::Servers::Profile
+  include CloudFlock::Interface::CLI::App::Common::Servers
+  include CloudFlock::Target::Servers
+  CLI = CloudFlock::Interface::CLI::Console
+
+  # Public: Begin Servers migration on the command line
+  #
+  # opts - Hash containing options mappings.
+  def initialize(opts)
+    resume = opts[:resume]
+    source_host_def = define_source(opts[:config])
+    source_host_ssh = CLI.spinner("Logging in to #{source_host_def[:host]}") do
+      host_login(source_host_def)
+    end
+
+    profile = CLI.spinner("Checking source host") do
+      profile = Profile.new(source_host_ssh)
+      profile.build
+      profile
+    end
+    platform = Platform::V2.new(profile[:cpe])
+
+    memory = profile[:memory]
+    memory_percent = memory[:mem_used].to_f / memory[:total] * 100
+    swapping = memory[:swapping?]
+    ftag = "#{CLI.bold}%15s#{CLI.reset}:"
+    hist_mem = profile[:memory_hist][:mem_used]
+
+    puts
+    puts "#{CLI.bold}System Information#{CLI.reset}"
+    puts "#{ftag} #{platform} (#{profile[:cpe]})" % "OS"
+    puts "#{ftag} #{profile[:arch]}" % "Arch"
+    puts "#{ftag} #{profile[:hostname]}" % "Hostname"
+    puts
+
+    puts "#{CLI.bold}CPU Statistics#{CLI.reset}"
+    puts "#{ftag} %d" % ["CPU Count", profile[:cpu][:count]]
+    puts "#{ftag} %d MHz" % ["CPU Speed", profile[:cpu][:speed]]
+    puts 
+
+    puts "#{CLI.bold}Memory Statistics#{CLI.reset}"
+    puts "#{ftag} %d MiB" % ["Total RAM", memory[:total]]
+    puts "#{ftag} %d MiB (%2.1f%%)" % ["RAM Used", memory[:mem_used],
+                                         memory_percent]
+    puts "#{ftag} %d MiB" % ["Swap Used", memory[:swap_used]] if swapping
+    puts "#{ftag} %d%%" % ["Hist. RAM Used", hist_mem] unless hist_mem.nil?
+    puts 
+
+    puts "#{CLI.bold}Hard Disk Statistics#{CLI.reset}"
+    puts "#{ftag} %2.1f GB" % ["Disk Used", profile[:disk]]
+    puts
+
+    puts "#{CLI.bold}System Statistics#{CLI.reset}"
+    puts "#{ftag} #{profile[:io][:uptime]}" % "Uptime"
+    puts "#{ftag} #{profile[:io][:wait]}" % "I/O Wait"
+    puts
+
+    puts "#{CLI.bold}IP Information#{CLI.reset}"
+    puts "#{ftag} #{profile[:ip][:public].join(', ')}" % "Public"
+    puts "#{ftag} #{profile[:ip][:private].join(', ')}" % "Private"
+    puts
+
+    puts "#{CLI.bold}MySQL Databases#{CLI.reset}"
+    puts "#{ftag} #{profile[:db][:count]}" % "Number"
+    puts "#{ftag} #{profile[:db][:size]}" % "Total Size"
+    puts
+
+    puts "#{CLI.bold}Libraries#{CLI.reset}"
+    puts "#{ftag} #{profile[:lib][:libc]}" % "LIBC"
+    puts "#{ftag} #{profile[:lib][:perl]}" % "Perl"
+    puts "#{ftag} #{profile[:lib][:python]}" % "Python"
+    puts "#{ftag} #{profile[:lib][:ruby]}" % "Ruby"
+    puts "#{ftag} #{profile[:lib][:php]}" % "PHP"
+    unless profile.warnings.empty?
+      puts
+      print CLI.red + CLI.bold
+      profile.warnings.each { |warning| puts warning }
+      print CLI.reset
+    end
+
+    source_host_ssh.logout!
+  end
+end

data/lib/cloudflock/interface/cli/app/servers.rb

@@ -0,0 +1,2 @@
+require 'cloudflock/interface/cli'
+require 'cloudflock/interface/cli/app/common/servers'

data/lib/cloudflock/interface/cli/console.rb

@@ -0,0 +1,213 @@
+# Public: Provide methods to abstract and simplify interaction with a user via
+# a command-line application.
+#
+# Examples
+#
+#   # prompt for a question with free-form input
+#   answer = Console.prompt("Question")
+#
+#   # Print bolded text
+#   puts "#{Console.bold}Bold text#{Console.reset}"
+module CloudFlock::Interface::CLI::Console extend self
+  # Public: Prompt user for input, allowing for a default answer and a list of
+  # valid responses.
+  #
+  # question - String containing the question to present to the user.
+  # args     - Hash containing arguments to control acceptable responses.
+  #            (default: {}):
+  #            :default_answer - String containing the default answer.  If the
+  #            default is nil, a non-empty answer MUST be given.
+  #            :valid_answers  - An Array containing all valid responses.
+  #
+  # Returns a String containing the answer provided by the user.
+  def prompt(question, args = {})
+    default = args[:default_answer].to_s
+    allow_empty = !args[:default_answer].nil?
+    valid = args[:valid_answers] || []
+
+    default_display = default.empty? ? "" : "[%s]" % default.strip
+    question.strip!
+
+    acceptable = false
+    until acceptable
+      printf("%s %s> ", question, default_display)
+      answer = readline.strip
+
+      if answer.empty? && allow_empty
+        acceptable = true
+      elsif valid.empty? && !answer.empty?
+        acceptable = true
+      elsif !(valid.grep(answer)).empty? && !valid.empty?
+        acceptable = true
+      end
+    end
+
+    answer.empty? ? default.to_s : answer
+  end
+
+  # Public: Wrap Console#prompt but require a Y/N response.
+  #
+  # question - String containing the question to present to the user.
+  # args     - Hash containing arguments to control acceptable responses.
+  #            (default: {}):
+  #            :default_answer - String containing the default answer.
+  #
+  # Returns true or false corresponding to Y or N answer respectively.
+  def prompt_yn(question, args = {})
+    args[:valid] = []
+    answer = nil
+
+    until answer =~ /^[yn]/i
+      answer = prompt(question, args)
+    end
+
+    /^n/i.match(answer).nil?
+  end
+
+  # Public: Render a spinner on the command line and yield to a block,
+  # reporting success if nothing is raised, otherwise reporting failure.
+  #
+  # message - Message to be displayed describing the task being evaluated.
+  # block   - Block to be yielded to determine pass or fail.
+  #
+  # Returns the result of the yielded block if successful.
+  # Raises whatever is raised inside the yielded block.
+  def spinner(message, &block)
+    success = nil
+    result = nil
+
+    pre = "\r#{bold}#{white} [#{reset}"
+    post = "#{bold}#{white}] #{reset}#{message}"
+    pre_ok = "\r#{bold}#{white} [#{green} ok "
+    pre_fail = "\r#{bold}#{white} [#{red}fail"
+
+    thread = Thread.new do
+      step = 0
+      spin = ["    ", ".   ", "..  ", "... ", "....", " ...", "  ..", "   ."]
+      while success.nil?
+        print "#{pre}#{spin[step % 8]}#{post}"
+        step += 1
+        sleep 0.5
+      end
+
+      if success
+        print "#{pre_ok}#{post}\n"
+      else
+        print "#{pre_fail}#{post}\n"
+      end
+    end
+
+    begin
+      result = yield
+      success = true
+      thread.join
+      return result
+    rescue
+      success = false
+      thread.join
+      raise
+    end
+  end
+
+  # Public: Generate a reasonably formatted, printable table.
+  #
+  # options - An Array containing Hash objects which contain desired options:
+  #           [{:col1 => val1, :col2 => val2}, {:col1 => val3, :col2 => val4}]
+  # labels  - A Hash containing key-value pairs to label each key in options.
+  #           (default: nil)
+  #
+  # Returns a String containing the grid.
+  # Raises ArgumentError if options is not an Array which contains at least one
+  # element.
+  def build_grid(options, labels = nil)
+    raise ArgumentError unless options.kind_of?(Array) and !options[0].nil?
+
+    if labels.nil?
+      options.unshift(options[0].keys.reduce({}) { |c,e| {e => e.to_s} })
+    else
+      options.unshift(labels)
+    end
+
+    keys = options[0].keys
+    max_lengths = keys.reduce({}) { |c,e| c.merge({e => 0}) }
+
+    options.each do |row|
+      row.each_key do |key|
+        if max_lengths[key] < row[key].to_s.length
+          max_lengths[key] = row[key].to_s.length
+        end
+      end
+    end
+
+    # Base width = 3n+1
+    grid_width = (max_lengths.length * 3) + 1
+
+    # Construct rule
+    grid_rule = "+"
+    options[0].each_key { |k| grid_rule << "-" * (max_lengths[k] + 2) + "+" }
+
+    # Construct grid
+    grid = ""
+    grid << grid_rule
+
+    options.each_with_index do |row, idx|
+      grid << "\n|"
+      keys.each do |key|
+        grid << sprintf(" % #{max_lengths[key]}s |", row[key])
+      end
+
+      # Visually separate the labels
+      grid << "\n" + grid_rule if idx == 0
+    end
+    grid << "\n" + grid_rule
+  end
+
+  # Minimal documentation provided for the following functions; terminal
+  # control sequences are well documented; here we are only providing
+  # shorthand.
+
+  # Public: Escape sequence
+  #
+  # Returns a String containing an escaped terminal control sequence.
+  def escape(seq); "\033[#{seq}m"; end
+
+  # Public: Reset terminal control
+  #
+  # Returns a String the 'reset' terminal control sequence.
+  def reset; escape("0"); end
+
+  # Public: Set text bold
+  #
+  # Returns a String the terminal control sequence to set text bold.
+  def bold; escape("1"); end
+
+  # Public: Set text underlined
+  #
+  # Returns a String the terminal control sequence to set text underlined.
+  def underline; escape("4"); end
+
+  # Public: Set text flashing
+  #
+  # Returns a String the terminal control sequence to set text flashing.
+  def annoy; escape("5"); end
+
+  # Public: Set text red
+  #
+  # Returns a String the terminal control sequence to set text red.
+  def red; escape("31"); end
+
+  # Public: Set text green
+  #
+  # Returns a String the terminal control sequence to set text green.
+  def green; escape("32"); end
+
+  # Public: Set text blue
+  #
+  # Returns a String the terminal control sequence to set text blue.
+  def blue; escape("34"); end
+
+  # Public: Set text white
+  #
+  # Returns a String the terminal control sequence to set text white.
+  def white; escape("37"); end
+end

data/lib/cloudflock/interface/cli/opts/servers.rb

@@ -0,0 +1,20 @@
+module CloudFlock::Interface::CLI::Opts extend self
+  # Internal: Extend the Opts module to provide options specific to the servers
+  # migration CLI utility.
+  #
+  # opts    - OptionParser object to which to add options.
+  # options - Hash containing options flags and settings for the application.
+  #
+  # Returns nothing.
+  def argv_servers(opts, options)
+    opts.on('-o', '--opencloud', 'Perform an Open Cloud Servers migration') do
+      options[:function] = :opencloud
+    end
+    opts.on('-s', '--servers', 'Perform a Cloud Servers migration') do
+      options[:function] = :servers
+    end
+    opts.on('-r', '--resume', 'Resume a migration') do
+      options[:resume] = true
+    end
+  end
+end

data/lib/cloudflock/interface/cli/opts.rb

@@ -0,0 +1,87 @@
+require 'optparse'
+Dir.glob(File.expand_path("../opts/*", __FILE__), &method(:require))
+
+# Public: The CLI Opts module provides methods to abstract and simplify loading
+# configuration information, parsing options and providing context to the
+# application.
+module CloudFlock::Interface::CLI::Opts extend self
+  CONFIG_LOCATION="~/.flockrc"
+  # Public: Open config files if applicable, overwriting default options with
+  # configuration passed files first, then with any options supplied via the
+  # command line.
+  #
+  # function - String or Symbol containing the name of the function to parse
+  #            arguments for, if applicable. (default: '')
+  #
+  # Returns a Hash containing an option to value map.
+  def parse(function = '')
+    options = parse_config_file(CONFIG_LOCATION)
+
+    argv = parse_argv(function)
+    if argv[:config_file].kind_of?(String)
+      options.merge(parse_config_file(argv[:config_file]))
+    end
+
+    options.merge(argv)
+  end
+
+  # Internal: Open and parse a given config file.
+  #
+  # file - String containing path to a configuration file which will be parsed.
+  #
+  # Returns a Hash containing option-value mappings.
+  def parse_config_file(file)
+    options = {}
+    return options if file.nil?
+
+    config_string = ""
+    if File.exists?(File.expand_path(file))
+      config_string = File.open(File.expand_path(file)).read
+    end
+
+    config_string.each_line do |line|
+      line.gsub!(/#.*/, "").strip!
+      next if line.empty?
+
+      opt,value = line.split(/\s*/, 2)
+      options[opt.to_sym] = value
+    end
+
+    options
+  end
+
+  # Internal: Parse and return options passed via the command line.
+  #
+  # function - String or Symbol containing the name of the function to parse
+  #            arguments for.  This will cause the OptionParser to search for a
+  #            argv_function name for the given name of the function.
+  #
+  # Returns a Hash containing an option to value map.
+  def parse_argv(function)
+    options = {}
+
+    optparse = OptionParser.new do |opts|
+      opts.on('-v', '--verbose', 'Be verbose') do
+        options[:verbose] = true
+      end
+
+      opts.on('-c', '--config FILE', 'Load configuration saved from previous' +
+                                     ' session (useful with -r)') do |file|
+        unless File.exists?(File.expand_path(file))
+          puts "Configuration file #{file} does not exist!  Exiting."
+          exit
+        end
+        options[:config_file] = File.expand_path(file)
+      end
+
+      # Pull in extra options if applicable
+      function = ("argv_" + function.to_s).to_sym
+      if CloudFlock::Interface::CLI::Opts.respond_to?(function)
+        CloudFlock::Interface::CLI::Opts.send(function, opts, options)
+      end
+    end
+    optparse.parse!
+
+    options
+  end
+end

data/lib/cloudflock/interface/cli.rb

@@ -0,0 +1,15 @@
+require 'cloudflock'
+
+module CloudFlock
+  module Interface
+    module CLI
+      module App
+        module Common; end
+        module Servers; end
+      end
+    end
+  end
+end
+
+require 'cloudflock/interface/cli/console'
+require 'cloudflock/interface/cli/opts'

data/lib/cloudflock/patch/fog.rb

@@ -0,0 +1,113 @@
+require 'fog'
+module Fog
+  module Compute
+    class RackspaceV2
+      class Server
+        # Place existing server into rescue mode, allowing for offline editing of configuration. The original server's disk is attached to a new instance of the same base image for a period of time to facilitate working within rescue mode.  The original server will be autom atically restored after 90 minutes.
+        # @return [Boolean] returns true if call to put server in rescue mode returns success
+        # @raise [Fog::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::ServiceError]
+        # @note Rescue mode is only guaranteed to be active for 90 minutes.
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/rescue_mode.html
+        # @see #unrescue
+        #
+        # * Status Transition:
+        #   * ACTIVE -> PREP_RESCUE -> RESCUE
+        def rescue
+          requires :identity
+          data = service.rescue_server(identity)
+          merge_attributes(data.body)
+          self.state = RESCUE
+          true
+        end
+
+        # Remove existing server from rescue mode.
+        # @return [Boolean] returns true if call to remove server from rescue mode returns success
+        # @raise [Fog::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::ServiceError]
+        # @note Rescue mode is only guaranteed to be active for 90 minutes.
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/exit_rescue_mode.html
+        # @see #rescue
+        #
+        # * Status Transition:
+        #   * RESCUE -> PREP_UNRESCUE -> ACTIVE
+        def unrescue
+          requires :identity
+          service.unrescue_server(identity)
+          self.state = ACTIVE
+          true
+        end
+      end
+
+      class Real
+        # Puts server into rescue mode
+        # @param [String] server_id id of server to rescue
+        # @return [Excon::Response] response
+        # @raise [Fog::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::ServiceError]
+        # @note Rescue mode is only guaranteed to be active for 90 minutes.
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/rescue_mode.html
+        #
+        # * Status Transition:
+        #   * ACTIVE -> PREP_RESCUE -> RESCUE
+        def rescue_server(server_id)
+          data = {
+            'rescue' => nil
+          }
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [200],
+            :method => 'POST',
+            :path => "servers/#{server_id}/action"
+          )
+        end
+
+        # Take server out of rescue mode
+        # @param [String] server_id id of server
+        # @return [Excon::Response] response
+        # @raise [Fog::Rackspace::Errors::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::Errors::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::Errors::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::Errors::ServiceError]
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/exit_rescue_mode.html
+        #
+        # * Status Transition:
+        #   * RESCUE -> PREP_UNRESCUE -> ACTIVE
+        def unrescue_server(server_id)
+          data = {
+            'unrescue' => nil
+          }
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [202],
+            :method => 'POST',
+            :path => "servers/#{server_id}/action"
+          )
+        end
+      end
+
+      class Mock
+        def rescue_server(server_id)
+          server = self.data[:servers][server_id]
+          server["status"] = "PREP_RESCUE"
+          response(:status => 200)
+        end
+
+        def unrescue_server(server_id)
+          server = self.data[:servers][server_id]
+          server["status"] = "PREP_UNRESCUE"
+          response(:status => 202)
+        end
+      end
+    end
+  end
+end
+