cloudflock 0.4.0

data/bin/flock

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+current_path = File.expand_path('../', __FILE__)
+function = ARGV.shift.to_s
+bin = File.basename($0, '.dev')
+
+if function.match(/^[^-]/)
+  target = "#{current_path}/#{bin}-#{function}"
+else
+  ARGV.unshift(function)
+  target = "#{current_path}/#{bin}.default"
+end
+
+if File.exists?(target)
+  load target
+else
+  print "Function \"#{function}\" not found.  " unless target =~ /\.default$/
+  puts "Available functions:"
+
+  functions = []
+  Dir.foreach(current_path) do |file|
+    next unless file.match(/^#{bin}-[^.]*$/)
+    functions << file.gsub(/^#{bin}-/, '')
+  end
+
+  until functions.empty?
+    a, b, c = functions.shift(3)
+    puts "%-15s %-15s %-15s" % [a, b, c].map { |i| i.to_s }
+  end
+
+  exit 1
+end

data/bin/flock-profile

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'cloudflock/interface/cli/app/servers/profile'
+CLI = CloudFlock::Interface::CLI::Console
+Opts = CloudFlock::Interface::CLI::Opts
+
+# Trap C-c to kill the application in a friendly manner
+trap 'INT' do
+  puts "\nCaught SIGINT, exiting..."
+  exit 1
+end
+
+options = Opts.parse
+options[:function] = :profile
+options[:config] = Opts.parse_config_file(options[:config_file])
+
+CloudFlock::Interface::CLI::App::Servers::Profile.new(options)

data/bin/flock-servers

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'cloudflock/interface/cli/app/servers/migrate'
+CLI = CloudFlock::Interface::CLI::Console
+Opts = CloudFlock::Interface::CLI::Opts
+
+# Trap C-c to kill the application in a friendly manner
+trap 'INT' do
+  puts "\nCaught SIGINT, exiting..."
+  exit 1
+end
+
+options = Opts.parse(:servers)
+type_prompt = "Type of migration (servers, opencloud)?"
+
+if options[:function].nil?
+  options[:function] = CLI.prompt(type_prompt, valid_answers:
+                                  ["servers", "opencloud"],
+                                  default_answer: "opencloud")
+end
+options[:function] = options[:function].to_sym
+options[:config] = Opts.parse_config_file(options[:config_file])
+
+CloudFlock::Interface::CLI::App::Servers::Migrate.new(options)

data/bin/flock.default

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'cloudflock/interface/cli/app/servers/migrate'
+CLI = CloudFlock::Interface::CLI::Console
+Opts = CloudFlock::Interface::CLI::Opts
+
+# Trap C-c to kill the application in a friendly manner
+trap 'INT' do
+  puts "\nCaught SIGINT, exiting..."
+  exit 1
+end
+
+options = Opts.parse(:servers)
+type_prompt = "Type of migration (servers, opencloud)?"
+
+if options[:function].nil?
+  options[:function] = CLI.prompt(type_prompt, valid_answers:
+                                  ["servers", "opencloud"],
+                                  default_answer: "opencloud")
+end
+options[:function] = options[:function].to_sym
+options[:config] = Opts.parse_config_file(options[:config_file])
+
+CloudFlock::Interface::CLI::App::Servers::Migrate.new(options)

data/lib/cloudflock/error.rb

@@ -0,0 +1,26 @@
+module CloudFlock
+  module Remote
+    class SSH
+      class InvalidHostname < StandardError; end
+      class ConnectionFailed < StandardError; end
+      class LoginFailed < StandardError; end
+      class RootFailed < StandardError; end
+    end
+  end
+
+  module Target
+    module Servers
+      module Migrate
+        class LongRunFailed < StandardError; end
+      end
+
+      class Platform
+        class ValueError < StandardError; end
+        class MapUndefined < NameError; end
+      end
+
+      class Profile
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+require 'cloudflock'
+require 'cloudflock/interface/cli'
+require 'cloudflock/remote/ssh'
+
+# Public: The ServersCommon module provides common methods for CLI interaction
+# pertaining to interaction with remote (Unix) servers.
+module CloudFlock::Interface::CLI::App::Common::Servers
+  include CloudFlock::Target::Servers
+
+  SSH = CloudFlock::Remote::SSH
+  CLI = CloudFlock::Interface::CLI::Console
+
+  # Internal: Collect information about the source server to be migrated.
+  #
+  # opts - Hash containing any applicable options mappings for the server in
+  #        question.
+  #
+  # Returns a Hash containing information pertinent to logging in to a host.
+  def define_source(opts)
+    host = {}
+
+    host[:host] = opts[:source_host] || CLI.prompt("Source host")
+    host[:port] = opts[:source_port] || CLI.prompt("Source SSH port",
+                                                   default_answer: "22")
+    host[:username] = opts[:source_user] || CLI.prompt("Source username",
+                                                       default_answer: "root")
+    host[:password] = opts[:source_pass] || CLI.prompt("Source password",
+                                                       default_answer: "")
+
+    until host[:public_key].kind_of?(String)
+      key = opts[:public_key] || CLI.prompt("SSH Key", default_answer: "")
+      if File.file?(File.expand_path(key)) || key.empty?
+        host[:public_key] = key
+      end
+    end
+
+    # Only need to use sudo if the user isn't root
+    if host[:username] == "root"
+      host[:sudo] = false
+    elsif !opts[:source_sudo].nil?
+      host[:sudo] = opts[:source_sudo]
+    else
+      host[:sudo] = CLI.prompt_yn("Use sudo? (Y/N)", default_answer: "Y")
+    end
+
+    # We need the root pass if non-root and no sudo
+    if host[:username] == "root" || host[:sudo]
+      host[:root_pass] = host[:password]
+    else
+      host[:root_pass] = CLI.prompt("Password for root")
+    end
+
+    host
+  end
+
+  # Internal: Collect information about the destination server to target in a
+  # migration -- only used for resume functions.
+  #
+  # Returns a Hash containing information pertinent to logging in to a host.
+  def define_destination
+    host = Hash.new
+
+    host[:host] = CLI.prompt("Destination host")
+    host[:password] = CLI.prompt("Destination root password")
+    host[:pre_steps] = CLI.prompt_yn("Perform pre-migration steps? (Y/N)")
+    host[:username] = "root"
+
+    host
+  end
+
+  # Internal: Initiate a connection to a given host and obtain root privileges.
+  #
+  # host - Hash containing information for connecting to the host:
+  #        :host      - String containing the location to which to connect.
+  #        :port      - String or Fixnum containing the port on which ssh
+  #                     listens. (default: "22")
+  #        :username  - String containing the username to use when logging in.
+  #        :password  - String containing the password for the above user.
+  #        :sudo      - Boolean value defining whether to use sudo to obtain
+  #                     root. (default: false)
+  #        :root_pass - String containing the password to use to obtain root,
+  #                     if the user isn't root and sudo isn't used.
+  #        :verbose   - Boolean value defining whether to flush output to
+  #                     STDOUT. (default: false)
+  #
+  # Returns an SSH object.
+  # Raises ArgumentError unless at least host and user are defined.
+  def host_login(host)
+    if host[:host].nil? || host[:username].nil?
+      raise ArgumentError, "Need at least host and username defined"
+    end
+
+    host[:flush_buffer] = host[:verbose] || false
+
+    ssh = SSH.new(host)
+    ssh.get_root(host[:root_pass], host[:sudo])
+
+    ssh
+  end
+
+  # Internal: Initiate a connection to a destination host.
+  #
+  # host - Hash containing information for connecting to the host:
+  #        :host      - String containing the location to which to connect.
+  #        :password  - String containing the password for the above user.
+  #        :verbose   - Boolean value defining whether to flush output to
+  #                     STDOUT. (default: false)
+  #
+  # Returns an SSH object.
+  # Raises ArgumentError unless at least host and user are defined.
+  def destination_login(host)
+    host[:username] = "root"
+    message = "Connecting to destination host (password: #{host[:password]})"
+    r = 0
+
+    destination_host = CLI.spinner(message) do
+      begin
+        host_login(host)
+      rescue Timeout::Error
+        if (r += 1) < 5
+          sleep 300
+          retry
+        end
+        raise
+      end
+    end
+  end
+end

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

@@ -0,0 +1,357 @@
+require 'fog'
+require 'cloudflock/target/servers'
+require 'cloudflock/interface/cli/app/common/servers'
+
+# Public: The Servers::Migrate app provides the interface to Servers migrations
+# (primarily targeting Managed/Unmanaged Rackspace First-gen and Open Cloud,
+# but other migrations are possible) on the CLI.
+class CloudFlock::Interface::CLI::App::Servers::Migrate
+  include CloudFlock::Interface::CLI::App::Common::Servers
+  CLI = CloudFlock::Interface::CLI::Console
+
+  # Public: Begin Servers migration on the command line
+  #
+  # opts - Hash containing options mappings.
+  def initialize(opts)
+    opencloud = (opts[:function] == :opencloud)
+
+    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
+
+    source_profile = CLI.spinner("Checking source host") do
+      profile = Profile.new(source_host_ssh)
+      profile.build
+      profile
+    end
+
+    if opencloud
+      target_platform = Platform::V2
+    else
+      target_platform = Platform::V1
+    end
+    platform = target_platform.new(source_profile[:cpe])
+    build_target = platform.build_recommendation(source_profile)
+    flavor_list = target_platform::FLAVOR_LIST
+    default_target = flavor_list[build_target[:flavor]]
+
+    # Generate and display a brief summary of the server Platform/Profile
+    os_tag = source_profile[:cpe].vendor == "Unknown" ? CLI.red : CLI.blue
+    ram_qty = default_target[:mem]
+    hdd_qty = default_target[:hdd]
+    decision_reason = "#{CLI.bold}#{build_target[:flavor_reason]}#{CLI.reset}"
+
+    puts "OS: #{CLI.bold}#{os_tag}#{platform}#{CLI.reset}"
+    puts "---"
+    puts "Recommended server:"
+    puts "RAM: #{CLI.bold} % 6d MiB#{CLI.reset}" % ram_qty
+    puts "HDD: #{CLI.bold} % 7d GB#{CLI.reset}" % hdd_qty
+    puts "The reason for this decision is: #{decision_reason}"
+    puts "---"
+    unless source_profile.warnings.empty?
+      print CLI.red + CLI.bold
+      source_profile.warnings.each { |warning| puts warning }
+      print CLI.reset
+      puts "---"
+    end
+
+    if resume
+      destination_host_def = define_destination
+      migration_exclusions = determine_exclusions(source_profile[:cpe])
+      platform.managed = CLI.prompt_yn("Managed service level? (Y/N)",
+                                       default_answer: "Y")
+      platform.rack_connect = CLI.prompt_yn("Rack Connected? (Y/N)",
+                                            default_answer: "N")
+    else
+      api = {}
+      api[:version] = opencloud ? :v2 : :v1
+
+      proceed = CLI.prompt_yn("Spin up this server? (Y/N)", default_answer: "Y")
+      if proceed
+        api[:flavor] = default_target[:id]
+      else
+        puts CLI.build_grid(flavor_list, 
+                            {id: "ID", mem: "RAM (MiB)", hdd: "HDD (GB)" })
+        api[:flavor] = CLI.prompt("Flavor ID",
+                                  default_answer: default_target[:id])
+        api[:flavor] = api[:flavor].to_i
+      end
+
+      migration_exclusions = determine_exclusions(source_profile[:cpe])
+      platform.managed = CLI.prompt_yn("Managed service level? (Y/N)",
+                                       default_answer: "Y")
+      platform.rack_connect = CLI.prompt_yn("Rack Connected? (Y/N)",
+                                            default_answer: "N")
+
+      # Warn against Rack Connect
+      if platform.rack_connect
+        puts "#{CLI.bold}#{CLI.red}*** Rack Connect servers might not " +
+             "provision properly when spun up from the API!  Resume " +
+             "recommended!#{CLI.reset}"
+        sleep 5
+      end
+
+
+      # Check to make sure we have a valid flavor ID
+      exit 0 if api[:flavor] == 0 or flavor_list[api[:flavor]-1].nil?
+
+      # Build our API call
+      api[:hostname] = CLI.prompt("New Server Name",
+                                   default_answer: source_profile[:hostname])
+
+      # OpenCloud only supports US migrations presently
+      if opts[:function] == :opencloud
+        api[:region] = CLI.prompt("Region (dfw, ord)", default_answer: "dfw",
+                            valid_answers: ["ord", "dfw"])
+      else
+        api[:region] = :dfw
+      end
+
+      api[:username] = CLI.prompt("RS Cloud Username")
+      api[:api_key] = CLI.prompt("RS Cloud API key")
+
+      # Name cannot have any special characters in it
+      api[:hostname].gsub!(/[^A-Za-z0-9.]/, '-')
+
+      rack_api = Fog::Compute.new(provider: 'rackspace',
+                                     rackspace_username: api[:username],
+                                     rackspace_api_key: api[:api_key],
+                                     rackspace_region: api[:region],
+                                     version: api[:version])
+
+      # Rescue patch has to be loaded after the connection is created
+      require 'cloudflock/patch/fog'
+
+      # Send API call
+      new_server = CLI.spinner("Spinning up new server: #{api[:hostname]}") do
+        rack_api.servers::create(name: api[:hostname],
+                                 image_id: platform.image,
+                                 flavor_id: api[:flavor])
+
+      end
+
+      # Set the destination host address
+      destination_host_def = {}
+      CLI.spinner("Obtaining information for new instance") do
+        # Obtain the administrative pass for the new host.
+        destination_host_def[:password] = new_server.password
+        server_id = new_server.id
+
+        until new_server.state == 'ACTIVE'
+          sleep 30
+          begin
+            new_server.update
+          rescue NoMethodError
+            new_server.reload
+          end
+        end
+
+        if opencloud
+          dest_host = new_server.addresses["public"].select do |e|
+            e["version"] == 4
+          end
+          destination_host_def[:host] = dest_host[0]["addr"]
+        else
+          destination_host_def[:host] = new_server.addresses["public"][0]
+        end
+      end
+
+      # If we're working within the Managed service level, ensure that Chef
+      # has finished successfully
+      if platform.managed
+        r = 0
+        destination_host_ssh = destination_login(destination_host_def)
+
+        begin
+          message =
+          finished = CLI.spinner("Waiting for Chef to finish") do
+            # Sleep 180 seconds before trying
+            sleep 180
+            Migrate.setup_managed(destination_host_ssh)
+          end
+          unless finished
+            panic = "#{CLI.bold}#{CLI.red}*** MGC Cloud Scripts appear to " +
+                    "have failed to run in a reasonable amount of time." +
+                    "#{CLI.reset}"
+            puts panic
+            exit unless CLI.prompt_yn("Continue? (Y/N)", default_answer: "Y")
+          end
+          destination_host_ssh.logout!
+        rescue
+          panic = "#{CLI.bold}#{CLI.red}*** Unable to communicate with the " +
+                  "destination host.  Bailing out.#{CLI.reset}"
+          puts panic
+          raise
+        end
+      end
+
+      if opts[:function] == :opencloud
+        host = destination_host_def[:host]
+        CLI.spinner("Putting #{host} into rescue mode") do
+          new_server.rescue
+          destination_host_def[:password] = new_server.password
+          new_server.update
+        end
+      else
+        pass_prompt = "Please put #{api[:hostname]} into rescue mode and " +
+                      "give password"
+        destination_host_def[:password] = CLI.prompt(pass_prompt)
+      end
+
+      CLI.spinner "Letting rescue mode come up..." do
+        until new_server.state == 'RESCUE'
+          sleep 30
+          begin
+            new_server.update
+          rescue NoMethodError
+            sleep 60
+            new_server.reload
+          end
+        end
+      end
+
+      Thread.new do
+        continue = false
+        until continue
+          r = 0
+          message = "Checking for SSH on #{destination_host_def[:host]}"
+          ssh_command = "ssh #{SSH::SSH_ARGUMENTS} " +
+                        "root@#{destination_host_def[:host]}"
+          continue = CLI.spinner(message) do
+            begin
+              sleep 20
+              ssh_expect = Expectr.new(ssh_command, flush_buffer: false)
+              ssh_expect.expect("password")
+            rescue
+              retry if (r+=1) < 10
+              raise
+            end
+          end
+        end
+      end.join
+    end
+
+    destination_host_ssh = destination_login(destination_host_def)
+
+    unless destination_host_def[:pre_steps] == false
+      # Attempt to set up the source host 5 times.  If there is a failure,
+      # sleep for 60 seconds before retrying.
+      r = 0
+      begin
+        message = "Setting up source host (attempt #{r + 1}/5)"
+        pubkey = CLI.spinner(message) do
+          begin
+            message.gsub!(/\d\/5/, "#{r + 1}/5")
+            sleep 60 unless r == 0
+            Migrate.setup_source(source_host_ssh, migration_exclusions)
+          rescue
+            retry if (r += 1) < 5
+            raise
+          end
+        end
+      rescue
+        panic = "#{CLI.bold}#{CLI.red}*** Unable to communicate with the " +
+                "source host.  Bailing out.#{CLI.reset}"
+        puts panic
+        raise
+      end
+
+      # Attempt to set up the destination host 5 times.  If there is a
+      # failure, sleep for 60 seconds before retrying.
+      r = 0
+      begin
+        message = "Setting up destination host (attempt #{r + 1}/5)"
+        CLI.spinner(message) do
+          begin
+            message.gsub!(/\d\/5/, "#{r + 1}/5")
+            sleep 60 unless r == 0
+            Migrate.setup_destination(destination_host_ssh, pubkey)
+          rescue
+            retry if (r += 1) < 5
+            raise
+          end
+        end
+      rescue
+        panic = "#{CLI.bold}#{CLI.red}*** Unable to communicate with the " +
+                "destination host.  Bailing out.#{CLI.reset}"
+        puts panic
+        raise
+      end
+    end
+
+    # Determine if Service Net can be used
+    begin
+      CLI.spinner "Checking for ServiceNet" do
+        target_addr = Migrate.check_servicenet(source_host_ssh,
+                                               destination_host_ssh)
+        raise if target_addr.nil?
+        destination_host_def[:target_addr] = target_addr
+      end
+    rescue
+      destination_host_def[:target_addr] = destination_host_def[:host]
+    end
+
+    # Define no timeout for the migration rsync
+    destination_host_def[:timeout] = -1
+
+    # Kick off the migration proper
+    if opts[:verbose]
+      Migrate.migrate_server(source_host_ssh, destination_host_def)
+    else
+      CLI.spinner "Performing migration" do
+        Migrate.migrate_server(source_host_ssh, destination_host_def)
+      end
+    end
+
+    CLI.spinner "Cleaning up destination host" do
+      Migrate.clean_destination(destination_host_ssh, source_profile[:cpe])
+    end
+
+    [destination_host_ssh, source_host_ssh].each do |host|
+      host.logout!
+    end
+
+    puts
+    puts "#{CLI.bold}#{CLI.blue}*** Migration complete#{CLI.reset}\a"
+  end
+
+  # Internal: Ask whether or not to edit the default exclusion list for a given
+  # platform, and facilitate the edit if so.
+  #
+  # cpe - CPE object for the host in question.
+  #
+  # Returns a String containing the exclusions.
+  # Raises ArgumentError if cpe isn't a CPE object.
+  def determine_exclusions(cpe)
+    raise ArgumentError unless cpe.kind_of?(CPE)
+
+    exclusion_string = Migrate.build_default_exclusions(cpe)
+    alter = CLI.prompt_yn("Edit default exclusions list? (Y/N)",
+                          default_answer: "N")
+
+    if alter
+      require 'tempfile'
+
+      tmp_file = Tempfile.new("exclude")
+      tmp_file.write(exclusion_string)
+      tmp_file.close
+
+      # Allow for "other" editors
+      if File.exists?("/usr/bin/editor")
+        editor = "/usr/bin/editor"
+      else
+        editor = "vim"
+      end
+
+      system("#{editor} #{tmp_file.path}")
+      tmp_file.open
+      exclusion_string = tmp_file.read
+      tmp_file.close
+      tmp_file.unlink
+    end
+
+    exclusion_string
+  end
+end