chef-provisioning-aws 1.3.1 → 1.4.0

data/lib/chef/provider/aws_dhcp_options.rb

@@ -1,7 +1,10 @@
 require 'chef/provisioning/aws_driver/aws_provider'
-require 'retryable'
 
 class Chef::Provider::AwsDhcpOptions < Chef::Provisioning::AWSDriver::AWSProvider
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::EC2ConvergeTags
+
+  provides :aws_dhcp_options
+
   protected
 
   def create_aws_object
@@ -10,7 +13,7 @@ class Chef::Provider::AwsDhcpOptions < Chef::Provisioning::AWSDriver::AWSProvide
       options[:domain_name_servers] = "AmazonProvidedDNS"
     end
 
-    converge_by "create new dhcp_options #{new_resource.name} in #{region}" do
+    converge_by "create DHCP options #{new_resource.name} in #{region}" do
       dhcp_options = new_resource.driver.ec2.dhcp_options.create(options)
       retry_with_backoff(AWS::EC2::Errors::InvalidDhcpOptionsID::NotFound) do
         dhcp_options.tags['Name'] = new_resource.name
@@ -35,17 +38,17 @@ class Chef::Provider::AwsDhcpOptions < Chef::Provisioning::AWSDriver::AWSProvide
       if action_handler.should_perform_actions
         dhcp_options = AWS.ec2(config: dhcp_options.config).dhcp_options.create(config.merge(desired_options))
       end
-      action_handler.report_progress "create new dhcp_options #{dhcp_options.id} with new attributes in #{region}"
+      action_handler.report_progress "create DHCP options #{dhcp_options.id} with new attributes in #{region}"
 
       # attach dhcp_options to existing vpcs
       old_dhcp_options.vpcs.each do |vpc|
-        action_handler.perform_action "attach new dhcp_options #{dhcp_options.id} to vpc #{vpc.id}" do
+        action_handler.perform_action "attach DHCP options #{dhcp_options.id} to vpc #{vpc.id}" do
           vpc.dhcp_options = dhcp_options
         end
       end
 
       # delete old dhcp_options
-      action_handler.perform_action "delete old dhcp_options #{old_dhcp_options.id}" do
+      action_handler.perform_action "delete DHCP options #{old_dhcp_options.id}" do
         old_dhcp_options.delete
       end
 
@@ -54,7 +57,7 @@ class Chef::Provider::AwsDhcpOptions < Chef::Provisioning::AWSDriver::AWSProvide
   end
 
   def destroy_aws_object(dhcp_options)
-    converge_by "delete dhcp_options #{new_resource.name} in #{region}" do
+    converge_by "delete DHCP options #{new_resource.name} in #{region}" do
       dhcp_options.delete
     end
   end

data/lib/chef/provider/aws_ebs_volume.rb

@@ -4,6 +4,10 @@ require 'date'
 require 'retryable'
 
 class Chef::Provider::AwsEbsVolume < Chef::Provisioning::AWSDriver::AWSProvider
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::EC2ConvergeTags
+
+  provides :aws_ebs_volume
+
   class VolumeNotFoundError < RuntimeError
     def initialize(new_resource)
       super("#{new_resource} does not exist!")
@@ -34,7 +38,7 @@ class Chef::Provider::AwsEbsVolume < Chef::Provisioning::AWSDriver::AWSProvider
 
   def create_aws_object
     volume = nil
-    converge_by "create new #{new_resource} in #{region}" do
+    converge_by "create #{new_resource} in #{region}" do
       volume = new_resource.driver.ec2.volumes.create(initial_options)
       retry_with_backoff(AWS::EC2::Errors::InvalidVolumeID::NotFound) do
         volume.tags['Name'] = new_resource.name
@@ -119,12 +123,12 @@ class Chef::Provider::AwsEbsVolume < Chef::Provisioning::AWSDriver::AWSProvider
     #
     # If we were told to attach the volume to a machine, do so
     #
