chef-provisioning-aws 1.0.4 → 1.1.0

data/lib/chef/provisioning/aws_driver/aws_resource.rb

@@ -5,7 +5,7 @@ require 'chef/provisioning/chef_managed_entry_store'
 # Common AWS resource - contains metadata that all AWS resources will need
 module Chef::Provisioning::AWSDriver
 class AWSResource < Chef::Provisioning::AWSDriver::SuperLWRP
-  actions :create, :destroy, :nothing
+  actions :create, :destroy, :purge, :nothing
   default_action :create
 
   def initialize(name, run_context=nil)

data/lib/chef/provisioning/aws_driver/driver.rb

@@ -54,6 +54,8 @@ module AWSDriver
         access_key_id:     credentials[:aws_access_key_id],
         secret_access_key: credentials[:aws_secret_access_key],
         region: region || credentials[:region],
+        proxy_uri: credentials[:proxy_uri] || nil,
+        session_token: credentials[:aws_session_token] || nil,
         logger: Chef::Log.logger
       )
     end
@@ -331,6 +333,7 @@ module AWSDriver
           image_options[:description] ||= "Image #{image_spec.name} created from machine #{machine_spec.name}"
           Chef::Log.debug "AWS Image options: #{image_options.inspect}"
           image = ec2.images.create(image_options.to_hash)
