chef-provisioning-aws 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e941203fbc66689312f07ace28e6ea90413c25b
-  data.tar.gz: fd09857eee368a41188c6c36084aacf061b31eef
+  metadata.gz: 1e2131f19428e227cac159a6380060b30a02b3c4
+  data.tar.gz: 1df8021af60fd98b0495e4f09c2d1254fd5800e5
 SHA512:
-  metadata.gz: 8421e20240201c3c8e66a03017d700dbdb91c669a092793b003ba5ea24234449ebe8c5c4f9517c6c943ecfd1eb5ad138279fc5548045babb004fbf2455c2ca02
-  data.tar.gz: 08802b5ba314ce4840c4ef883164877c57291a98ae1d76720fff5c58d8e4308adfbb5bb1479d77bc46a3525fd9a5ccad99fc643db317a9b92c71806550cb889f
+  metadata.gz: 50f7f3d1749f8f2a95430e1d489446b40bf7b58c94d212258fbb005b0c5ffd53c2fcc355632640f362868de86a46e93b7110ce7bb31d8e7c50004e0f6dd1ce59
+  data.tar.gz: 5c7ae1a4bb3abfe55533b177ee02695c198ca9322b698f2869bffbdee13b49ddd6f740681c246c784e177983b1edcb0fc5aec65d33e5a191a49eb4055f3cc5c5

data/Rakefile

@@ -7,4 +7,6 @@ task :default => :spec
 desc "Run specs"
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = 'spec/**/*_spec.rb'
+  # TODO add back integration tests whenever we have strategy for keys
+  spec.exclude_pattern = 'spec/integration/**/*_spec.rb'
 end

data/lib/chef/provider/aws_auto_scaling_group.rb

@@ -1,51 +1,40 @@
-require 'chef/provider/aws_provider'
-
-class Chef::Provider::AwsAutoScalingGroup < Chef::Provider::AwsProvider
-  action :create do
-    if existing_group.nil?
-      auto_scaling_opts = {
-        :launch_configuration => new_resource.launch_config,
-        :min_size => new_resource.min_size,
-        :max_size => new_resource.max_size,
-        :availability_zones => availability_zones
-      }
-
-      auto_scaling_opts[:desired_capacity] = new_resource.desired_capacity if new_resource.desired_capacity
-      auto_scaling_opts[:load_balancers] = new_resource.load_balancers if new_resource.load_balancers
-
-      converge_by "Creating new Auto Scaling group #{new_resource.name} in #{new_driver.aws_config.region}" do
-        @existing_group = new_driver.auto_scaling.groups.create(
-          new_resource.name,
-          auto_scaling_opts
-        )
-
-        new_resource.save
-      end
-    end
-  end
+require 'chef/provisioning/aws_driver/aws_provider'
+require 'set'
 
-  action :delete do
-    if existing_group
-      converge_by "Deleting Auto Scaling group #{new_resource.name} in #{new_driver.aws_config.region}" do
-        existing_group.delete!
-      end
-    end
+class Chef::Provider::AwsAutoScalingGroup < Chef::Provisioning::AWSDriver::AWSProvider
+
+  protected
 
-    new_resource.delete
+  def create_aws_object
+    converge_by "create new Auto Scaling Group #{new_resource.name} in #{region}" do
+      options = desired_options.dup
+      options[:min_size] ||= 1
+      options[:max_size] ||= 1
+
+      new_resource.driver.auto_scaling.groups.create( new_resource.name, options )
+    end
   end
 
-  def availability_zones
-    @availability_zones ||= new_driver.ec2.availability_zones.reduce([]) { |result, az| result << az }
+  def update_aws_object(group)
+    # TODO add updates for group
   end
 
-  def existing_group
-    @existing_group ||= begin
-                          eg = new_driver.auto_scaling.groups[new_resource.name]
-                          eg.exists? ? eg : nil
-                        end
+  def destroy_aws_object(group)
+    converge_by "delete Auto Scaling Group #{new_resource.name} in #{region}" do
+      group.delete!
+    end
   end
 
