vagrant-skytap 0.1.1a

data/lib/vagrant-skytap/config.rb

@@ -0,0 +1,106 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Skytap
+    class Config < Vagrant.plugin("2", :config)
+      # The user id for accessing Skytap.
+      #
+      # @return [String]
+      attr_accessor :username
+
+      # The secret API token for accessing Skytap.
+      #
+      # @return [String]
+      attr_accessor :api_token
+
+      # The base URL for Skytap API calls.
+      #
+      # @return [String]
+      attr_accessor :base_url
+
+      # The url of the source VM to use.
+      #
+      # @return [String]
+      attr_accessor :vm_url
+
+      # The timeout to wait for a VM to become ready.
+      #
+      # @return [Fixnum]
+      attr_accessor :instance_ready_timeout
+
+      # The total number of virtual CPUs for this VM.
+      #
+      # @return [Integer]
+      attr_accessor :cpus
+
+      # The number of virtual CPUs per socket.
+      #
+      # @return [Integer]
+      attr_accessor :cpuspersocket
+
+      # The RAM to use for this machine (measured in MB).
+      #
+      # @return [Integer]
+      attr_accessor :ram
+
+      # The VMware guest OS setting for this machine.
+      #
+      # @return [String]
+      attr_accessor :guestos
+
+      def initialize(region_specific=false)
+        @username               = UNSET_VALUE
+        @api_token              = UNSET_VALUE
+        @base_url               = UNSET_VALUE
+        @vm_url                 = UNSET_VALUE
+        @instance_ready_timeout = UNSET_VALUE
+        @region                 = UNSET_VALUE
+
+        @cpus                   = UNSET_VALUE
+        @cpuspersocket          = UNSET_VALUE
+        @ram                    = UNSET_VALUE
+        @guestos                = UNSET_VALUE
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def finalize!
+        # Try to get access keys from standard Skytap environment variables; they
+        # will default to nil if the environment variables are not present.
+        @username  = ENV['VAGRANT_SKYTAP_USERNAME']  if @username  == UNSET_VALUE
+        @api_token = ENV['VAGRANT_SKYTAP_API_TOKEN'] if @api_token == UNSET_VALUE
+
+        # Base URL for API calls.
+        @base_url = "https://cloud.skytap.com/" if @base_url == UNSET_VALUE
+
+        # Source VM url must be set.
+        @vm_url = nil if @vm_url == UNSET_VALUE
+
+        # Set the default timeout for waiting for an instance to be ready
+        @instance_ready_timeout = 120 if @instance_ready_timeout == UNSET_VALUE
+
+        # Hardware settings default to nil (will be obtained
+        # from the source VM)
+        @cpus          = nil if @cpus          == UNSET_VALUE
+        @cpuspersocket = nil if @cpuspersocket == UNSET_VALUE
+        @ram           = nil if @ram           == UNSET_VALUE
+        @guestos       = nil if @guestos       == UNSET_VALUE
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << I18n.t('vagrant_skytap.config.username_required') unless username
+        errors << I18n.t('vagrant_skytap.config.api_token_required') unless api_token
+        errors << I18n.t('vagrant_skytap.config.vm_url_required') unless vm_url
+
+        { "Skytap Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/core_ext/object/blank.rb

@@ -0,0 +1,82 @@
+# Copied from Rails ActiveSupport 2.3.18:
+# activesupport-2.3.18/lib/active_support/core_ext/object/blank.rb
+#
+# == License
+# Active Support is released under the MIT license.
+
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies:
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # ...to:
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's #present? otherwise returns nil.
+  # object.presence is equivalent to object.present? ? object : nil.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all.  For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/vagrant-skytap/core_ext/object/tap.rb

@@ -0,0 +1,8 @@
+unless Object.respond_to?(:tap)
+  class Object
+    def tap
+      yield self
+      self
+    end
+  end
+end

data/lib/vagrant-skytap/core_ext/try.rb

@@ -0,0 +1,42 @@
+# Copied from Rails ActiveSupport 2.3.18:
+# activesupport-2.3.18/lib/active_support/core_ext/try.rb
+#
+# == License
+# Active Support is released under the MIT license.
+#
+class Object
+  # Invokes the method identified by the symbol +method+, passing it any arguments
+  # and/or the block specified, just like the regular Ruby <tt>Object#send</tt> does.
+  #
+  # *Unlike* that method however, a +NoMethodError+ exception will *not* be raised
+  # and +nil+ will be returned instead, if the receiving object is a +nil+ object or NilClass.
+  #
+  # ==== Examples
+  #
+  # Without try
+  #   @person && @person.name
+  # or
+  #   @person ? @person.name : nil
+  #
+  # With try
+  #   @person.try(:name)
+  #
+  # +try+ also accepts arguments and/or a block, for the method it is trying
+  #   Person.try(:find, 1)
+  #   @people.try(:collect) {|p| p.name}
+  #--
+  # This method definition below is for rdoc purposes only. The alias_method call
+  # below overrides it as an optimization since +try+ behaves like +Object#send+,
+  # unless called on +NilClass+.
+  def try(method, *args, &block)
+    send(method, *args, &block)
+  end
+  remove_method :try
+  alias_method :try, :__send__
+end
+
+class NilClass
+  def try(*args)
+    nil
+  end
+end

data/lib/vagrant-skytap/environment_properties.rb

@@ -0,0 +1,11 @@
+require 'vagrant-skytap/properties'
+
+module VagrantPlugins
+  module Skytap
+    class EnvironmentProperties < Properties
+      def self.filename
+        'environment'
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/errors.rb

@@ -0,0 +1,59 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Skytap
+    module Errors
+      class VagrantSkytapError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_skytap.errors")
+      end
+
+      class InstanceReadyTimeout < VagrantSkytapError
+        error_key(:instance_ready_timeout)
+      end
+
+      class RsyncError < VagrantSkytapError
+        error_key(:rsync_error)
+      end
+
+      class MkdirError < VagrantSkytapError
+        error_key(:mkdir_error)
+      end
+
+      class Unauthorized < VagrantSkytapError
+        error_key(:unauthorized)
+      end
+
+      class DoesNotExist < VagrantSkytapError
+        error_key(:does_not_exist)
+      end
+
+      class ResourceBusy < VagrantSkytapError
+        error_key(:resource_busy)
+      end
+
+      class RateLimited < VagrantSkytapError
+        error_key(:rate_limited)
+      end
+
+      class UnprocessableEntity < VagrantSkytapError
+        error_key(:unprocessable_entity)
+      end
+
+      class OperationFailed < VagrantSkytapError
+        error_key(:operation_failed)
+      end
+
+      class VpnConnectionFailed < VagrantSkytapError
+        error_key(:vpn_connection_failed)
+      end
+
+      class SourceVmNotStopped < VagrantSkytapError
+        error_key(:source_vm_not_stopped)
+      end
+
+      class NoConnectionOptions < VagrantSkytapError
+        error_key(:no_connection_options)
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Skytap plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant Skytap plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module Skytap
+    class Plugin < Vagrant.plugin("2")
+      name "Skytap"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in Skytap (EC2/VPC).
+      DESC
+
+      config(:skytap, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:skytap, parallel: false) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Skytap.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_skytap")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/properties.rb

@@ -0,0 +1,42 @@
+require 'yaml'
+
+module VagrantPlugins
+  module Skytap
+    class Properties
+      attr_reader :properties
+      attr_reader :data_dir
+
+      def self.filename
+        raise NotImplementedError.new('Must override')
+      end
+
+      def self.read(data_dir)
+        file = data_dir.join(filename)
+        if file.exist?
+          YAML.load_file(file)
+        end
+      end
+
+      def self.write(data_dir, properties={})
+        existing_props = read(data_dir) || {}
+        props = existing_props.merge(properties)
+
+        IO.write(data_dir.join(filename),
+                 YAML.dump(props))
+      end
+
+      def initialize(data_dir)
+        @properties = self.class.read(data_dir)
+        @data_dir = data_dir
+      end
+
+      def read
+        self.class.read(@data_dir)
+      end
+
+      def write(properties={})
+        self.class.write(@data_dir, properties)
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/provider.rb

@@ -0,0 +1,50 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module Skytap
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      end
+
+      def state
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_skytap.states.short_#{state_id}")
+        long  = I18n.t("vagrant_skytap.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "Skytap (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/setup_helper.rb

@@ -0,0 +1,193 @@
+require 'log4r'
+require 'yaml'
+require 'vagrant-skytap/vm_properties'
+require 'vagrant-skytap/api/vpn'
+require 'net/ssh/transport/session'
+
+module VagrantPlugins
+  module Skytap
+    class SetupHelper
+      attr_reader :env, :environment, :machine, :provider_config
+      attr_reader :username, :password, :host, :port
+
+      def self.run!(env, environment)
+        new(env, environment).run!
+      end
+
+      def initialize(env, environment)
+        @env = env
+        @logger = Log4r::Logger.new("vagrant_skytap::setup_helper")
+        @environment = environment
+        @machine = env[:machine]
+        @provider_config = env[:machine].provider_config
+        @username = @machine.config.ssh.username
+        @password = @machine.config.ssh.password
+        @host = @machine.config.ssh.host
+        @port = @machine.config.ssh.port || Net::SSH::Transport::Session::DEFAULT_PORT
+      end
+
+      def current_vm
+        environment.current_vm
+      end
+
+      def run!
+        ask_routing
+        ask_credentials
+        write_properties
+      end
+
+
+      private
+
+
+      def ask_credentials
+        @logger.debug("ask_credentials")
+        return if username && password
+
+        env[:ui].info("Note that the machine password will be stored in " \
+                      "cleartext on your local filesystem.")
+
+        creds = current_vm.credentials.select(&:recognized?)
+
+        if username
+          env[:ui].info("SSH username found in Vagrantfile: #{username}")
+          match = creds.detect{|c| c.username == username}
+
+          if match
+            @logger.info("Found username in Vagrantfile. Using matching password from credentials.")
+            env[:ui].info("Matched SSH password in Skytap VM credentials.")
+            @password = match.password
+          else
+            @logger.info("Found username in Vagrantfile. Will use manual password entry.")
+          end
+        elsif creds.present?
+          question = "How do you want to choose SSH credentials for machine '#{@machine.name}'?"
+          choices = creds.collect do |c|
+            "Use VM credentials stored in Skytap: #{c}"
+          end
+          choices << 'Type credentials manually'
+
+          ask_from_list(question, choices, 0) do |i|
+            if cred = creds[i]
+              @username = cred.username
+              @password = cred.password
+            end
+          end
+        else
+          @logger.info("No login credentials found for the VM. Prompting for manual username/password entry.")
+        end
+
+        @username ||= ask_username
+        @password ||= ask_password
+      end
+
+      def ask_username
+        @username = ask('Enter SSH username:').strip
+      end
+
+      def ask_password
+        @password = ask('Enter SSH password (no output will appear):', echo: false).strip
+      end
+
+      def ask_routing
+        @logger.debug("ask_routing")
+        return if host && port
+
+        iface = current_vm.interfaces.first
+        choices = connection_choices(iface).select(&:valid?)
+        raise Errors::NoConnectionOptions unless choices.present?
+
+        question = "How do you want to connect to machine '#{@machine.name}'?"
+        ask_from_list(question, choices, 0) do |i, choice|
+          @host, @port = choice.choose
+        end
+      end
+
+      def connection_choices(iface)
+        vpn_choices(iface)
+      end
+
+      def vpn_choices(iface)
+        candidates = vpns.select do |vpn|
+          vpn.nat_enabled? || vpn.subsumes?(iface.network)
+        end
+
+        candidates.collect {|vpn| vpn.choice_for_setup(iface.vm) }
+      end
+
+      def public_ip_choices(iface)
+        ips = iface.public_ips + iface.available_ips
+        ips.collect {|ip| ip.choice_for_setup(iface) }
+      end
+
+      def published_service_choices(iface)
+        iface.published_service_choices
+      end
+
+      def vpns
+        VagrantPlugins::Skytap::API::Vpn.all(env, query: {region: environment.region})
+      end
+
+      # Given a message and an array of choices, displays them to the user as a
+      # numbered list and asks the user to choose one. Returns the index that
+      # the user chose.
+      #
+      # The choices are presented to the user starting at 1, but the return
+      # value is a 0-based Ruby index. If specified, +default_index+ should be
+      # 0-based.
+      #
+      # If a block is given, yields chosen index.
+      def ask_from_list(message, choices, default_index=nil, &block)
+        if default_index && (default_index < 0 || default_index >= choices.size)
+          raise ArgumentError.new("Bad value for default #{default_index.inspect}")
+        end
+
+        numbered_choices = choices.each_with_index.collect do |choice, i|
+          "#{i+1}. #{choice}"
+        end.join("\n")
+
+        default_choice = " [#{default_index+1}]" if default_index
+        prompt = "Enter choice number:#{default_choice} "
+
+        index = nil
+
+        until index && index >= 0 && index < choices.length
+          input = env[:ui].ask([message, numbered_choices, prompt].join("\n\n"),
+                               prefix: false)
+          begin
+            if default_index && input.blank?
+              index = default_index
+            else
+              index = Integer(input, 10) - 1
+            end
+          rescue ArgumentError
+            # No-op
+          end
+        end
+
+        yield index, choices[index] if block_given?
+
+        index
+      end
+
+      def ask(message, options={})
+        prompt = message
+        if default = options[:default]
+          prompt = "#{message} [#{default}] "
+        else
+          prompt = "#{message} "
+        end
+
+        env[:ui].ask(prompt, {prefix: false}.merge(options))
+      end
+
+      def write_properties
+        VmProperties.write(env[:machine].data_dir,
+                              'username' => username,
+                              'password' => password,
+                              'host' => host,
+                              'port' => port)
+      end
+    end
+  end
+end