+          image.add_tag('From-Instance', :value => image_options[:instance_id]) if image_options[:instance_id]
           image_spec.reference = {
             'driver_url' => driver_url,
             'driver_version' => Chef::Provisioning::AWSDriver::VERSION,
@@ -428,9 +431,7 @@ EOD
     end
 
     def allocate_machines(action_handler, specs_and_options, parallelizer)
-      #Chef::Log.warn("#{specs_and_options}")
       create_servers(action_handler, specs_and_options, parallelizer) do |machine_spec, server|
-    #Chef::Log.warn("#{machine_spec}")
         yield machine_spec
       end
       specs_and_options.keys
@@ -812,7 +813,7 @@ EOD
       image ||= image_for(image_spec)
       time_elapsed = 0
       sleep_time = 10
-      max_wait_time = 120
+      max_wait_time = 300
       if !yield(image)
         action_handler.report_progress "waiting for #{image_spec.name} (#{image.id} on #{driver_url}) to be ready ..."
         while time_elapsed < max_wait_time && !yield(image)
@@ -821,7 +822,7 @@ EOD
           time_elapsed += sleep_time
         end
         unless yield(image)
-          raise "Image #{image.id} did not become ready within 120 seconds"
+          raise "Image #{image.id} did not become ready within #{max_wait_time} seconds"
         end
         action_handler.report_progress "Image #{image_spec.name} is now ready"
       end
@@ -845,7 +846,7 @@ EOD
             time_elapsed += sleep_time
           end
           unless yield(instance)
-            raise "Image #{instance.id} did not become ready within 120 seconds"
+            raise "Image #{instance.id} did not become ready within #{max_wait_time} seconds"
           end
           action_handler.report_progress "#{machine_spec.name} is now ready"
         end

data/lib/chef/provisioning/aws_driver/version.rb

@@ -1,7 +1,7 @@
 class Chef
 module Provisioning
 module AWSDriver
-  VERSION = '1.0.4'
+  VERSION = '1.1.0'
 end
 end
 end

data/lib/chef/resource/aws_image.rb

@@ -3,8 +3,7 @@ require 'chef/provisioning/aws_driver/aws_resource_with_entry'
 class Chef::Resource::AwsImage < Chef::Provisioning::AWSDriver::AWSResourceWithEntry
   aws_sdk_type AWS::EC2::Image,
                managed_entry_type:    :machine_image,
-               managed_entry_id_name: 'image_id',
-               load_provider:         false
+               managed_entry_id_name: 'image_id'
 
   attribute :name, kind_of: String,  name_attribute: true
 

data/lib/chef/resource/aws_instance.rb

@@ -3,8 +3,7 @@ require 'chef/provisioning/aws_driver/aws_resource_with_entry'
 class Chef::Resource::AwsInstance < Chef::Provisioning::AWSDriver::AWSResourceWithEntry
   aws_sdk_type AWS::EC2::Instance,
     managed_entry_type: :machine,
-    managed_entry_id_name: 'instance_id',
-    load_provider: false
+    managed_entry_id_name: 'instance_id'
 
   attribute :name, kind_of: String, name_attribute: true
 

data/lib/chef/resource/aws_load_balancer.rb

@@ -1,7 +1,7 @@
 require 'chef/provisioning/aws_driver/aws_resource'
 
 class Chef::Resource::AwsLoadBalancer < Chef::Provisioning::AWSDriver::AWSResource
-  aws_sdk_type AWS::ELB::LoadBalancer, load_provider: false
+  aws_sdk_type AWS::ELB::LoadBalancer
 
   attribute :name, kind_of: String,  name_attribute: true
 

data/lib/chef/resource/aws_network_interface.rb

@@ -1,16 +1,34 @@
 require 'chef/provisioning/aws_driver/aws_resource'
+require 'chef/resource/aws_subnet'
+require 'chef/resource/aws_eip_address'
 
-class Chef::Resource::AwsNetworkInterface < Chef::Provisioning::AWSDriver::AWSResource
-  aws_sdk_type AWS::EC2::NetworkInterface, load_provider: false, id: :id
+class Chef::Resource::AwsNetworkInterface < Chef::Provisioning::AWSDriver::AWSResourceWithEntry
+  aws_sdk_type AWS::EC2::NetworkInterface
 
-  attribute :name, kind_of: String, name_attribute: true
+  attribute :name,                   kind_of: String, name_attribute: true
 
-  attribute :network_interface_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+  attribute :network_interface_id,   kind_of: String, aws_id_attribute: true, lazy_default: proc {
     name =~ /^eni-[a-f0-9]{8}$/ ? name : nil
   }
 
+  attribute :subnet,                 kind_of: [ String, AWS::EC2::Subnet, AwsSubnet ]
+
+  attribute :private_ip_address,     kind_of: String
+
+  attribute :description,            kind_of: String
+
+  attribute :security_groups,        kind_of: Array #(Array<SecurityGroup>, Array<String>)
+
+  attribute :machine,                kind_of: [ String, FalseClass, AwsInstance, AWS::EC2::Instance ]
+
+  attribute :device_index,           kind_of: Integer
+
+  # TODO implement eip address association
+  #attribute :elastic_ip_address,     kind_of: [ String, AWS::EC2::ElasticIp, AwsEipAddress, FalseClass ]
+
   def aws_object
-    result = driver.ec2.network_interfaces[network_interface_id]
+    driver, id = get_driver_and_id
+    result = driver.ec2.network_interfaces[id] if id
     result && result.exists? ? result : nil
   end
 end

data/lib/chef/resource/aws_vpc.rb

@@ -125,14 +125,6 @@ class Chef::Resource::AwsVpc < Chef::Provisioning::AWSDriver::AWSResourceWithEnt
   #
   attribute :enable_dns_hostnames, equal_to: [ true, false ]
 
-  #
-  # A list of tags to put on the VPC.
-  #
-  # The "Name" tag will always be set to the Chef name of the instance if you do
-  # not specify it.
-  #
-  attribute :tags, kind_of: Array
-
   attribute :vpc_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
     name =~ /^vpc-[a-f0-9]{8}$/ ? name : nil
   }

data/spec/aws_support.rb

