vagrant-gq 0.1.0

data/lib/vagrant-gq/action.rb

@@ -0,0 +1,190 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module GQ
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to halt the remote machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectGQ
+            b2.use StopInstance
+          end
+        end
+      end
+
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b.use Call, IsCreated do |env2, b3|
+                if !env2[:result]
+                  b3.use MessageNotCreated
+                  next
+                end
+              end
+              b2.use ConnectGQ
+              b2.use TerminateInstance
+              b2.use ProvisionerCleanup if defined?(ProvisionerCleanup)
+            else
+              b2.use MessageWillNotDestroy
+            end
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncFolders
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectGQ
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectGQ
+          b.use ReadState
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      def self.action_prepare_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Provision
+          b.use SyncFolders
+          b.use WarnNetworks
+        end
+      end
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBoxUrl
+          b.use ConfigValidate
+          b.use ConnectGQ
+          b.use Call, IsCreated do |env1, b1|
+            if env1[:result]
+              b1.use Call, IsStopped do |env2, b2|
+                if env2[:result]
+                  b2.use action_prepare_boot
+                  b2.use StartInstance # restart this instance
+                else
+                  b2.use MessageAlreadyCreated # TODO write a better message
+                end
+              end
+            else
+              b1.use action_prepare_boot
+              b1.use RunInstance # launch a new instance
+            end
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectGQ
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use action_halt
+            b2.use Call, WaitForState, :stopped, 120 do |env2, b3|
+              if env2[:result]
+                b3.use action_up
+              else
+                # TODO we couldn't reach :stopped, what now?
+              end
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectGQ, action_root.join("connect_gq")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :IsStopped, action_root.join("is_stopped")
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :RunInstance, action_root.join("run_instance")
+      autoload :StartInstance, action_root.join("start_instance")
+      autoload :StopInstance, action_root.join("stop_instance")
+      autoload :SyncFolders, action_root.join("sync_folders")
+      autoload :TerminateInstance, action_root.join("terminate_instance")
+      autoload :TimedProvision, action_root.join("timed_provision") # some plugins now expect this action to exist
+      autoload :WaitForState, action_root.join("wait_for_state")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+    end
+  end
+end

data/lib/vagrant-gq/config.rb

