vagrant-aws 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6eb997239c2902fd5ffe82a2ad85f6a750b68fcc
-  data.tar.gz: b4db22de6d6004ec60a2bd97f8bea1abe0b23ff8
+  metadata.gz: 8af2e697fcbbf3ff15a67a92539b492944ba5784
+  data.tar.gz: 3729da1381c5fed78328854b5a447d104fb82212
 SHA512:
-  metadata.gz: 6a38047b88672ff53ff8002acaf948071bd020bac0e6cb4503291a1e10e2fb57406b4f6a6e1fadb63b5d1cfdf601b47b58bbb20191fe1d855a8748e0339422ad
-  data.tar.gz: d93eca59839124a024b471430d8864b4aec2a5d2a8723e3ddb77d2a9babab505a478bc4517cc39db8bd82f1b16a00a238b15347a38d83bf42ae6914d4f57be6f
+  metadata.gz: 1f3c1b091c706c26507221206a92de3f8b7ba8d9f421c37de7164f84ed652838afa0d59127243e3ae863435a553c61f37b6bcd17d548c5c39946354b637fac53
+  data.tar.gz: 07c726e7633b5913e74d0e522044607253248d6bff1d00dde238f9d9ff54cd6764adc4c33dc3cce442d827dc48571a1c95c6b1774d144fe0b8884c5ac9deef9b

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-# 0.5.0 (unreleased)
+# 0.5.1 
+
+* Support static Elastic IP addresses.
+
+# 0.5.0 (June 22, 2014)
 
 * Support for associating public IPs for VMs inside of VPCs (GH
   [#219](https://github.com/mitchellh/vagrant-aws/pull/219), GH

data/README.md

@@ -1,4 +1,5 @@
 # Vagrant AWS Provider
+[![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/mitchellh/vagrant-aws?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 <span class="badges">
 [![Gem Version](https://badge.fury.io/rb/vagrant-aws.png)][gem]
@@ -20,8 +21,9 @@ EC2 and VPC.
 * SSH into the instances.
 * Provision the instances with any built-in Vagrant provisioner.
 * Minimal synced folder support via `rsync`.
-* Define region-specifc configurations so Vagrant can manage machines
+* Define region-specific configurations so Vagrant can manage machines
   in multiple regions.
+* Package running instances into new vagrant-aws friendly boxes
 
 ## Usage
 
@@ -61,6 +63,7 @@ Vagrant.configure("2") do |config|
   config.vm.provider :aws do |aws, override|
     aws.access_key_id = "YOUR KEY"
     aws.secret_access_key = "YOUR SECRET KEY"
+    aws.session_token = "SESSION TOKEN"
     aws.keypair_name = "KEYPAIR NAME"
 
     aws.ami = "ami-7747d01e"
@@ -105,17 +108,25 @@ This provider exposes quite a few provider-specific configuration options:
   the instance. If nil, it will use the default set by Amazon.
 * `instance_ready_timeout` - The number of seconds to wait for the instance
   to become "ready" in AWS. Defaults to 120 seconds.
-* `instance_type` - The type of instance, such as "m1.small". The default
-  value of this if not specified is "m1.small".
+* `instance_package_timeout` - The number of seconds to wait for the instance
+  to be burnt into an AMI during packaging. Defaults to 600 seconds.
+* `instance_type` - The type of instance, such as "m3.medium". The default
+  value of this if not specified is "m3.medium".  "m1.small" has been
+  deprecated in "us-east-1" and "m3.medium" is the smallest instance
+  type to support both paravirtualization and hvm AMIs
 * `keypair_name` - The name of the keypair to use to bootstrap AMIs
    which support it.
+* `session_token` - The session token provided by STS
 * `private_ip_address` - The private IP address to assign to an instance
   within a [VPC](http://aws.amazon.com/vpc/)
+* `elastic_ip` - Can be set to 'true', or to an existing Elastic IP address. 
+  If true, allocate a new Elastic IP address to the instance. If set
+  to an existing Elastic IP address, assign the address to the instance.
 * `region` - The region to start the instance in, such as "us-east-1"
 * `secret_access_key` - The secret access key for accessing AWS
 * `security_groups` - An array of security groups for the instance. If this
   instance will be launched in VPC, this must be a list of security group
-  Name.
+  Name. For a nondefault VPC, you must use security group IDs instead (http://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html).
 * `iam_instance_profile_arn` - The Amazon resource name (ARN) of the IAM Instance
     Profile to associate with the instance
 * `iam_instance_profile_name` - The name of the IAM Instance Profile to associate
@@ -184,8 +195,8 @@ There is minimal support for synced folders. Upon `vagrant up`,
 `rsync` (if available) to uni-directionally sync the folder to
 the remote machine over SSH.
 
-This is good enough for all built-in Vagrant provisioners (shell,
-chef, and puppet) to work!
+See [Vagrant Synced folders: rsync](https://docs.vagrantup.com/v2/synced-folders/rsync.html)
+
 
 ## Other Examples
 

data/lib/vagrant-aws/action.rb

@@ -8,6 +8,21 @@ module VagrantPlugins
       # Include the built-in modules so we can use them as top-level things.
       include Vagrant::Action::Builtin
 
+      def self.action_package
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            # Connect to AWS and then Create a package from the server instance
+            b2.use ConnectAWS
+            b2.use PackageInstance
+          end
+        end
+      end
+
       # This action is called to halt the remote machine.
       def self.action_halt
         Vagrant::Action::Builder.new.tap do |b|
@@ -30,16 +45,16 @@ module VagrantPlugins
           b.use Call, DestroyConfirm do |env, b2|
             if env[:result]
               b2.use ConfigValidate
-              b.use Call, IsCreated do |env2, b3|
+              b2.use Call, IsCreated do |env2, b3|
                 if !env2[:result]
                   b3.use MessageNotCreated
                   next
                 end
+                b3.use ConnectAWS
+                b3.use ElbDeregisterInstance
+                b3.use TerminateInstance
+                b3.use ProvisionerCleanup if defined?(ProvisionerCleanup)
               end
-              b2.use ConnectAWS
-              b2.use ElbDeregisterInstance
-              b2.use TerminateInstance
-              b2.use ProvisionerCleanup if defined?(ProvisionerCleanup)
             else
               b2.use MessageWillNotDestroy
             end
@@ -58,7 +73,7 @@ module VagrantPlugins
             end
 
             b2.use Provision
-            b2.use SyncFolders
+            b2.use SyncedFolders
           end
         end
       end
@@ -117,7 +132,7 @@ module VagrantPlugins
       def self.action_prepare_boot
         Vagrant::Action::Builder.new.tap do |b|
           b.use Provision
-          b.use SyncFolders
+          b.use SyncedFolders
           b.use WarnNetworks
           b.use ElbRegisterInstance
         end
@@ -126,7 +141,7 @@ module VagrantPlugins
       # 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 HandleBox
           b.use ConfigValidate
           b.use ConnectAWS
           b.use Call, IsCreated do |env1, b1|
@@ -177,12 +192,12 @@ module VagrantPlugins
       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 :PackageInstance, action_root.join("package_instance")
       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")

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

@@ -30,6 +30,7 @@ module VagrantPlugins
           else
             fog_config[:aws_access_key_id] = region_config.access_key_id
             fog_config[:aws_secret_access_key] = region_config.secret_access_key
+            fog_config[:aws_session_token] = region_config.session_token
           end
 
           fog_config[:endpoint] = region_config.endpoint if region_config.endpoint
@@ -37,7 +38,7 @@ module VagrantPlugins
 
           @logger.info("Connecting to AWS...")
           env[:aws_compute] = Fog::Compute.new(fog_config)
-          env[:aws_elb]     = Fog::AWS::ELB.new(fog_config.except(:provider))
+          env[:aws_elb]     = Fog::AWS::ELB.new(fog_config.except(:provider, :endpoint))
 
           @app.call(env)
         end

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

@@ -0,0 +1,192 @@
+require "log4r"
+require 'vagrant/util/template_renderer'
+require 'vagrant-aws/util/timer'
+require 'vagrant/action/general/package'
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This action packages a running aws-based server into an
+      # aws-based vagrant box. It does so by burning the associated
+      # vagrant-aws server instance, into an AMI via fog. Upon
+      # successful AMI burning, the action will create a .box tarball
+      # writing a Vagrantfile with the fresh AMI id into it.
+
+      # Vagrant itself comes with a general package action, which 
+      # this plugin action does call. The general action provides
+      # the actual packaging as well as other options such as
+      # --include for including additional files and --vagrantfile
+      # which is pretty much not useful here anyway.
+
+      # The virtualbox package plugin action was loosely used
+      # as a model for this class.
+
+      class PackageInstance < Vagrant::Action::General::Package
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aws::action::package_instance")
+          env["package.include"] ||= []
+          env["package.output"] ||= "package.box"
+        end
+
+        alias_method :general_call, :call
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # This block attempts to burn the server instance into an AMI
+          begin
+            # Get the Fog server object for given machine
+            server = env[:aws_compute].servers.get(env[:machine].id)
+
+            env[:ui].info(I18n.t("vagrant_aws.packaging_instance", :instance_id => server.id))
+            
+            # Make the request to AWS to create an AMI from machine's instance
+            ami_response = server.service.create_image server.id, "#{server.tags["Name"]} Package - #{Time.now.strftime("%Y%m%d-%H%M%S")}", ""
+
+            # Find ami id
+            @ami_id = ami_response.data[:body]["imageId"]
+            
+            # Attempt to burn the aws instance into an AMI within timeout
+            env[:metrics]["instance_ready_time"] = Util::Timer.time do
+              
+              # Get the config, to set the ami burn timeout
+              region = env[:machine].provider_config.region
+              region_config = env[:machine].provider_config.get_region_config(region)
+              tries = region_config.instance_package_timeout / 2
+
+              env[:ui].info(I18n.t("vagrant_aws.burning_ami", :ami_id => @ami_id))
+
+              # Check the status of the AMI every 2 seconds until the ami burn timeout has been reached
+              begin
+                retryable(:on => Fog::Errors::TimeoutError, :tries => tries) do
+                  # If we're interrupted don't worry about waiting
+                  next if env[:interrupted]
+
+                  # Need to update the ami_obj on each cycle
+                  ami_obj = server.service.images.get(@ami_id)
+
+                  # Wait for the server to be ready, raise error if timeout reached 
+                  server.wait_for(2) { 
+                    if ami_obj.state == "failed"
+                      raise Errors::InstancePackageError, 
+                        ami_id: ami_obj.id,
+                        err: ami_obj.state
+                      return
+                    else
+                      # Successful AMI burn will result in true here
+                      ami_obj.ready?
+                    end
+                  }
+                end
+              rescue Fog::Errors::TimeoutError
+                # Notify the user upon timeout
+                raise Errors::InstancePackageTimeout,
+                  timeout: region_config.instance_package_timeout
+              end
+            end
+            env[:ui].info(I18n.t("vagrant_aws.packaging_instance_complete", :time_seconds => env[:metrics]["instance_ready_time"].to_i))
+          rescue Fog::Compute::AWS::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          # Handles inclusions from --include and --vagrantfile options
+          setup_package_files(env)
+
+          # Setup the temporary directory for the tarball files
+          @temp_dir = env[:tmp_path].join(Time.now.to_i.to_s)
+          env["export.temp_dir"] = @temp_dir
+          FileUtils.mkpath(env["export.temp_dir"])
+
+          # Create the Vagrantfile and metadata.json files from templates to go in the box
+          create_vagrantfile(env)
+          create_metadata_file(env)
+
+          # Just match up a couple environmental variables so that
+          # the superclass will do the right thing. Then, call the
+          # superclass to actually create the tarball (.box file)
+          env["package.directory"] = env["export.temp_dir"]
+          general_call(env)
+          
+          # Always call recover to clean up the temp dir
+          clean_temp_dir
+        end
+
+        protected
+
+        # Cleanup temp dir and files
+        def clean_temp_dir
+          if @temp_dir && File.exist?(@temp_dir)
+            FileUtils.rm_rf(@temp_dir)
+          end
+        end
+
+        # This method generates the Vagrantfile at the root of the box. Taken from 
+        # VagrantPlugins::ProviderVirtualBox::Action::PackageVagrantfile
+        def create_vagrantfile env
+          File.open(File.join(env["export.temp_dir"], "Vagrantfile"), "w") do |f|
+            f.write(TemplateRenderer.render("vagrant-aws_package_Vagrantfile", {
+              region: env[:machine].provider_config.region,
+              ami: @ami_id,
+              template_root: template_root
+            }))
+          end
+        end
+
+        # This method generates the metadata.json file at the root of the box.
+        def create_metadata_file env
+          File.open(File.join(env["export.temp_dir"], "metadata.json"), "w") do |f|
+            f.write(TemplateRenderer.render("metadata.json", {
+              template_root: template_root
+            }))
+          end
+        end
+
+        # Sets up --include and --vagrantfile files which may be added as optional
+        # parameters. Taken from VagrantPlugins::ProviderVirtualBox::Action::SetupPackageFiles
+        def setup_package_files(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Vagrant::Errors::PackageIncludeMissing,
+              file: from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+        end
+
+        # Used to find the base location of aws-vagrant templates
+        def template_root
+          AWS.source_root.join("templates")
+        end
+
+      end
+    end
+  end
+end

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

@@ -95,11 +95,10 @@ module VagrantPlugins
           if !security_groups.empty?
             security_group_key = options[:subnet_id].nil? ? :groups : :security_group_ids
             options[security_group_key] = security_groups
+            env[:ui].warn(I18n.t("vagrant_aws.warn_ssh_access")) unless allows_ssh_port?(env, security_groups, subnet_id)
           end
 
           begin
-            env[:ui].warn(I18n.t("vagrant_aws.warn_ssh_access")) unless allows_ssh_port?(env, security_groups, subnet_id)
-
             server = env[:aws_compute].servers.create(options)
           rescue Fog::Compute::AWS::NotFound => e
             # Invalid subnet doesn't have its own error so we catch and
@@ -132,7 +131,7 @@ module VagrantPlugins
                 next if env[:interrupted]
 
                 # Wait for the server to be ready
-                server.wait_for(2) { ready? }
+                server.wait_for(2, 5) { ready? }
               end
             rescue Fog::Errors::TimeoutError
               # Delete the instance
@@ -149,7 +148,7 @@ module VagrantPlugins
           # Allocate and associate an elastic IP if requested
           if elastic_ip
             domain = subnet_id ? 'vpc' : 'standard'
-            do_elastic_ip(env, domain, server)
+            do_elastic_ip(env, domain, server, elastic_ip)
           end
 
           if !env[:interrupted]
@@ -198,26 +197,45 @@ module VagrantPlugins
           !rules.select { |r| (r["fromPort"]..r["toPort"]).include?(port) }.empty?
         end
 
-        def do_elastic_ip(env, domain, server)
-          begin
-            allocation = env[:aws_compute].allocate_address(domain)
-          rescue
-            @logger.debug("Could not allocate Elastic IP.")
-            terminate(env)
-            raise Errors::FogError,
-                            :message => "Could not allocate Elastic IP."
+        def do_elastic_ip(env, domain, server, elastic_ip)
+          if elastic_ip =~ /\d+\.\d+\.\d+\.\d+/
+            begin
+              address = env[:aws_compute].addresses.get(elastic_ip)
+            rescue
+              handle_elastic_ip_error(env, "Could not retrieve Elastic IP: #{elastic_ip}")
+            end
+            if address.nil?
+              handle_elastic_ip_error(env, "Elastic IP not available: #{elastic_ip}")
+            end
+            @logger.debug("Public IP #{address.public_ip}")
+          else
+            begin
+              allocation = env[:aws_compute].allocate_address(domain)
+            rescue
+              handle_elastic_ip_error(env, "Could not allocate Elastic IP.")
+            end
+            @logger.debug("Public IP #{allocation.body['publicIp']}")
           end
-          @logger.debug("Public IP #{allocation.body['publicIp']}")
 
           # Associate the address and save the metadata to a hash
+          h = nil
           if domain == 'vpc'
             # VPC requires an allocation ID to assign an IP
-            association = env[:aws_compute].associate_address(server.id, nil, nil, allocation.body['allocationId'])
-            h = { :allocation_id => allocation.body['allocationId'], :association_id => association.body['associationId'], :public_ip => allocation.body['publicIp'] }
+            if address
+              association = env[:aws_compute].associate_address(server.id, nil, nil, address.allocation_id)
+            else
+              association = env[:aws_compute].associate_address(server.id, nil, nil, allocation.body['allocationId'])
+              # Only store release data for an allocated address
+              h = { :allocation_id => allocation.body['allocationId'], :association_id => association.body['associationId'], :public_ip => allocation.body['publicIp'] }
+            end
           else
             # Standard EC2 instances only need the allocated IP address
-            association = env[:aws_compute].associate_address(server.id, allocation.body['publicIp'])
-            h = { :public_ip => allocation.body['publicIp'] }
+            if address
+              association = env[:aws_compute].associate_address(server.id, address.public_ip)
+            else
+              association = env[:aws_compute].associate_address(server.id, allocation.body['publicIp'])
+              h = { :public_ip => allocation.body['publicIp'] }
+            end
           end
 
           unless association.body['return']
@@ -228,12 +246,21 @@ module VagrantPlugins
           end
 
           # Save this IP to the data dir so it can be released when the instance is destroyed
-          ip_file = env[:machine].data_dir.join('elastic_ip')
-          ip_file.open('w+') do |f|
-            f.write(h.to_json)
+          if h 
+            ip_file = env[:machine].data_dir.join('elastic_ip')
+            ip_file.open('w+') do |f|
+              f.write(h.to_json)
+            end
           end
         end
 
+        def handle_elastic_ip_error(env, message) 
+          @logger.debug(message)
+          terminate(env)
+          raise Errors::FogError,
+                          :message => message
+        end
+
         def terminate(env)
           destroy_env = env.dup
           destroy_env.delete(:interrupted)

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

@@ -12,7 +12,11 @@ module VagrantPlugins
         end
 
         def call(env)
-          server = env[:aws_compute].servers.get(env[:machine].id)
+          server         = env[:aws_compute].servers.get(env[:machine].id)
+          region         = env[:machine].provider_config.region
+          region_config  = env[:machine].provider_config.get_region_config(region)
+
+          elastic_ip     = region_config.elastic_ip
 
           # Release the elastic IP
           ip_file = env[:machine].data_dir.join('elastic_ip')

data/lib/vagrant-aws/config.rb

@@ -24,7 +24,12 @@ module VagrantPlugins
       # @return [Fixnum]
       attr_accessor :instance_ready_timeout
 
-      # The type of instance to launch, such as "m1.small"
+      # The timeout to wait for an instance to successfully burn into an AMI.
+      #
+      # @return [Fixnum]
+      attr_accessor :instance_package_timeout
+
+      # The type of instance to launch, such as "m3.medium"
       #
       # @return [String]
       attr_accessor :instance_type
@@ -39,9 +44,10 @@ module VagrantPlugins
       # @return [String]
       attr_accessor :private_ip_address
 
-      # Acquire and attach an elastic IP address (VPC).
+      # If true, acquire and attach an elastic IP address.
+      # If set to an IP address, assign to the instance.
       #
-      # @return [Boolean]
+      # @return [String]
       attr_accessor :elastic_ip
 
       # The name of the AWS region in which to create the instance.
@@ -64,6 +70,11 @@ module VagrantPlugins
       # @return [String]
       attr_accessor :secret_access_key
 
+      # The token associated with the key for accessing AWS.
+      #
+      # @return [String]
+      attr_accessor :session_token
+
       # The security groups to set on the instance. For VPC this must
       # be a list of IDs. For EC2, it can be either.
       #
@@ -145,32 +156,34 @@ module VagrantPlugins
       attr_accessor :elb
 
       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
+        @access_key_id             = UNSET_VALUE
+        @ami                       = UNSET_VALUE
+        @availability_zone         = UNSET_VALUE
+        @instance_ready_timeout    = UNSET_VALUE
+        @instance_package_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
+        @session_token             = 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
-        @elb                    = UNSET_VALUE
+        @terminate_on_shutdown     = UNSET_VALUE
+        @ssh_host_attribute        = UNSET_VALUE
+        @monitoring                = UNSET_VALUE
+        @ebs_optimized             = UNSET_VALUE
+        @associate_public_ip       = UNSET_VALUE
+        @elb                       = UNSET_VALUE
 
         # Internal state (prefix with __ so they aren't automatically
         # merged)
@@ -255,6 +268,7 @@ module VagrantPlugins
         # 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
+        @session_token     = ENV['AWS_SESSION_TOKEN'] if @session_token == UNSET_VALUE
 
         # AMI must be nil, since we can't default that
         @ami = nil if @ami == UNSET_VALUE
@@ -262,8 +276,11 @@ module VagrantPlugins
         # 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
+        # Set the default timeout for waiting for an instance to burn into and ami
+        @instance_package_timeout = 600 if @instance_package_timeout == UNSET_VALUE
+
+        # Default instance type is an m3.medium
+        @instance_type = "m3.medium" if @instance_type == UNSET_VALUE
 
         # Keypair defaults to nil
         @keypair_name = nil if @keypair_name == UNSET_VALUE

data/lib/vagrant-aws/errors.rb

@@ -19,6 +19,14 @@ module VagrantPlugins
         error_key(:instance_ready_timeout)
       end
 
+      class InstancePackageError < VagrantAWSError
+        error_key(:instance_package_error)
+      end
+
+      class InstancePackageTimeout < VagrantAWSError
+        error_key(:instance_package_timeout)
+      end
+
       class RsyncError < VagrantAWSError
         error_key(:rsync_error)
       end

data/lib/vagrant-aws/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module AWS
-    VERSION = "0.5.0"
+    VERSION = '0.6.0'
   end
 end

data/locales/en.yml

@@ -2,6 +2,8 @@ en:
   vagrant_aws:
     already_status: |-
       The machine is already %{status}.
+    burning_ami: |-
+      Waiting for the AMI '%{ami_id}' to burn...
     elb:
       adjusting: |-
         Adjusting availability zones of ELB %{elb_name}...
@@ -26,6 +28,10 @@ en:
       to SSH into it.
     not_created: |-
       Instance is not created. Please run `vagrant up` first.
+    packaging_instance: |-
+      Burning instance %{instance_id} into an ami
+    packaging_instance_complete: |-
+      Burn was successful in %{time_seconds}s
     ready: |-
       Machine is booted and ready for use!
     rsync_not_found_warning: |-
@@ -85,6 +91,17 @@ en:
         set waiting for the instance to become ready is %{timeout} seconds.
         Please verify that the machine properly boots. If you need more time
         set the `instance_ready_timeout` configuration on the AWS provider.
+      instance_package_error: |-
+        There was an error packaging the instance. See details below for more info.
+
+        AMI Id: %{ami_id}
+        Error: %{err}
+      instance_package_timeout: |-
+        The AMI failed to become "ready" in AWS. The timeout currently
+        set waiting for the instance to become ready is %{timeout} seconds. For 
+        larger instances AMI burning may take long periods of time. Please
+        ensure the timeout is set high enough, it can be changed by adjusting
+        the `instance_package_timeout` configuration on the AWS provider.
       rsync_error: |-
         There was an error when attempting to rsync a shared folder.
         Please inspect the error message below for more info.

data/spec/vagrant-aws/config_spec.rb

@@ -19,11 +19,13 @@ describe VagrantPlugins::AWS::Config do
     its("ami")               { should be_nil }
     its("availability_zone") { should be_nil }
     its("instance_ready_timeout") { should == 120 }
-    its("instance_type")     { should == "m1.small" }
+    its("instance_package_timeout") { should == 600 }
+    its("instance_type")     { should == "m3.medium" }
     its("keypair_name")      { should be_nil }
     its("private_ip_address") { should be_nil }
     its("region")            { should == "us-east-1" }
     its("secret_access_key") { should be_nil }
+    its("session_token") { should be_nil }
     its("security_groups")   { should == [] }
     its("subnet_id")         { should be_nil }
     its("iam_instance_profile_arn") { should be_nil }
@@ -46,9 +48,9 @@ describe VagrantPlugins::AWS::Config do
     # each of these attributes to "foo" in isolation, and reads the value
     # and asserts the proper result comes back out.
     [:access_key_id, :ami, :availability_zone, :instance_ready_timeout,
-      :instance_type, :keypair_name, :ssh_host_attribute, :ebs_optimized,
-      :region, :secret_access_key, :monitoring, :associate_public_ip,
-      :subnet_id, :tags, :elastic_ip, :terminate_on_shutdown,
+      :instance_package_timeout, :instance_type, :keypair_name, :ssh_host_attribute,
+      :ebs_optimized, :region, :secret_access_key, :session_token, :monitoring,
+      :associate_public_ip, :subnet_id, :tags, :elastic_ip, :terminate_on_shutdown,
       :iam_instance_profile_arn, :iam_instance_profile_name,
       :use_iam_profile, :user_data, :block_device_mapping].each do |attribute|
 
@@ -75,12 +77,14 @@ describe VagrantPlugins::AWS::Config do
 
       its("access_key_id")     { should be_nil }
       its("secret_access_key") { should be_nil }
+      its("session_token")     { should be_nil }
     end
 
     context "with EC2 credential environment variables" do
       before :each do
         ENV.stub(:[]).with("AWS_ACCESS_KEY").and_return("access_key")
         ENV.stub(:[]).with("AWS_SECRET_KEY").and_return("secret_key")
+        ENV.stub(:[]).with("AWS_SESSION_TOKEN").and_return("session_token")
       end
 
       subject do
@@ -91,6 +95,7 @@ describe VagrantPlugins::AWS::Config do
 
       its("access_key_id")     { should == "access_key" }
       its("secret_access_key") { should == "secret_key" }
+      its("session_token")     { should == "session_token" }
     end
   end
 
@@ -101,6 +106,7 @@ describe VagrantPlugins::AWS::Config do
     let(:config_keypair_name)      { "foo" }
     let(:config_region)            { "foo" }
     let(:config_secret_access_key) { "foo" }
+    let(:config_session_token)     { "foo" }
 
     def set_test_values(instance)
       instance.access_key_id     = config_access_key_id
@@ -109,6 +115,7 @@ describe VagrantPlugins::AWS::Config do
       instance.keypair_name      = config_keypair_name
       instance.region            = config_region
       instance.secret_access_key = config_secret_access_key
+      instance.session_token     = config_session_token
     end
 
     it "should raise an exception if not finalized" do
@@ -134,6 +141,7 @@ describe VagrantPlugins::AWS::Config do
       its("keypair_name")      { should == config_keypair_name }
       its("region")            { should == config_region }
       its("secret_access_key") { should == config_secret_access_key }
+      its("session_token")     { should == config_session_token }
     end
 
     context "with a specific config set" do
@@ -158,6 +166,7 @@ describe VagrantPlugins::AWS::Config do
       its("keypair_name")      { should == config_keypair_name }
       its("region")            { should == region_name }
       its("secret_access_key") { should == config_secret_access_key }
+      its("session_token")     { should == config_session_token }
     end
 
     describe "inheritance of parent config" do

data/templates/metadata.json.erb

@@ -0,0 +1,3 @@
+{
+    "provider": "aws"
+}

data/templates/vagrant-aws_package_Vagrantfile.erb

@@ -0,0 +1,5 @@
+Vagrant.configure("2") do |config|
+  config.vm.provider "aws" do |aws|
+	aws.region_config "<%= region %>", ami: "<%= ami %>"
+  end
+end

data/vagrant-aws.gemspec

@@ -18,9 +18,8 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "fog", "~> 1.22"
 
   s.add_development_dependency "rake"
-  s.add_development_dependency "rspec-core", "~> 2.12.2"
-  s.add_development_dependency "rspec-expectations", "~> 2.12.1"
-  s.add_development_dependency "rspec-mocks", "~> 2.12.1"
+  s.add_development_dependency "rspec", "~> 2.12"
+  s.add_development_dependency "rspec-its"
 
   # The following block of code determines the files that should be included
   # in the gem. It does this by reading all the files in the directory where

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-aws
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Mitchell Hashimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-22 00:00:00.000000000 Z
+date: 2014-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -39,47 +39,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-core
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.2
+        version: '2.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.2
+        version: '2.12'
 - !ruby/object:Gem::Dependency
-  name: rspec-expectations
+  name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.12.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.12.1
-- !ruby/object:Gem::Dependency
-  name: rspec-mocks
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.12.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.12.1
+        version: '0'
 description: Enables Vagrant to manage machines in EC2 and VPC.
 email: mitchell@hashicorp.com
 executables: []
@@ -98,7 +84,6 @@ files:
 - example_box/metadata.json
 - lib/vagrant-aws.rb
 - lib/vagrant-aws/action.rb
-- lib/vagrant-aws/action/.sync_folders.rb.swp
 - lib/vagrant-aws/action/connect_aws.rb
 - lib/vagrant-aws/action/elb_deregister_instance.rb
 - lib/vagrant-aws/action/elb_register_instance.rb
@@ -107,12 +92,12 @@ files:
 - lib/vagrant-aws/action/message_already_created.rb
 - lib/vagrant-aws/action/message_not_created.rb
 - lib/vagrant-aws/action/message_will_not_destroy.rb
+- lib/vagrant-aws/action/package_instance.rb
 - lib/vagrant-aws/action/read_ssh_info.rb
 - lib/vagrant-aws/action/read_state.rb
 - lib/vagrant-aws/action/run_instance.rb
 - lib/vagrant-aws/action/start_instance.rb
 - lib/vagrant-aws/action/stop_instance.rb
-- lib/vagrant-aws/action/sync_folders.rb
 - lib/vagrant-aws/action/terminate_instance.rb
 - lib/vagrant-aws/action/timed_provision.rb
 - lib/vagrant-aws/action/wait_for_state.rb
@@ -126,9 +111,9 @@ files:
 - lib/vagrant-aws/version.rb
 - locales/en.yml
 - spec/spec_helper.rb
-- spec/vagrant-aws/actions/.syncfolders_spec.rb.swp
-- spec/vagrant-aws/actions/syncfolders_spec.rb
 - spec/vagrant-aws/config_spec.rb
+- templates/metadata.json.erb
+- templates/vagrant-aws_package_Vagrantfile.erb
 - vagrant-aws.gemspec
 homepage: http://www.vagrantup.com
 licenses:
@@ -150,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: vagrant-aws
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Enables Vagrant to manage machines in EC2 and VPC.

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

@@ -1,130 +0,0 @@
-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", "--delete",
-              *excludes.map{|e|['--exclude', e]}.flatten,
-              "-e", "ssh -p #{ssh_info[:port]} #{ssh_key_options(ssh_info)} " + 
-              ssh_options_to_args(ssh_options).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
-
-        # Generate a ssh(1) command line list of options
-        #
-        # @param [Array] options An array of ssh options. E.g.
-        #   `StrictHostKeyChecking=no` see ssh_config(5) for more
-        # @return [Array] Computed list of command line arguments
-        def ssh_options_to_args(options)
-          # Bail early if we get something that is not an array of options
-          return [] unless options
-
-          return options.map { |o| "-o '#{o}'" }
-        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/spec/vagrant-aws/actions/syncfolders_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'vagrant-aws/action/sync_folders'
-
-describe VagrantPlugins::AWS::Action::SyncFolders do
-  let(:app) { nil }
-  let(:env) { {} }
-  subject(:action) { described_class.new(app, env) }
-
-  describe '#ssh_options_to_args' do
-    subject(:args) { action.ssh_options_to_args(options) }
-
-    context 'with no ssh options' do
-      let(:options) { [] }
-
-      it { should eql [] }
-    end
-
-    context 'with one option' do
-      let(:options) { ['StrictHostKeyChecking=no'] }
-      it { should eql ["-o 'StrictHostKeyChecking=no'"] }
-    end
-
-    context 'with multiple options' do
-      let(:options) { ['SHKC=no', 'Port=222'] }
-      it { should eql ["-o 'SHKC=no'", "-o 'Port=222'"] }
-    end
-  end
-end