@@ -0,0 +1,235 @@
+#
+# Provides a `with_aws` method that when used in your tests will create a new
+# context pointed at the user's chosen driver, and helper methods to create
+# AWS objects and clean them up.
+#
+module AWSSupport
+  require 'cheffish/rspec/chef_run_support'
+  def self.extended(other)
+    other.extend Cheffish::RSpec::ChefRunSupport
+  end
+
+  require 'chef/provisioning/aws_driver'
+  require 'aws_support/matchers/create_an_aws_object'
+  require 'aws_support/matchers/update_an_aws_object'
+  require 'aws_support/delayed_stream'
+  require 'chef/provisioning/aws_driver/resources'
+  require 'aws_support/aws_resource_run_wrapper'
+
+  # Add AWS to the list of objects which can be matched against a Hash or Array
+  require 'aws'
+  require 'aws_support/deep_matcher/matchable_object'
+  require 'aws_support/deep_matcher/matchable_array'
+  DeepMatcher::MatchableObject.matchable_classes << proc { |o| o.class.name =~ /^AWS::EC2($|::)/ }
+  DeepMatcher::MatchableArray.matchable_classes  << AWS::Core::Data::List
+
+  def purge_all
+    before :all do
+      driver = self.driver
+      recipe do
+        driver.ec2.vpcs.with_tag('Name', 'test_vpc').each do |vpc|
+          aws_vpc vpc do
+            action :purge
+          end
+        end
+        aws_key_pair 'test_key_pair' do
+          action :purge
+        end
+      end.converge
+    end
+  end
+
+  def setup_public_vpc
+    aws_vpc 'test_vpc' do
+      cidr_block '10.0.0.0/24'
+      internet_gateway true
+      enable_dns_hostnames true
+      main_routes '0.0.0.0/0' => :internet_gateway
+    end
+
+    aws_key_pair 'test_key_pair' do
+      allow_overwrite true
+    end
+
+    before :context do
+      image = driver.ec2.images.filter('name', 'test_machine_image').first
+      image.delete if image
+
+      default_sg = test_vpc.aws_object.security_groups.filter('group-name', 'default').first
+      recipe do
+        aws_security_group default_sg do
+          inbound_rules '0.0.0.0/0' => 22
+        end
+      end.converge
+    end
+
+    aws_subnet 'test_public_subnet' do
+      vpc 'test_vpc'
+      map_public_ip_on_launch true
+    end
+  end
+
+  def with_aws(description, *tags, &block)
+    aws_driver = nil
+    context_block = proc do
+      extend WithAWSClassMethods
+      include WithAWSInstanceMethods
+
+      @@driver = aws_driver
+      def self.driver
+        @@driver
+      end
+
+      module_eval(&block)
+    end
+
+    if ENV['AWS_TEST_DRIVER']
+      aws_driver = Chef::Provisioning.driver_for_url(ENV['AWS_TEST_DRIVER'])
+      when_the_repository "exists #{description ? "and #{description}" : ""}", *tags, &context_block
+    else
+#       warn <<EOM
+# --------------------------------------------------------------------------------------------------------------------------
+# AWS_TEST_DRIVER not set ... cannot run AWS test.  Set AWS_TEST_DRIVER=aws or aws:profile:region to run tests that hit AWS.
+# --------------------------------------------------------------------------------------------------------------------------
+# EOM
+      skip "AWS_TEST_DRIVER not set ... cannot run AWS tests.  Set AWS_TEST_DRIVER=aws or aws:profile:region to run tests that hit AWS." do
+        context description, *tags, &context_block
+      end
+    end
+  end
+
+  module WithAWSClassMethods
+    instance_eval do
+      #
+      # Create a context-level method for each AWS resource:
+      #
+      # with_aws do
+      #   context 'mycontext' do
+      #     aws_vpc 'myvpc' do
+      #       ...
+      #     end
+      #   end
+      # end
+      #
+      # Creates the AWS thing when the first example in the context runs.
+      # Destroys it after the last example in the context runs.  Objects created
+      # in the order declared, and destroyed in reverse order.
+      #
+      Chef::Provisioning::AWSDriver::Resources.constants.each do |resource_class|
+        resource_class = Chef::Provisioning::AWSDriver::Resources.const_get(resource_class)
+        resource_name = resource_class.resource_name
+        # def aws_vpc(name, &block)
+        define_method(resource_name) do |name, &block|
+          # def myvpc
+          #   @@myvpc
+          # end
+          instance_eval do
+            define_method(name) { class_variable_get(:"@@#{name}") }
+          end
+          module_eval do
+            define_method(name) { self.class.class_variable_get(:"@@#{name}") }
+          end
+
+          resource = nil
+
+          before :context do
+            resource = AWSResourceRunWrapper.new(self, resource_name, name, &block)
+            # @myvpc = resource
+            begin
+              self.class.class_variable_set(:"@@#{name}", resource.resource)
+            rescue NameError
+            end
+            begin
+              resource.converge
+            rescue
+              puts "ERROR #{$!}"
+              puts $!.backtrace.join("\n")
+              raise
+            end
+          end
+
+          after :context do
+            resource.destroy if resource
+          end
+        end
+      end
+    end
+  end
+
+  module WithAWSInstanceMethods
+    def self.included(context)
+      context.module_eval do
+        after :example do
+          # Close up delayed streams so they don't print out their garbage later in the run
+          delayed_streams.each { |s| s.close }
+
+          # Destroy any objects we know got created during the test
+          created_during_test.reverse_each do |resource_name, name|
+            (recipe do
+              public_send(resource_name, name) do
+                action :purge
+              end
+            end).converge
+          end
+        end
+      end
+    end
+
+    #
+    # expect_recipe { }.to create_an_aws_vpc
+    # expect_recipe { }.to update_an_aws_security_object
+    #
+    Chef::Provisioning::AWSDriver::Resources.constants.each do |resource_class|
+      resource_class = Chef::Provisioning::AWSDriver::Resources.const_get(resource_class)
+      resource_name = resource_class.resource_name
+      define_method("update_an_#{resource_name}") do |name, expected_updates={}|
+        AWSSupport::Matchers::UpdateAnAWSObject.new(self, resource_class, name, expected_updates)
+      end
+      define_method("create_an_#{resource_name}") do |name, expected_values={}|
+        AWSSupport::Matchers::CreateAnAWSObject.new(self, resource_class, name, expected_values)
+      end
+    end
+
+    def chef_config
+      @chef_config ||= {
+        driver:       driver,
+        stdout:       delayed_stream(delay_before_streaming, STDOUT),
+        stderr:       delayed_stream(delay_before_streaming, STDERR),
+        log_location: delayed_stream(delay_before_streaming_logs, STDOUT),
+        log_level:    :info
+      }
+    end
+
+    def delayed_streams
+      @delayed_streams ||= []
+    end
+
+    def delayed_stream(delay, stream)
+      stream = DelayedStream.new(delay, stream)
+      delayed_streams << stream
+      stream
+    end
+
+    # Override in tests if you want different numbers
+    def delay_before_streaming_logs
+      30
+    end
+
+    def delay_before_streaming
+      10
+    end
+
+    def created_during_test
+      @created_during_test ||= []
+    end
+
+    def default_vpc
+      @default_vpc ||= driver.ec2.vpcs.filter('isDefault', 'true').first
+    end
+
+    def driver
+      self.class.driver
+    end
+  end
+
+end