@@ -0,0 +1,372 @@
+require "vagrant"
+
+module VagrantPlugins
+  module GQ
+    class Config < Vagrant.plugin("2", :config)
+      # The access key ID for accessing GQ.
+      #
+      # @return [String]
+      attr_accessor :access_key_id
+
+      # The ID of the AMI to use.
+      #
+      # @return [String]
+      attr_accessor :qmi
+
+      # The availability zone to launch the instance into. If nil, it will
+      # use the default for your account.
+      #
+      # @return [String]
+      attr_accessor :availability_zone
+
+      # The timeout to wait for an instance to become ready.
+      #
+      # @return [Fixnum]
+      attr_accessor :instance_ready_timeout
+
+      # The type of instance to launch, such as "m1.small"
+      #
+      # @return [String]
+      attr_accessor :instance_type
+
+      # The name of the keypair to use.
+      #
+      # @return [String]
+      attr_accessor :keypair_name
+
+      # The private IP address to give this machine (VPC).
+      #
+      # @return [String]
+      attr_accessor :private_ip_address
+
+      # Acquire and attach an elastic IP address (VPC).
+      #
+      # @return [Boolean]
+      attr_accessor :elastic_ip
+
+      # The name of the GQ region in which to create the instance.
+      #
+      # @return [String]
+      attr_accessor :region
+
+      # The EC2 endpoint to connect to
+      #
+      # @return [String]
+      attr_accessor :endpoint
+
+      # The version of the GQ api to use
+      #
+      # @return [String]
+      attr_accessor :version
+
+      # The secret access key for accessing GQ.
+      #
+      # @return [String]
+      attr_accessor :secret_access_key
+
+      # The security groups to set on the instance. For VPC this must
+      # be a list of IDs. For EC2, it can be either.
+      #
+      # @return [Array<String>]
+      attr_reader :security_groups
+
+      # The Amazon resource name (ARN) of the IAM Instance Profile
+      # to associate with the instance.
+      #
+      # @return [String]
+      attr_accessor :iam_instance_profile_arn
+
+      # The name of the IAM Instance Profile to associate with
+      # the instance.
+      #
+      # @return [String]
+      attr_accessor :iam_instance_profile_name
+
+      # The subnet ID to launch the machine into (VPC).
+      #
+      # @return [String]
+      attr_accessor :subnet_id
+
+      # The tags for the machine.
+      #
+      # @return [Hash<String, String>]
+      attr_accessor :tags
+
+      # Use IAM Instance Role for authentication to GQ instead of an
+      # explicit access_id and secret_access_key
+      #
+      # @return [Boolean]
+      attr_accessor :use_iam_profile
+
+      # The user data string
+      #
+      # @return [String]
+      attr_accessor :user_data
+
+      # Block device mappings
+      #
+      # @return [Array<Hash>]
+      attr_accessor :block_device_mapping
+
+      # Indicates whether an instance stops or terminates when you initiate shutdown from the instance
+      #
+      # @return [bool]
+      attr_accessor :terminate_on_shutdown
+
+      # Specifies which address to connect to with ssh
+      # Must be one of:
+      #  - :public_ip_address
+      #  - :dns_name
+      #  - :private_ip_address
+      # This attribute also accepts an array of symbols
+      #
+      # @return [Symbol]
+      attr_accessor :ssh_host_attribute
+
+      # Enables Monitoring
+      #
+      # @return [Boolean]
+      attr_accessor :monitoring
+
+      # EBS optimized instance
+      #
+      # @return [Boolean]
+      attr_accessor :ebs_optimized
+
+      # Assigning a public IP address in a VPC
+      #
+      # @return [Boolean]
+      attr_accessor :associate_public_ip
+
+      def initialize(region_specific=false)
+        @access_key_id          = UNSET_VALUE
+        @qmi                    = UNSET_VALUE
+        @availability_zone      = UNSET_VALUE
+        @instance_ready_timeout = UNSET_VALUE
+        @instance_type          = UNSET_VALUE
+        @keypair_name           = UNSET_VALUE
+        @private_ip_address     = UNSET_VALUE
+        @region                 = UNSET_VALUE
+        @endpoint               = UNSET_VALUE
+        @version                = UNSET_VALUE
+        @secret_access_key      = UNSET_VALUE
+        @security_groups        = UNSET_VALUE
+        @subnet_id              = UNSET_VALUE
+        @tags                   = {}
+        @user_data              = UNSET_VALUE
+        @use_iam_profile        = UNSET_VALUE
+        @block_device_mapping   = []
+        @elastic_ip             = UNSET_VALUE
+        @iam_instance_profile_arn  = UNSET_VALUE
+        @iam_instance_profile_name = UNSET_VALUE
+        @terminate_on_shutdown  = UNSET_VALUE
+        @ssh_host_attribute     = UNSET_VALUE
+        @monitoring             = UNSET_VALUE
+        @ebs_optimized          = UNSET_VALUE
+        @associate_public_ip    = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__compiled_region_configs = {}
+        @__finalized = false
+        @__region_config = {}
+        @__region_specific = region_specific
+      end
+
+      # set security_groups
+      def security_groups=(value)
+        # convert value to array if necessary
+        @security_groups = value.is_a?(Array) ? value : [value]
+      end
+
+      # Allows region-specific overrides of any of the settings on this
+      # configuration object. This allows the user to override things like
+      # AMI and keypair name for regions. Example:
+      #
+      #     gq.region_config "us-east-1" do |region|
+      #       region.qmi = "qmi-12345678"
+      #       region.keypair_name = "company-east"
+      #     end
+      #
+      # @param [String] region The region name to configure.
+      # @param [Hash] attributes Direct attributes to set on the configuration
+      #   as a shortcut instead of specifying a full block.
+      # @yield [config] Yields a new GQ configuration.
+      def region_config(region, attributes=nil, &block)
+        # Append the block to the list of region configs for that region.
+        # We'll evaluate these upon finalization.
+        @__region_config[region] ||= []
+
+        # Append a block that sets attributes if we got one
+        if attributes
+          attr_block = lambda do |config|
+            config.set_options(attributes)
+          end
+
+          @__region_config[region] << attr_block
+        end
+
+        # Append a block if we got one
+        @__region_config[region] << block if block_given?
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def merge(other)
+        super.tap do |result|
+          # Copy over the region specific flag. "True" is retained if either
+          # has it.
+          new_region_specific = other.instance_variable_get(:@__region_specific)
+          result.instance_variable_set(
+          :@__region_specific, new_region_specific || @__region_specific)
+
+          # Go through all the region configs and prepend ours onto
+          # theirs.
+          new_region_config = other.instance_variable_get(:@__region_config)
+          @__region_config.each do |key, value|
+            new_region_config[key] ||= []
+            new_region_config[key] = value + new_region_config[key]
+          end
+
+          # Set it
+          result.instance_variable_set(:@__region_config, new_region_config)
+
+          # Merge in the tags
+          result.tags.merge!(self.tags)
+          result.tags.merge!(other.tags)
+
+          # Merge block_device_mapping
+          result.block_device_mapping |= self.block_device_mapping
+          result.block_device_mapping |= other.block_device_mapping
+        end
+      end
+
+      def finalize!
+        # Try to get access keys from standard GQ environment variables; they
+        # will default to nil if the environment variables are not present.
+        @access_key_id     = ENV['EC2_ACCESS_KEY'] if @access_key_id     == UNSET_VALUE
+        @secret_access_key = ENV['EC2_SECRET_KEY'] if @secret_access_key == UNSET_VALUE
+
+        # AMI must be nil, since we can't default that
+        @qmi = nil if @qmi == UNSET_VALUE
+
+        # Set the default timeout for waiting for an instance to be ready
+        @instance_ready_timeout = 120 if @instance_ready_timeout == UNSET_VALUE
+
+        # Default instance type is an m1.small
+        @instance_type = "m1.small" if @instance_type == UNSET_VALUE
+
+        # Keypair defaults to nil
+        @keypair_name = nil if @keypair_name == UNSET_VALUE
+
+        # Default the private IP to nil since VPC is not default
+        @private_ip_address = nil if @private_ip_address == UNSET_VALUE
+
+        # Acquire an elastic IP if requested
+        @elastic_ip = nil if @elastic_ip == UNSET_VALUE
+
+        # Default region is us-east-1. This is sensible because GQ
+        # generally defaults to this as well.
+        @region = "us-east-1" if @region == UNSET_VALUE
+        @availability_zone = nil if @availability_zone == UNSET_VALUE
+        @endpoint = nil if @endpoint == UNSET_VALUE
+        @version = nil if @version == UNSET_VALUE
+
+        # The security groups are empty by default.
+        @security_groups = [] if @security_groups == UNSET_VALUE
+
+        # Subnet is nil by default otherwise we'd launch into VPC.
+        @subnet_id = nil if @subnet_id == UNSET_VALUE
+
+        # IAM Instance profile arn/name is nil by default.
+        @iam_instance_profile_arn   = nil if @iam_instance_profile_arn  == UNSET_VALUE
+        @iam_instance_profile_name  = nil if @iam_instance_profile_name == UNSET_VALUE
+
+        # By default we don't use an IAM profile
+        @use_iam_profile = false if @use_iam_profile == UNSET_VALUE
+
+        # User Data is nil by default
+        @user_data = nil if @user_data == UNSET_VALUE
+
+        # default false
+        @terminate_on_shutdown = false if @terminate_on_shutdown == UNSET_VALUE
+
+        # default to nil
+        @ssh_host_attribute = nil if @ssh_host_attribute == UNSET_VALUE
+
+        # default false
+        @monitoring = false if @monitoring == UNSET_VALUE
+
+        # default false
+        @ebs_optimized = false if @ebs_optimized == UNSET_VALUE
+
+        # default false
+        @associate_public_ip = false if @associate_public_ip == UNSET_VALUE
+
+        # Compile our region specific configurations only within
+        # NON-REGION-SPECIFIC configurations.
+        if !@__region_specific
+          @__region_config.each do |region, blocks|
+            config = self.class.new(true).merge(self)
+
+            # Execute the configuration for each block
+            blocks.each { |b| b.call(config) }
+
+            # The region name of the configuration always equals the
+            # region config name:
+            config.region = region
+
+            # Finalize the configuration
+            config.finalize!
+
+            # Store it for retrieval
+            @__compiled_region_configs[region] = config
+          end
+        end
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << I18n.t("vagrant_gq.config.region_required") if @region.nil?
+
+        if @region
+          # Get the configuration for the region we're using and validate only
+          # that region.
+          config = get_region_config(@region)
+
+          if !config.use_iam_profile
+            errors << I18n.t("vagrant_gq.config.access_key_id_required") if \
+              config.access_key_id.nil?
+            errors << I18n.t("vagrant_gq.config.secret_access_key_required") if \
+              config.secret_access_key.nil?
+          end
+
+          if config.associate_public_ip && !subnet_id
+            errors << I18n.t("vagrant_gq.config.subnet_id_required_with_public_ip")
+          end
+
+          errors << I18n.interpolate("vagrant_gq.config.qmi_required", :region => @region)  if config.qmi.nil?
+        end
+
+        { "GQ Provider" => errors }
+      end
+
+      # This gets the configuration for a specific region. It shouldn't
+      # be called by the general public and is only used internally.
+      def get_region_config(name)
+        if !@__finalized
+          raise "Configuration must be finalized before calling this method."
+        end
+
+        # Return the compiled region config
+        @__compiled_region_configs[name] || self
+      end
+    end
+  end
+end

data/lib/vagrant-gq/errors.rb

@@ -0,0 +1,31 @@
+require "vagrant"
+
+module VagrantPlugins
+  module GQ
+    module Errors
+      class VagrantGQError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_gq.errors")
+      end
+
+      class FogError < VagrantGQError
+        error_key(:fog_error)
+      end
+
+      class InternalFogError < VagrantGQError
+        error_key(:internal_fog_error)
+      end
+
+      class InstanceReadyTimeout < VagrantGQError
+        error_key(:instance_ready_timeout)
+      end
+
+      class RsyncError < VagrantGQError
+        error_key(:rsync_error)
+      end
+
+      class MkdirError < VagrantGQError
+        error_key(:mkdir_error)
+      end
+    end
+  end
+end

data/lib/vagrant-gq/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant GQ 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 GQ plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module GQ
+    class Plugin < Vagrant.plugin("2")
+      name "GQ"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in GQ (EC2/VPC).
+      DESC
+
+      config(:gq, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:gq, parallel: true) 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", GQ.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_gq")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end