vagrant-aws-stsmith 0.5.0.dev

data/lib/vagrant-aws/action/start_instance.rb

@@ -0,0 +1,81 @@
+require "log4r"
+
+require 'vagrant/util/retryable'
+
+require 'vagrant-aws/util/timer'
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This starts a stopped instance.
+      class StartInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aws::action::start_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          server = env[:aws_compute].servers.get(env[:machine].id)
+
+          env[:ui].info(I18n.t("vagrant_aws.starting"))
+
+          begin
+            server.start
+
+            region = env[:machine].provider_config.region
+            region_config = env[:machine].provider_config.get_region_config(region)
+
+            # Wait for the instance to be ready first
+            env[:metrics]["instance_ready_time"] = Util::Timer.time do
+              tries = region_config.instance_ready_timeout / 2
+
+              env[:ui].info(I18n.t("vagrant_aws.waiting_for_ready"))
+              begin
+                retryable(:on => Fog::Errors::TimeoutError, :tries => tries) do
+                  # If we're interrupted don't worry about waiting
+                  next if env[:interrupted]
+
+                  # Wait for the server to be ready
+                  server.wait_for(2) { ready? }
+                end
+              rescue Fog::Errors::TimeoutError
+                # Notify the user
+                raise Errors::InstanceReadyTimeout,
+                  timeout: region_config.instance_ready_timeout
+              end
+            end
+          rescue Fog::Compute::AWS::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_aws.waiting_for_ssh"))
+              while true
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+                sleep 2
+              end
+            end
+
+            @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_aws.ready"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-aws/action/stop_instance.rb

@@ -0,0 +1,28 @@
+require "log4r"
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aws::action::stop_instance")
+        end
+
+        def call(env)
+          server = env[:aws_compute].servers.get(env[:machine].id)
+
+          if env[:machine].state.id == :stopped
+            env[:ui].info(I18n.t("vagrant_aws.already_status", :status => env[:machine].state.id))
+          else
+            env[:ui].info(I18n.t("vagrant_aws.stopping"))
+            server.stop(!!env[:force_halt])
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-aws/action/sync_folders.rb