-  def id
-    new_resource.name
+  def desired_options
+    @desired_options ||= begin
+      options = new_resource.options
+      %w(launch_configuration min_size max_size availability_zones desired_capacity load_balancers).each do |var|
+        var = var.to_sym
+        value = new_resource.public_send(var)
+        options[var] = value if value
+      end
+      AWSResource.lookup_options(options, resource: new_resource)
+    end
   end
+
 end

data/lib/chef/provider/aws_dhcp_options.rb

@@ -0,0 +1,70 @@
+require 'chef/provisioning/aws_driver/aws_provider'
+
+class Chef::Provider::AwsDhcpOptions < Chef::Provisioning::AWSDriver::AWSProvider
+  protected
+
+  def create_aws_object
+    options = desired_options
+    if options.empty?
+      options[:domain_name_servers] = "AmazonProvidedDNS"
+    end
+
+    converge_by "create new dhcp_options #{new_resource.name} in #{region}" do
+      dhcp_options = new_resource.driver.ec2.dhcp_options.create(options)
+      dhcp_options.tags['Name'] = new_resource.name
+      dhcp_options
+    end
+  end
+
+  def update_aws_object(dhcp_options)
+    # Verify unmodifiable attributes of existing dhcp_options
+    config = dhcp_options.configuration
+    differing_options = desired_options.select { |name, value| config[name] != value }
+    if !differing_options.empty?
+      old_dhcp_options = dhcp_options
+      # Report what we are trying to change ...
+      action_handler.report_progress "update #{new_resource.to_s}"
+      differing_options.each do |name, value|
+        action_handler.report_progress "  set #{name} to #{value.inspect} (was #{config.has_key?(name) ? config[name].inspect : "not set"})"
+      end
+
+      # create new dhcp_options
+      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}"
+
+      # 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
+          vpc.dhcp_options = dhcp_options
+        end
+      end
+
+      # delete old dhcp_options
+      action_handler.perform_action "delete old dhcp_options #{old_dhcp_options.id}" do
+        old_dhcp_options.delete
+      end
+
+      [ :replaced_aws_object, dhcp_options ]
+    end
+  end
+
+  def destroy_aws_object(dhcp_options)
+    converge_by "delete dhcp_options #{new_resource.name} in #{region}" do
+      dhcp_options.delete
+    end
+  end
+
+  private
+
+  def desired_options
+    desired_options = {}
+    %w(domain_name domain_name_servers ntp_servers netbios_name_servers netbios_node_type).each do |attr|
+      attr = attr.to_sym
+      value = new_resource.public_send(attr)
+      desired_options[attr] = value unless value.nil?
+    end
+    Chef::Provisioning::AWSDriver::AWSResource.lookup_options(desired_options, resource: new_resource)
+  end
+end

data/lib/chef/provider/aws_ebs_volume.rb

@@ -1,59 +1,207 @@
-require 'chef/provider/aws_provider'
+require 'chef/provisioning/aws_driver/aws_provider'
 require 'cheffish'
 require 'date'
+require 'retryable'
 
-class Chef::Provider::AwsEbsVolume < Chef::Provider::AwsProvider
+class Chef::Provider::AwsEbsVolume < Chef::Provisioning::AWSDriver::AWSProvider
+  class VolumeNotFoundError < RuntimeError
+    def initialize(new_resource)
+      super("#{new_resource} does not exist!")
+    end
+  end
 
-  action :create do
-    if existing_volume == nil
-      converge_by "Creating new EBS volume #{fqn} in #{new_driver.aws_config.region}" do
+  class VolumeStatusTimeoutError < 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
 
-        ebs = new_driver.ec2.volumes.create(
-            :availability_zone => new_resource.availability_zone,
-            :size => new_resource.size.to_i
-        )
-        ebs.tags['Name'] = fqn
+  class VolumeInvalidStatusError < RuntimeError
+    def initialize(new_resource, status)
+      super("#{new_resource} is in #{status} state!")
+    end
+  end
 