data/spec/aws_support/aws_resource_run_wrapper.rb

@@ -0,0 +1,45 @@
+require 'cheffish/rspec/recipe_run_wrapper'
+
+module AWSSupport
+  class AWSResourceRunWrapper < Cheffish::RSpec::RecipeRunWrapper
+    def initialize(example, resource_type, name, &properties)
+      super(example.chef_config) do
+        if properties && properties.parameters.size > 0
+          public_send(resource_type, name) { instance_exec(example, &properties) }
+        else
+          public_send(resource_type, name, &properties)
+        end
+      end
+      @example = example
+      @resource_type = resource_type
+      @name = name
+      @properties = properties
+    end
+
+    attr_reader :example
+    attr_reader :resource_type
+    attr_reader :name
+
+    def resource
+      resources.first
+    end
+
+    def to_s
+      "#{resource_type}[#{name}]"
+    end
+
+    def destroy
+      resource_type = self.resource_type
+      name = self.name
+      example.recipe do
+        public_send(resource_type, name) do
+          action :purge
+        end
+      end.converge
+    end
+
+    def aws_object
+      resource.aws_object
+    end
+  end
+end

data/spec/aws_support/deep_matcher.rb

@@ -0,0 +1,40 @@
+module AWSSupport
+  #
+  # Include this and override `match_failure_messages`, and your class becomes
+  # a matcher which will have `matches?` call `match_failure_messages` and
+  # cache the result, which is then returned verbatim from failure_message.
+  #
+  module DeepMatcher
+
+    require 'aws_support/deep_matcher/match_values_failure_messages'
+
+    include MatchValuesFailureMessages
+
+    def matches?(actual)
+      @failure_messages = match_failure_messages(actual)
+      @failure_messages.empty?
+    end
+
+    def failure_message
+      @failure_messages.flat_map { |message| message.split("\n") }.join("\n")
+    end
+
+    def failure_message_when_negated
+      "expected #{@actual.inspect} not to #{description}"
+    end
+
+    #
+    # Return the failure message resulting from matching `actual`.  Meant to be
+    # overridden in implementors.
+    #
+    # @param actual The actual value to compare against
+    # @param identifier The name of the thing being compared (may not be passed,
+    #                   in which case the class will choose an appropriate default.)
+    #
+    # @return A failure message, or empty string if it does not fail.
+    #
+    def match_failure_messages(actual, identifier='value')
+      raise NotImplementedError, :match_failure_messages
+    end
+  end
+end