-    if expected_instance.is_a?(AWS::EC2::Instance)
+    if expected_instance.is_a?(AWS::EC2::Instance) || expected_instance.is_a?(::Aws::EC2::Instance)
       case status
       when :in_use
         # We don't want to attempt to reattach to the same instance and device
         attachment = current_attachment(volume)
-        if attachment.instance != expected_instance || attachment.device != new_resource.device
+        if attachment.instance.id != expected_instance.id || attachment.device != new_resource.device
           detach(volume)
           attach(volume)
         end

data/lib/chef/provider/aws_eip_address.rb

@@ -4,6 +4,7 @@ require 'chef/provisioning/machine_spec'
 require 'cheffish'
 
 class Chef::Provider::AwsEipAddress < Chef::Provisioning::AWSDriver::AWSProvider
+  provides :aws_eip_address
 
   def action_create
     elastic_ip = super
@@ -16,10 +17,10 @@ class Chef::Provider::AwsEipAddress < Chef::Provisioning::AWSDriver::AWSProvider
   protected
 
   def create_aws_object
-    converge_by "create new EIP address in #{region}" do
+    converge_by "create Elastic IP address in #{region}" do
       associate_to_vpc = new_resource.associate_to_vpc
       if associate_to_vpc.nil?
-        if desired_instance.is_a?(AWS::EC2::Instance)
+        if desired_instance.is_a?(AWS::EC2::Instance) || desired_instance.is_a?(::Aws::EC2::Instance)
           associate_to_vpc = !!desired_instance.vpc_id
           Chef::Log.debug "Since associate_to_vpc is not specified and instance #{new_resource.machine} (#{desired_instance.id}) and #{associate_to_vpc ? "is" : "is not"} in a VPC, setting associate_to_vpc to #{associate_to_vpc}."
         end
@@ -39,11 +40,11 @@ class Chef::Provider::AwsEipAddress < Chef::Provisioning::AWSDriver::AWSProvider
   def destroy_aws_object(elastic_ip)
     #if it's attached to something in a vpc, disassociate first
     if elastic_ip.instance_id != nil && elastic_ip.domain == 'vpc'
-      converge_by "dissociate Elastic IP Address #{new_resource.name} (#{elastic_ip.public_ip}) from #{elastic_ip.instance_id}" do
+      converge_by "dissociate Elastic IP address #{new_resource.name} (#{elastic_ip.public_ip}) from #{elastic_ip.instance_id}" do
         elastic_ip.disassociate
       end
     end
-    converge_by "delete Elastic IP Address #{new_resource.name} (#{elastic_ip.public_ip}) in #{region}" do
+    converge_by "delete Elastic IP address #{new_resource.name} (#{elastic_ip.public_ip}) in #{region}" do
       elastic_ip.delete
     end
   end
@@ -65,9 +66,9 @@ class Chef::Provider::AwsEipAddress < Chef::Provisioning::AWSDriver::AWSProvider
     #
     # If we were told to associate the IP to a machine, do so
     #
-    if desired_instance.is_a?(AWS::EC2::Instance)
+    if desired_instance.is_a?(AWS::EC2::Instance) || desired_instance.is_a?(::Aws::EC2::Instance)
       if desired_instance.id != elastic_ip.instance_id
-        converge_by "associate Elastic IP Address #{new_resource.name} (#{elastic_ip.public_ip}) with #{new_resource.machine} (#{desired_instance.id})" do
+        converge_by "associate Elastic IP address #{new_resource.name} (#{elastic_ip.public_ip}) with #{new_resource.machine} (#{desired_instance.id})" do
           elastic_ip.associate instance: desired_instance.id
         end
       end
@@ -77,7 +78,7 @@ class Chef::Provider::AwsEipAddress < Chef::Provisioning::AWSDriver::AWSProvider
     #
     else
       if elastic_ip.associated?
-        converge_by "disassociate Elastic IP Address #{new_resource.name} (#{elastic_ip.public_ip}) from #{elastic_ip.instance_id} in #{region}" do
+        converge_by "disassociate Elastic IP address #{new_resource.name} (#{elastic_ip.public_ip}) from #{elastic_ip.instance_id} in #{region}" do
           aws_object.disassociate
         end
       end