-        new_resource.created_at DateTime.now.to_s
-        new_resource.volume_id ebs.id
+  def action_create
+    volume = super
 
-      end
-    else
-      new_resource.volume_id existing_volume.id
+    if !new_resource.machine.nil?
+      update_attachment(volume)
     end
+  end
 
-    new_resource.save
+  protected
+
+  def create_aws_object
+    volume = nil
+    converge_by "create new #{new_resource} in #{region}" do
+      volume = new_resource.driver.ec2.volumes.create(initial_options)
+      volume.tags['Name'] = new_resource.name
+    end
+
+    converge_by "wait for new #{new_resource} in #{region} to become available" do
+      wait_for_volume_status(volume, :available)
+      volume
+    end
   end
 
-  action :delete do
-    if existing_volume
-      converge_by "Deleting EBS volume #{fqn} in #{new_driver.aws_config.region}" do
-        existing_volume.delete
+  def update_aws_object(volume)
+    if initial_options.has_key?(:availability_zone)
+      if initial_options[:availability_zone] != volume.availability_zone_name
+        raise "#{new_resource}.availability_zone is #{new_resource.availability_zone}, but actual volume has availability_zone_name set to #{volume.availability_zone_name}.  Cannot be modified!"
+      end
+    end
+    if initial_options.has_key?(:size)
+      if initial_options[:size] != volume.size
+        raise "#{new_resource}.size is #{new_resource.size}, but actual volume has size set to #{volume.size}.  Cannot be modified!"
+      end
+    end
+    if initial_options.has_key?(:snapshot)
+      if initial_options[:snapshot] != volume.snapshot.id
+        raise "#{new_resource}.snapshot is #{new_resource.snapshot}, but actual volume has snapshot set to #{volume.snapshot.id}.  Cannot be modified!"
+      end
+    end
+    if initial_options.has_key?(:iops)
+      if initial_options[:iops] != volume.iops
+        raise "#{new_resource}.iops is #{new_resource.iops}, but actual volume has iops set to #{volume.iops}.  Cannot be modified!"
+      end
+    end
+    if initial_options.has_key?(:volume_type)
+      if initial_options[:volume_type] != volume.type
+        raise "#{new_resource}.volume_type is #{new_resource.volume_type}, but actual volume has type set to #{volume.type}.  Cannot be modified!"
       end
     end
+    if initial_options.has_key?(:encrypted)
+      if initial_options[:encrypted] != !!volume.encrypted
+        raise "#{new_resource}.encrypted is #{new_resource.encrypted}, but actual volume has encrypted set to #{volume.encrypted}.  Cannot be modified!"
+      end
+    end
+  end
 
-    new_resource.delete
+  def destroy_aws_object(volume)
+    detach(volume) if volume.status == :in_use
+    delete(volume)
+  end
+
+  private
+
+  def expected_instance
+    if !defined?(@expected_instance)
+      if new_resource.machine == false
+        @expected_instance = nil
+      else
+        @expected_instance = Chef::Resource::AwsInstance.get_aws_object(new_resource.machine, resource: new_resource)
+      end
+    end
+    @expected_instance
   end
 
+  def initial_options
+    @initial_options ||= begin
+      options = {}
+      options[:availability_zone] = new_resource.availability_zone if !new_resource.availability_zone.nil?
+      options[:size]              = new_resource.size              if !new_resource.size.nil?
+      options[:snapshot_id]       = new_resource.snapshot          if !new_resource.snapshot.nil?
+      options[:iops]              = new_resource.iops              if !new_resource.iops.nil?
+      options[:volume_type]       = new_resource.volume_type       if !new_resource.volume_type.nil?
+      options[:encrypted]         = new_resource.encrypted         if !new_resource.encrypted.nil?
+      options[:encrypted] = !!options[:encrypted] if !options[:encrypted].nil?
 