@@ -0,0 +1,118 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+require "vagrant/util/scoped_hash_override"
+
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # AWS instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aws::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          unless Vagrant::Util::Which.which('rsync')
+            env[:ui].warn(I18n.t('vagrant_aws.rsync_not_found_warning', :side => "host"))
+            return
+          end
+
+          if env[:machine].communicate.execute('which rsync', :error_check => false) != 0
+            env[:ui].warn(I18n.t('vagrant_aws.rsync_not_found_warning', :side => "guest"))
+            return
+          end
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            data = scoped_hash_override(data, :aws)
+
+            # Ignore disabled shared folders
+            next if data[:disabled]
+
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            # on windows rsync.exe requires cygdrive-style paths
+            if Vagrant::Util::Platform.windows?
+              hostpath = hostpath.gsub(/^(\w):/) { "/cygdrive/#{$1}" }
+            end
+
+            env[:ui].info(I18n.t("vagrant_aws.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the host path if it doesn't exist and option flag is set
+            if data[:create]
+              begin
+                FileUtils::mkdir_p(hostpath)
+              rescue => err
+                raise Errors::MkdirError,
+                  :hostpath => hostpath,
+                  :err => err
+              end
+            end
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown -R #{ssh_info[:username]} '#{guestpath}'")
+
+            #collect rsync excludes specified :rsync_excludes=>['path1',...] in synced_folder options
+            excludes = ['.vagrant/', 'Vagrantfile', *Array(data[:rsync_excludes])].uniq
+
+            ssh_options = ["StrictHostKeyChecking=no"]
+	    # Use proxy command if it's set
+            if ssh_info[:proxy_command]
+              ssh_options.push("ProxyCommand #{ssh_info[:proxy_command]}")
+            end
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              *excludes.map{|e|['--exclude', e]}.flatten,
+              "-e", "ssh -p #{ssh_info[:port]} #{ssh_key_options(ssh_info)} " + 
+              ssh_options.map { |ssh_option| "-o '#{ssh_option}' " }.join,
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            # we need to fix permissions when using rsync.exe on windows, see
+            # http://stackoverflow.com/questions/5798807/rsync-permission-denied-created-directories-have-no-permissions
+            if Vagrant::Util::Platform.windows?
+              command.insert(1, "--chmod", "ugo=rwX")
+            end
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+
+        private
+
+        def ssh_key_options(ssh_info)
+          # Ensure that `private_key_path` is an Array (for Vagrant < 1.4)
+          Array(ssh_info[:private_key_path]).map { |path| "-i '#{path}' " }.join
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-aws/action/terminate_instance.rb

@@ -0,0 +1,47 @@
+require "log4r"
+require "json"
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aws::action::terminate_instance")
+        end
+
+        def call(env)
+          server = env[:aws_compute].servers.get(env[:machine].id)
+
+          # Release the elastic IP
+          ip_file = env[:machine].data_dir.join('elastic_ip')
+          if ip_file.file?
+            release_address(env,ip_file.read)
+            ip_file.delete
+          end
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_aws.terminating"))
+          server.destroy
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+
+        # Release an elastic IP address
+        def release_address(env,eip)
+          h = JSON.parse(eip)
+          # Use association_id and allocation_id for VPC, use public IP for EC2
+          if h['association_id']
+            env[:aws_compute].disassociate_address(nil,h['association_id'])
+            env[:aws_compute].release_address(h['allocation_id'])
+          else
+            env[:aws_compute].disassociate_address(h['public_ip'])
+            env[:aws_compute].release_address(h['public_ip'])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-aws/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require "vagrant-aws/util/timer"
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, name, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [name, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-aws/action/wait_for_state.rb

@@ -0,0 +1,41 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout
+      class WaitForState
+        # env[:result] will be false in case of timeout.
+        # @param [Symbol] state Target machine state.
+        # @param [Number] timeout Timeout in seconds.
+        def initialize(app, env, state, timeout)
+          @app     = app
+          @logger  = Log4r::Logger.new("vagrant_aws::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          if env[:machine].state.id == @state
+            @logger.info(I18n.t("vagrant_aws.already_status", :status => @state))
+          else
+            @logger.info("Waiting for machine to reach state #{@state}")
+            begin
+              Timeout.timeout(@timeout) do
+                until env[:machine].state.id == @state
+                  sleep 2
+                end
+              end
+            rescue Timeout::Error
+              env[:result] = false # couldn't reach state in time
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-aws/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module AWS
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_aws.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-aws/config.rb

@@ -0,0 +1,372 @@
+require "vagrant"
+
+module VagrantPlugins
+  module AWS
+    class Config < Vagrant.plugin("2", :config)
+      # The access key ID for accessing AWS.
+      #
+      # @return [String]
+      attr_accessor :access_key_id
+
+      # The ID of the AMI to use.
+      #
+      # @return [String]
+      attr_accessor :ami
+
+      # 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 AWS 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 AWS api to use
+      #
+      # @return [String]
+      attr_accessor :version
+
+      # The secret access key for accessing AWS.
+      #
+      # @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 AWS 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
+        @ami                    = 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:
+      #
+      #     aws.region_config "us-east-1" do |region|
+      #       region.ami = "ami-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 AWS 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 AWS environment variables; they
+        # will default to nil if the environment variables are not present.
+        @access_key_id     = ENV['AWS_ACCESS_KEY'] if @access_key_id     == UNSET_VALUE
+        @secret_access_key = ENV['AWS_SECRET_KEY'] if @secret_access_key == UNSET_VALUE
+
+        # AMI must be nil, since we can't default that
+        @ami = nil if @ami == 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 AWS
+        # 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_aws.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_aws.config.access_key_id_required") if \
+              config.access_key_id.nil?
+            errors << I18n.t("vagrant_aws.config.secret_access_key_required") if \
+              config.secret_access_key.nil?
+          end
+
+          if config.associate_public_ip && !subnet_id
+            errors << I18n.t("vagrant_aws.config.subnet_id_required_with_public_ip")
+          end
+
+          errors << I18n.interpolate("vagrant_aws.config.ami_required", :region => @region)  if config.ami.nil?
+        end
+
+        { "AWS 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