data/lib/chef/provider/aws_image.rb

@@ -1,13 +1,18 @@
 require 'chef/provisioning/aws_driver/aws_provider'
+require 'chef/provisioning/aws_driver/tagging_strategy/ec2'
 
 class Chef::Provider::AwsImage < Chef::Provisioning::AWSDriver::AWSProvider
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::EC2ConvergeTags
+
+  provides :aws_image
+
   def destroy_aws_object(image)
-    instance_id = image.tags['From-Instance']
-    Chef::Log.debug("Found From-Instance tag [#{instance_id}] on #{image.id}")
+    instance_id = image.tags['from-instance']
+    Chef::Log.debug("Found from-instance tag [#{instance_id}] on #{image.id}")
     unless instance_id
       # This is an old image and doesn't have the tag added - lets try and find it from the block device mapping
       image.block_device_mappings.map do |dev, opts|
-        snapshot = ec2.snapshots[opts[:snapshot_id]]
+        snapshot = new_resource.driver.ec2.snapshots[opts[:snapshot_id]]
         desc = snapshot.description
         m = /CreateImage\(([^\)]+)\)/.match(desc)
         if m

data/lib/chef/provider/aws_instance.rb

@@ -1,6 +1,11 @@
 require 'chef/provisioning/aws_driver/aws_provider'
+require 'chef/provisioning/aws_driver/tagging_strategy/ec2'
 
 class Chef::Provider::AwsInstance < Chef::Provisioning::AWSDriver::AWSProvider
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::EC2ConvergeTags
+
+  provides :aws_instance
+
   def create_aws_object(instance); end
 
   def update_aws_object(instance); end
@@ -10,12 +15,19 @@ class Chef::Provider::AwsInstance < Chef::Provisioning::AWSDriver::AWSProvider
     message += " in VPC #{instance.vpc.id}" unless instance.vpc.nil?
     message += " in #{region}"
     converge_by message do
-      instance.delete
+      instance.terminate
     end
     converge_by "waited until instance #{new_resource} is :terminated" do
       # When purging, we must wait until the instance is fully terminated - thats the only way
       # to delete the network interface that I can see
-      wait_for_status(instance, :terminated, [AWS::EC2::Errors::InvalidInstanceID::NotFound])
+      instance.wait_until_terminated do |w|
+        # TODO look at `wait_for_status` - delay and max_attempts should be configurable
+        w.delay = 5
+        w.max_attempts = 60
+        w.before_wait do |attempts, response|
+          action_handler.report_progress "waited #{(attempts-1)*5}/#{60*5}s for #{instance.id} status to terminate..."
+        end
+      end
     end
   end
 end

data/lib/chef/provider/aws_key_pair.rb

@@ -4,7 +4,8 @@ require 'aws-sdk-v1'
 
 
 class Chef::Provider::AwsKeyPair < Chef::Provisioning::AWSDriver::AWSProvider
-
+  provides :aws_key_pair
+  
   action :create do
     create_key(:create)
   end

data/lib/chef/provider/aws_launch_configuration.rb

@@ -2,6 +2,8 @@ require 'chef/provisioning/aws_driver/aws_provider'
 require 'chef/resource/aws_image'
 
 class Chef::Provider::AwsLaunchConfiguration < Chef::Provisioning::AWSDriver::AWSProvider
+  provides :aws_launch_configuration
+
   protected
 
   def create_aws_object
@@ -9,7 +11,7 @@ class Chef::Provider::AwsLaunchConfiguration < Chef::Provisioning::AWSDriver::AW
     instance_type = new_resource.instance_type || new_resource.driver.default_instance_type
     options = AWSResource.lookup_options(new_resource.options || options, resource: new_resource)
 