-  def existing_volume
-    @existing_volume ||=  new_resource.volume_id == nil ? nil : begin
-      Chef::Log.debug("Loading volume #{new_resource.volume_id}")
-      volume = new_driver.ec2.volumes[new_resource.volume_id]
-      if [:deleted, :deleting, :error].include? volume.status
-        nil
+      AWSResource.lookup_options(options, resource: new_resource)
+    end
+  end
+
+  def update_attachment(volume)
+    status = volume.status
+    #
+    # If we were told to attach the volume to a machine, do so
+    #
+    if 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
+          detach(volume)
+          attach(volume)
+        end
+      when :available
+        attach(volume)
+      when nil
+        raise VolumeNotFoundError.new(new_resource)
       else
-        Chef::Log.debug("Found EBS volume #{volume.inspect}")
-        volume
+        raise VolumeInvalidStatusError.new(new_resource, status)
+      end
+
+    #
+    # If we were told to set the machine to false, detach it.
+    #
+    else
+      case status
+      when nil
+        Chef::Log.warn VolumeNotFoundError.new(new_resource)
+      when :in_use
+        detach(volume)
       end
-    rescue => e
-      Chef::Log.error("Error looking for EBS volume: #{e}")
-      nil
+    end
+    volume
+  end
+    
+  def wait_for_volume_status(volume, expected_status)
+    initial_status = volume.status
+    log_callback = proc {
+      Chef::Log.info("waiting for #{new_resource} status to change to #{expected_status}...")
+    }
+
+    Retryable.retryable(:tries => 30, :sleep => 2, :on => VolumeStatusTimeoutError, :ensure => log_callback) do
+      raise VolumeStatusTimeoutError.new(new_resource, initial_status, expected_status) if volume.status != expected_status
+    end
+  end
+
+  def detach(volume)
+    attachment = current_attachment(volume)
+    instance = attachment.instance
+    device   = attachment.device
+
+    converge_by "detach #{new_resource} from #{new_resource.machine} (#{instance.instance_id})" do
+      volume.detach_from(instance, device)
+    end
+
+    converge_by "wait for #{new_resource} to detach" do
+      wait_for_volume_status(volume, :available)
+      volume
+    end
+  end
+
+  def attach(volume)
+    converge_by "attach #{new_resource} to #{new_resource.machine} (#{expected_instance.instance_id}) to device #{new_resource.device}" do
+      volume.attach_to(expected_instance, new_resource.device)
+    end
+
+    converge_by "wait for #{new_resource} to attach" do
+      wait_for_volume_status(volume, :in_use)
+      volume
     end
   end
 
-  def id
-    new_resource.volume_name
+  def current_attachment(volume)
+    volume.attachments.first
   end
 
+  def delete(volume)
+    converge_by "delete #{new_resource} in #{region}" do
+      volume.delete
+    end
+
+    converge_by "wait for #{new_resource} in #{region} to delete" do
+      log_callback = proc {
+        Chef::Log.info('waiting for volume to delete...')
+      }
+
+      Retryable.retryable(:tries => 30, :sleep => 2, :on => VolumeStatusTimeoutError, :ensure => log_callback) do
+        raise VolumeStatusTimeoutError.new(new_resource, 'exists', 'deleted') if volume.exists?
+      end
+      volume
+    end
+  end
 end

data/lib/chef/provider/aws_eip_address.rb

@@ -1,85 +1,88 @@
-require 'chef/provider/aws_provider'
+require 'chef/provisioning/aws_driver/aws_provider'
+require 'chef/resource/aws_instance'
 require 'chef/provisioning/machine_spec'
 require 'cheffish'
 
-class Chef::Provider::AwsEipAddress < Chef::Provider::AwsProvider
+class Chef::Provider::AwsEipAddress < Chef::Provisioning::AWSDriver::AWSProvider
 
-  action :create do
-    if existing_ip == nil
-      converge_by "Creating new EIP address in #{new_driver.aws_config.region}" do
-        eip = new_driver.ec2.elastic_ips.create :vpc => new_resource.associate_to_vpc
-        new_resource.public_ip eip.public_ip
-        new_resource.domain eip.domain
-        new_resource.instance_id eip.instance_id
-      end
-    else
-      new_resource.public_ip existing_ip.public_ip
-      new_resource.domain existing_ip.domain
-      new_resource.instance_id existing_ip.instance_id
+  def action_create
+    elastic_ip = super
+
+    if !new_resource.machine.nil?
+      update_association(elastic_ip)
     end
-    new_resource.save
   end
 
-  action :delete do
-    if existing_ip
-      converge_by "Deleting EIP Address #{new_resource.name} in #{new_driver.aws_config.region}" do
-        #if it's attached to something in a vpc, disassociate first
-        if existing_ip.instance_id != nil && existing_ip.domain == 'vpc'
-          existing_ip.disassociate
+  protected
+
+  def create_aws_object
+    converge_by "create new EIP 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)
+          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
-        existing_ip.delete
-        new_resource.delete
       end
+      new_resource.driver.ec2.elastic_ips.create vpc: new_resource.associate_to_vpc
     end
   end
 
-  action :associate do
-    converge_by "Associating EIP Address #{new_resource.name} in #{new_driver.aws_config.region}" do
-      if existing_ip == nil
-        action_create
-      end
-        eip = new_driver.ec2.elastic_ips[new_resource.public_ip]
-      begin
-        spec = Chef::Provisioning::ChefMachineSpec.get(new_resource.machine)
-        if spec == nil
-          Chef::Application.fatal!("Could not find machine #{new_resource.machine}")
-        else
-          eip.associate :instance => spec.location['instance_id']
-        end
-        new_resource.instance_id eip.instance_id
-      rescue => e
-        Chef::Application.fatal!("Error Associating EIP: #{e}")
+  def update_aws_object(elastic_ip)
+    if !new_resource.associate_to_vpc.nil?
+      if !!new_resource.associate_to_vpc != !!elastic_ip.vpc?
+        raise "#{new_resource.to_s}.associate_to_vpc = #{new_resource.associate_to_vpc}, but actual IP address has vpc? set to #{elastic_ip.vpc?}.  Cannot be modified!"
       end
-      new_resource.save
     end
   end
 
-  action :disassociate do
-    converge_by "Disassociating EIP Address #{new_resource.name} in #{new_driver.aws_config.region}" do
-      begin
-        if existing_ip != nil
-          existing_ip.disassociate
-          new_resource.instance_id nil
-          new_resource.save
-        else
-          Chef::Log.warn("No EIP found to disassociate")
-        end
-      rescue => e
-        Chef::Application.fatal!("Error Disassociating EIP: #{e}")
+  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
+        elastic_ip.disassociate
       end
     end
+    converge_by "delete Elastic IP Address #{new_resource.name} (#{elastic_ip.public_ip}) in #{region}" do
+      elastic_ip.delete
+    end
   end
 
-  def existing_ip
-    new_resource.hydrate
-    @existing_ip ||=  new_resource.public_ip == nil ? nil : begin
-      eip = new_driver.ec2.elastic_ips[new_resource.public_ip]
-      eip
-    rescue => e
-      Chef::Application.fatal!("Error looking for EIP Address: #{e}")
-      nil
+  private
+
+  def desired_instance
+    if !defined?(@desired_instance)
+      if new_resource.machine == false
+        @desired_instance = false
+      else
+        @desired_instance = Chef::Resource::AwsInstance.get_aws_object(new_resource.machine, resource: new_resource)
+      end
     end
+    @desired_instance
   end
 
+  def update_association(elastic_ip)
+    #
+    # If we were told to associate the IP to a machine, do so
+    #
+    if 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
+          elastic_ip.associate instance: desired_instance.id
+        end
+      end
+
+    #
+    # If we were told to set the association to false, disassociate it.
+    #
+    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
+          aws_object.disassociate
+        end
+      end
+    end
+
+  end
 
 end