-    converge_by "Creating new Launch Configuration #{new_resource.name} in #{region}" do
+    converge_by "create launch configuration #{new_resource.name} in #{region}" do
       new_resource.driver.auto_scaling.launch_configurations.create(
         new_resource.name,
         image,
@@ -35,7 +37,7 @@ class Chef::Provider::AwsLaunchConfiguration < Chef::Provisioning::AWSDriver::AW
   end
 
   def destroy_aws_object(launch_configuration)
-    converge_by "delete Launch Configuration #{new_resource.name} in #{region}" do
+    converge_by "delete launch configuration #{new_resource.name} in #{region}" do
       # TODO add a timeout here.
       # TODO is InUse really a status guaranteed to go away??
       begin

data/lib/chef/provider/aws_load_balancer.rb

@@ -1,6 +1,24 @@
 require 'chef/provisioning/aws_driver/aws_provider'
 
 class Chef::Provider::AwsLoadBalancer < Chef::Provisioning::AWSDriver::AWSProvider
+
+  def aws_tagger
+    @aws_tagger ||= begin
+      elb_strategy = Chef::Provisioning::AWSDriver::TaggingStrategy::ELB.new(
+        new_resource.driver.elb_client,
+        new_resource.name,
+        new_resource.aws_tags
+      )
+      Chef::Provisioning::AWSDriver::AWSTagger.new(elb_strategy, action_handler)
+    end
+  end
+
+  def converge_tags
+    aws_tagger.converge_tags
+  end
+
+  provides :aws_load_balancer
+
   def destroy_aws_object(load_balancer)
     converge_by "delete load balancer #{new_resource.name} (#{load_balancer.name}) in #{region}" do
       load_balancer.delete

data/lib/chef/provider/aws_network_acl.rb

@@ -3,6 +3,10 @@ require 'chef/resource/aws_vpc'
 require 'retryable'
 
 class Chef::Provider::AwsNetworkAcl < Chef::Provisioning::AWSDriver::AWSProvider
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::EC2ConvergeTags
+
+  provides :aws_network_acl
+
   def action_create
     network_acl = super
 
@@ -12,7 +16,7 @@ class Chef::Provider::AwsNetworkAcl < Chef::Provisioning::AWSDriver::AWSProvider
   protected
 
   def create_aws_object
-    converge_by "create new Network ACL #{new_resource.name} in #{region}" do
+    converge_by "create network ACL #{new_resource.name} in #{region}" do
       options = {}
       options[:vpc] = new_resource.vpc if new_resource.vpc
       options = AWSResource.lookup_options(options, resource: new_resource)
@@ -87,7 +91,7 @@ class Chef::Provider::AwsNetworkAcl < Chef::Provisioning::AWSDriver::AWSProvider
     end
 
     unless replace_rules.empty? && desired_rules.empty? && current_rules.empty?
-      action_handler.report_progress "update Network ACL #{new_resource.name} #{direction.to_s} rules"
+      action_handler.report_progress "update network ACL #{new_resource.name} #{direction.to_s} rules"
       replace_rules(network_acl, replace_rules)
       add_rules(network_acl, desired_rules)
       remove_rules(network_acl, current_rules)

data/lib/chef/provider/aws_network_interface.rb

@@ -4,11 +4,9 @@ require 'date'
 require 'retryable'
 
 class Chef::Provider::AwsNetworkInterface < Chef::Provisioning::AWSDriver::AWSProvider
-  class NetworkInterfaceStatusTimeoutError < TimeoutError
-    def initialize(new_resource, initial_status, expected_status)
-      super("timed out waiting for #{new_resource} status to change from #{initial_status} to #{expected_status}!")
-    end
-  end
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::EC2ConvergeTags
+
+  provides :aws_network_interface
 
   class NetworkInterfaceStatusTimeoutError < TimeoutError
     def initialize(new_resource, initial_status, expected_status)
@@ -43,7 +41,7 @@ class Chef::Provider::AwsNetworkInterface < Chef::Provisioning::AWSDriver::AWSPr
     end
 
     converge_by "wait for new #{new_resource} in #{region} to become available" do
-      wait_for_eni_status(eni, :available)
+      wait_for_status(eni, :available)
       eni
     end
   end
@@ -122,14 +120,14 @@ class Chef::Provider::AwsNetworkInterface < Chef::Provisioning::AWSDriver::AWSPr
     #
     # If we were told to attach the network interface to a machine, do so
     #
-    if expected_instance.is_a?(AWS::EC2::Instance)
+    if expected_instance.is_a?(AWS::EC2::Instance) || expected_instance.is_a?(::Aws::EC2::Instance)
       case status
       when :available
         attach(eni)
       when :in_use
         # We don't want to attempt to reattach to the same instance or device index
         attachment = current_attachment(eni)
-        if attachment.instance != expected_instance || (options[:device_index] && attachment.device_index != new_resource.device_index)
+        if attachment.instance.id != expected_instance.id || (options[:device_index] && attachment.device_index != new_resource.device_index)
           detach(eni)
           attach(eni)
         end
@@ -153,38 +151,27 @@ class Chef::Provider::AwsNetworkInterface < Chef::Provisioning::AWSDriver::AWSPr
     eni
   end
 
-  def wait_for_eni_status(eni, expected_status)
-    initial_status = eni.status
-    log_callback = proc {
-      Chef::Log.info("waiting for #{new_resource} status to change to #{expected_status}...")
-    }
-
-    Retryable.retryable(:tries => 30, :sleep => 2, :on => NetworkInterfaceStatusTimeoutError, :ensure => log_callback) do
-      raise NetworkInterfaceStatusTimeoutError.new(new_resource, initial_status, expected_status) if eni.status != expected_status
-    end
-  end
-
   def detach(eni)
     attachment   = current_attachment(eni)
     instance     = attachment.instance
 
-    converge_by "detach #{new_resource} from #{instance.instance_id}" do
+    converge_by "detach #{new_resource} from #{instance.id}" do
       eni.detach
     end
 
     converge_by "wait for #{new_resource} to detach" do
-      wait_for_eni_status(eni, :available)
+      wait_for_status(eni, :available)
       eni
     end
   end
 
   def attach(eni)
-    converge_by "attach #{new_resource} to #{new_resource.machine} (#{expected_instance.instance_id})" do
-      eni.attach(expected_instance, options)
+    converge_by "attach #{new_resource} to #{new_resource.machine} (#{expected_instance.id})" do
+      eni.attach(expected_instance.id, options)
     end
 
     converge_by "wait for #{new_resource} to attach" do
-      wait_for_eni_status(eni, :in_use)
+      wait_for_status(eni, :in_use)
       eni
     end
   end

data/lib/chef/provider/aws_rds_instance.rb

@@ -0,0 +1,66 @@
+require 'chef/provisioning/aws_driver/aws_provider'
+require 'chef/provisioning/aws_driver/tagging_strategy/rds'
+
+class Chef::Provider::AwsRdsInstance < Chef::Provisioning::AWSDriver::AWSProvider
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::RDSConvergeTags
+
+  provides :aws_rds_instance
+
+  REQUIRED_OPTIONS = %i(db_instance_identifier allocated_storage engine
+                        db_instance_class master_username master_user_password)
+
+  OTHER_OPTIONS = %i(engine_version multi_az iops publicly_accessible db_name port db_subnet_group_name)
+
+  def update_aws_object(instance)
+    Chef::Log.warn("aws_rds_instance does not support modifying a started instance")
+    # There are required optiosn (like `allocated_storage`) that the use may not
+    # specify on a resource to perform an update.  For example, they may want to
+    # only specify iops to modify that attribute on an update after initial
+    # creation.  In this case we need to load the required options from the existing
+    # aws_object and only override it if the user has specified a value in the
+    # resource.  Ideally, it would be nice to mark values as required on the
+    # resource but right now there is not a `required_on_create`.  This would
+    # also be different if chef-provisioning performed resource cloning, which
+    # it does not.
+  end
+
+  def create_aws_object
+    converge_by "create RDS instance #{new_resource.db_instance_identifier} in #{region}" do
+      new_resource.driver.rds.client.create_db_instance(options_hash)
+    end
+  end
+
+  def destroy_aws_object(instance)
+    converge_by "delete RDS instance #{new_resource.db_instance_identifier} in #{region}" do
+      instance.delete(skip_final_snapshot: true)
+    end
+    # Wait up to 10 minutes for the db instance to shutdown
+    converge_by "waited until RDS instance #{new_resource.name} was deleted" do
+      wait_for(
+        aws_object: instance,
+        query_method: :exists?,
+        expected_responses: [false],
+        acceptable_errors: [AWS::RDS::Errors::DBInstanceNotFound],
+        tries: 60,
+        sleep: 10
+      )
+    end
+  end
+
+  # Sets the additional options then overrides it with all required options from
+  # the resource as well as optional options
+  def options_hash
+    @options_hash ||= begin
+      opts = Hash[new_resource.additional_options.map{|(k,v)| [k.to_sym,v]}]
+      REQUIRED_OPTIONS.each do |opt|
+        opts[opt] = new_resource.send(opt)
+      end
+      OTHER_OPTIONS.each do |opt|
+        opts[opt] = new_resource.send(opt) if ! new_resource.send(opt).nil?
+      end
+      AWSResource.lookup_options(opts, resource: new_resource)
+      opts
+    end
+  end
+
+end

data/lib/chef/provider/aws_rds_subnet_group.rb

@@ -0,0 +1,89 @@
+require 'chef/provisioning/aws_driver/aws_provider'
+require 'chef/provisioning/aws_driver/tagging_strategy/rds'
+
+class Chef::Provider::AwsRdsSubnetGroup < Chef::Provisioning::AWSDriver::AWSProvider
+  include Chef::Provisioning::AWSDriver::TaggingStrategy::RDSConvergeTags
+
+  provides :aws_rds_subnet_group
+
+  def create_aws_object
+    converge_by "create RDS subnet group #{new_resource.name} in #{region}" do
+      driver.create_db_subnet_group(desired_options)
+    end
+  end
+
+  def destroy_aws_object(object)
+    converge_by "delete RDS subnet group #{new_resource.name} in #{region}" do
+      driver.delete_db_subnet_group(db_subnet_group_name: new_resource.name)
+    end
+  end
+
+  def update_aws_object(object)
+    updates = required_updates(object)
+    if ! updates.empty?
+      converge_by updates do
+        driver.modify_db_subnet_group(desired_options)
+      end
+    end
+  end
+
+  def desired_options
+    @desired_options ||= begin
+      opts = {}
+      opts[:db_subnet_group_name] = new_resource.name
+      opts[:db_subnet_group_description] = new_resource.description
+      opts[:subnet_ids] = new_resource.subnets
+      AWSResource.lookup_options(opts, resource: new_resource)
+    end
+  end
+
+  # Given an existing object, return an array of update descriptions
+  # representing the updates that need to be made.
+  #
+  # If no updates are needed, an empty array is returned.
+  #
+  def required_updates(object)
+    ret = []
+    if desired_options[:db_subnet_group_description] != object[:db_subnet_group_description]
+      ret << "  set group description to #{desired_options[:db_subnet_group_description]}"
+    end
+
+    if ! xor_array(desired_options[:subnet_ids], subnet_ids(object[:subnets])).empty?
+      ret << "  set subnets to #{desired_options[:subnet_ids]}"
+    end
+
+    if ! (desired_options[:aws_tags].nil? || desired_options[:aws_tags].empty?)
+      # modify_db_subnet_group doesn't support the tags key according to
+      # http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/RDS/Client.html#modify_db_subnet_group-instance_method
+      Chef::Log.warn "Updating tags for RDS subnet groups is not supported."
+    end
+
+    ret.unshift("update RDS subnet group #{new_resource.name} in #{region}") unless ret.empty?
+    ret
+  end
+
+
+  private
+
+  def subnet_ids(subnets)
+    subnets.map {|i| i[:subnet_identifier] }
+  end
+
+  def xor_array(a, b)
+    (a | b) - (a & b)
+  end
+
+  # To be in line with the other resources. The aws_tags property
+  # takes a hash.  But we actually need an array.
+  def tag_hash_to_array(tag_hash)
+    ret = []
+    tag_hash.each do |key, value|
+      ret << {:key => key, :value => value}
+    end
+    ret
+  end
+
+  def driver
+    new_resource.driver.rds.client
+  end
+end