chef-provisioning-aws 0.4.0 → 0.5.0

data/lib/chef/provisioning/aws_driver.rb

@@ -1,3 +1,20 @@
 require 'chef/provisioning'
 require 'chef/provisioning/aws_driver/driver'
-require 'chef/provisioning/aws_driver/resources'
+
+require "chef/resource/aws_auto_scaling_group"
+require "chef/resource/aws_dhcp_options"
+require "chef/resource/aws_ebs_volume"
+require "chef/resource/aws_eip_address"
+require "chef/resource/aws_image"
+require "chef/resource/aws_instance"
+require "chef/resource/aws_internet_gateway"
+require "chef/resource/aws_launch_configuration"
+require "chef/resource/aws_load_balancer"
+require "chef/resource/aws_network_interface"
+require "chef/resource/aws_route_table"
+require "chef/resource/aws_s3_bucket"
+require "chef/resource/aws_security_group"
+require "chef/resource/aws_sns_topic"
+require "chef/resource/aws_sqs_queue"
+require "chef/resource/aws_subnet"
+require "chef/resource/aws_vpc"

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

@@ -0,0 +1,206 @@
+require 'chef/provider/lwrp_base'
+require 'chef/provisioning/aws_driver/aws_resource'
+require 'chef/provisioning/aws_driver/aws_resource_with_entry'
+require 'chef/provisioning/chef_managed_entry_store'
+require 'chef/provisioning/chef_provider_action_handler'
+
+module Chef::Provisioning::AWSDriver
+class AWSProvider < Chef::Provider::LWRPBase
+  use_inline_resources
+
+  AWSResource = Chef::Provisioning::AWSDriver::AWSResource
+
+  def action_handler
+    @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
+  end
+
+  # All these need to implement whyrun
+  def whyrun_supported?
+    true
+  end
+
+  def region
+    new_resource.driver.aws_config.region
+  end
+
+  #
+  # Return the damned value from the block, not whatever weirdness converge_by
+  # normally returns.
+  #
+  def converge_by(*args, &block)
+    result = nil
+    super(*args) do
+      result = block.call
+    end
+    result
+  end
+
+  action :create do
+    #
+    # If the user specified an ID, get the object for it, and fail if it does not exist.
+    #
+    desired_driver = new_resource.driver
+    desired_id = new_resource.public_send(new_resource.class.aws_id_attribute) if new_resource.class.aws_id_attribute
+    if desired_id
+      aws_object = new_resource.class.get_aws_object(desired_id, resource: new_resource)
+    end
+
+    #
+    # If Chef has already associated the object with an AWS ID, check if it's
+    # the same as the desired AWS ID.
+    #
+    if new_resource.is_a?(AWSResourceWithEntry)
+      entry_driver, entry_id, entry = new_resource.get_id_from_managed_entry
+      if entry_id
+        if desired_id
+
+          #
+          # We have both a desired ID and an entry ID.  Find out whether they
+          # match and warn if they don't (because we're going to reassociate and
+          # update the *desired* AWS thing.).
+          #
+          if desired_driver.driver_url == entry_driver.driver_url && desired_id == entry_id
+            Chef::Log.debug "#{new_resource.to_s} is already associated with #{entry_id} in #{entry_driver.driver_url}"
+          else
+            Chef::Log.warn "#{new_resource.to_s} is currently associated with #{entry_id} in #{entry_driver.driver_url}, but the desired ID is #{desired_id} in #{new_resource.driver.driver_url}!  Will associate with new desired ID #{desired_id}."
+          end
+
+        else
+
+          #
+          # If we don't have desired (common case), we'll update the existing
+          # resource or create a new one if it's been deleted.
+          #
+          aws_object = new_resource.class.get_aws_object(entry_id, driver: entry_driver, resource: new_resource, required: false)
+          if aws_object
+            Chef::Log.debug "#{new_resource.to_s} is currently associated with #{entry_id} in #{entry_driver.driver_url}."
+          else
+            Chef::Log.warn "#{new_resource.to_s} is currently associated with #{entry_id} in #{entry_driver.driver_url}, but it does not exist!  We will create a new one to replace it."
+          end
+        end
+
+      else
+
+        #
+        # If we don't currently have an AWS ID associated with this resource, we
+        # will either associate the desired one, or create a new one.
+        #
+        if desired_id
+          Chef::Log.debug "#{new_resource.to_s} is not yet associated with anything.  Associating with desired object #{desired_id} in #{desired_driver.driver_url}."
+        else
+          Chef::Log.debug "#{new_resource.to_s} is not yet associated with anything.  Creating a new one in #{desired_driver.driver_url} ..."
+        end
+      end
+
+    else
+
+      #
+      # If it does not support storing IDs in Chef at all, just grab the existing
+      # object and we'll update (or not) based on that.
+      #
+      aws_object ||= new_resource.aws_object
+
+    end
+
+    #
+    # Actually update or create the AWS object
+    #
+    if aws_object
+      action, new_obj = update_aws_object(aws_object)
+      if action == :replaced_aws_object
+        aws_object = new_obj
+      end
+    else
+      aws_object = create_aws_object
+    end
+
+    #
+    # Associate the managed entry with the AWS object
+    #
+    if new_resource.is_a?(AWSResourceWithEntry)
+      new_resource.save_managed_entry(aws_object, action_handler, existing_entry: entry)
+    end
+
+    aws_object
+  end
+
+  action :destroy do
+    desired_driver = new_resource.driver
+    desired_id = new_resource.public_send(new_resource.class.aws_id_attribute) if new_resource.class.aws_id_attribute
+
+    #
+    # If the user specified an ID, delete THAT; do NOT delete the associated object.
+    #
+    if desired_id
+      aws_object = new_resource.class.get_aws_object(desired_id, resource: new_resource, required: false)
+      if aws_object
+        Chef::Log.debug "#{new_resource.to_s} provided #{new_resource.class.aws_id_attribute} #{desired_id} in #{desired_driver.driver_url}.  Will delete."
+      end
+    end
+
+    #
+    # Managed entries are looked up by ID.
+    #
+    if new_resource.is_a?(AWSResourceWithEntry)
+      entry_driver, entry_id, entry = new_resource.get_id_from_managed_entry
+      if entry_id
+        if desired_id && (desired_id != entry_id || desired_driver.driver_url != entry_driver.driver_url)
+          if new_resource.class.get_aws_object(entry_id, driver: entry_driver, resource: new_resource, required: false)
+            # If the desired ID / driver differs from the entry, don't delete.  We
+            # certainly can't delete the AWS object itself, and we don't *want* to
+            # delete the association, because the expectation is that after doing a
+            # delete, you should be able to create a new thing.
+            raise "#{new_resource.to_s} provided #{new_resource.class.aws_id_attribute} #{desired_id} in #{desired_driver.driver_url}, but is currently associated with #{entry_id} in #{entry_driver.driver_url}.  Cannot delete the entry or the association until this inconsistency is resolved."
+          else
+            Chef::Log.debug "#{new_resource.to_s} provided #{new_resource.class.aws_id_attribute} #{desired_id} in #{desired_driver.driver_url}, but is currently associated with #{entry_id} in #{entry_driver.driver_url}, which does not exist.  Will delete #{desired_id} and disassociate from #{entry_id}."
+          end
+        else
+
+          # Normal case: entry exists, and is the same as desired (or no desired)
+          aws_object = new_resource.class.get_aws_object(entry_id, driver: entry_driver, resource: new_resource, required: false)
+          if aws_object
+            Chef::Log.debug "#{new_resource.to_s} is associated with #{entry_id} in #{entry_driver.driver_url}.  Will delete."
+          else
+            Chef::Log.debug "#{new_resource.to_s} is associated with #{entry_id} in #{entry_driver.driver_url}, but it does not exist.  Will disassociate the entry but not delete."
+          end
+        end
+      end
+
+    #
+    # Non-managed entries all have their own way of looking it up
+    #
+    else
+      aws_object ||= new_resource.aws_object
+    end
+
+    #
+    # Call the delete method
+    #
+    if aws_object
+      destroy_aws_object(aws_object)
+    end
+
+    #
+    # Associate the managed entry with the AWS object
+    #
+    if new_resource.is_a?(AWSResourceWithEntry) && entry
+      new_resource.delete_managed_entry(action_handler)
+    end
+  end
+
+  protected
+
+  def create_aws_object
+    raise NotImplementedError, :create_aws_object
+  end
+
+  def update_aws_object(obj)
+    raise NotImplementedError, :update_aws_object
+  end
+
+  def destroy_aws_object(obj)
+    raise NotImplementedError, :destroy_aws_object
+  end
+
+end
+end

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

@@ -0,0 +1,186 @@
+require 'aws'
+require 'chef/provisioning/aws_driver/super_lwrp'
+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
+  default_action :create
+
+  def initialize(name, run_context=nil)
+    name = name.public_send(self.class.aws_sdk_class_id) if name.is_a?(self.class.aws_sdk_class)
+    super
+    if run_context
+      driver run_context.chef_provisioning.current_driver
+      chef_server run_context.cheffish.current_chef_server
+    end
+  end
+
+  # Backwards compatibility for action :destroy
+  def action(*args)
+    if args == [ :delete ]
+      super(:destroy)
+    else
+      super
+    end
+  end
+  def action=(value)
+    action(value)
+  end
+
+  #
+  # The desired driver.
+  #
+  attribute :driver, kind_of: Chef::Provisioning::Driver,
+                     coerce: (proc do |value|
+                               case value
+                               when nil, Chef::Provisioning::Driver
+                                 value
+                               else
+                                 run_context.chef_provisioning.driver_for(value)
+                               end
+                             end)
+
+  #
+  # The Chef server on which any IDs should be looked up.
+  #
+  attribute :chef_server, kind_of: Hash
+
+  #
+  # The managed entry store.
+  #
+  attribute :managed_entry_store, kind_of: Chef::Provisioning::ManagedEntryStore,
+                              lazy_default: proc { Chef::Provisioning::ChefManagedEntryStore.new(chef_server) }
+
+  #
+  # Get the current AWS object.
+  #
+  def aws_object
+    raise NotImplementedError, :aws_object
+  end
+
+  #
+  # Look up an AWS options list, translating standard names using the appropriate
+  # classes.
+  #
+  # For example, `load_balancer_options` is passed into `lookup_options`, and if
+  # it looks like this: `{ subnets: `[ 'subnet1', 'subnet2' ] }`, then
+  # `AWSResource.lookup_options` will translate each ID with
+  # `AwsSubnet.get_aws_object('subnet1')`, which supports Chef names
+  # (`mysubnet`) as well as AWS subnet Ids (`subnet-1234abcd`) or AWS objects
+  # (`AWS::EC2::Subnet`).
+  #
+  # Keys that represent non-AWS-objects (such as `timeout`) are left alone.
+  #
+  def self.lookup_options(options, **handler_options)
+    options = options.dup
+    options.each do |name, value|
+      if name.to_s.end_with?('s')
+        handler_name = :"#{name[0..-2]}"
+        if aws_option_handlers[handler_name]
+          options[name] = [options[name]].flatten.map { |value| aws_option_handlers[handler_name].get_aws_object_id(value, **handler_options) }
+        end
+      else
+        if aws_option_handlers[name]
+          options[name] = aws_option_handlers[name].get_aws_object_id(value, **handler_options)
+        end
+      end
+    end
+    options
+  end
+
+  def self.get_aws_object(value, resource: nil, run_context: nil, driver: nil, managed_entry_store: nil, required: true)
+    return nil if value.nil?
+
+    if resource
+      run_context         ||= resource.run_context
+      driver              ||= resource.driver
+      managed_entry_store ||= resource.managed_entry_store
+    end
+    if value.is_a?(self)
+      resource = value
+    else
+      resource = new(value, run_context)
+      resource.driver driver if driver
+      resource.managed_entry_store managed_entry_store if managed_entry_store
+    end
+    result = resource.aws_object
+    if required && result.nil?
+      raise "#{self}[#{value}] does not exist!"
+    end
+    result
+  end
+
+  def self.get_aws_object_id(value, **options)
+    aws_object = get_aws_object(value, **options)
+    aws_object.public_send(aws_sdk_class_id) if aws_object
+  end
+
+  protected
+
+  NOT_PASSED = Object.new
+
+  def self.aws_sdk_type(sdk_class,
+                        option_names: nil,
+                        option_name: NOT_PASSED,
+                        load_provider: true,
+                        id: :name,
+                        aws_id_prefix: nil)
+    self.resource_name = self.dsl_name
+    @aws_sdk_class = sdk_class
+    @aws_sdk_class_id = id
+    @aws_id_prefix = aws_id_prefix
+
+    # Go ahead and require the provider since we're here anyway ...
+    require "chef/provider/#{resource_name}" if load_provider
+
+    option_name = :"#{resource_name[4..-1]}" if option_name == NOT_PASSED
+    @aws_sdk_option_name = option_name
+
+    option_names ||= begin
+      option_names = []
+      option_names << aws_sdk_option_name
+      option_names << :"#{option_name}_#{aws_sdk_class_id}" if aws_sdk_class_id
+      option_names
+    end
+    option_names.each do |option_name|
+      aws_option_handlers[option_name] = self
+    end
+
+    name = self.name.split('::')[-1]
+    eval("Chef::Provisioning::AWSDriver::Resources::#{name} = self", binding, __FILE__, __LINE__)
+  end
+
+  def self.aws_sdk_class
+    @aws_sdk_class
+  end
+
+  def self.aws_sdk_class_id
+    @aws_sdk_class_id
+  end
+
+  def self.aws_id_prefix
+    @aws_id_prefix
+  end
+
+  def self.aws_sdk_option_name
+    @aws_sdk_option_name
+  end
+
+  @@aws_option_handlers = {}
+  def self.aws_option_handlers
+    @@aws_option_handlers
+  end
+
+  # Add support for aws_id_attribute: true
+  def self.attribute(name, aws_id_attribute: false, **validation_opts)
+    @aws_id_attribute = name if aws_id_attribute
+    super(name, validation_opts)
+  end
+
+  def self.aws_id_attribute
+    @aws_id_attribute
+  end
+end
+end

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

@@ -0,0 +1,114 @@
+require 'chef/provisioning/aws_driver/aws_resource'
+require 'chef/provisioning/aws_driver/resources'
+
+# Common AWS resource - contains metadata that all AWS resources will need
+class Chef::Provisioning::AWSDriver::AWSResourceWithEntry < Chef::Provisioning::AWSDriver::AWSResource
+  #
+  # Dissociate the ID of this object from Chef.
+  #
+  # @param action_handler [Chef::Provisioning::ActionHandler] The action handler,
+  #        which handles progress reporting, update reporting ("little green text")
+  #        and dry run.
+  #
+  def delete_managed_entry(action_handler)
+    if should_have_managed_entry?
+      managed_entry_store.delete(self.class.resource_name, name, action_handler)
+    end
+  end
+
+  #
+  # Save the ID of this object to Chef.
+  #
+  # @param aws_object [AWS::EC2::Core] The AWS object containing the ID.
+  # @param action_handler [Chef::Provisioning::ActionHandler] The action handler,
+  #        which handles progress reporting, update reporting ("little green text")
+  #        and dry run.
+  # @param existing_entry [Chef::Provisioning::ManagedEntry] The existing entry
+  #        (if any).  If this is passed in, and no values are changed, we will
+  #        not attempt to update it (this prevents us from retrieving it twice).
+  #
+  def save_managed_entry(aws_object, action_handler, existing_entry: nil)
+    if should_have_managed_entry?
+      managed_entry = existing_entry ||
+                      managed_entry_store.new_entry(self.class.resource_name, name)
+      updated = update_managed_entry(aws_object, managed_entry)
+      if updated || !existing_entry
+        managed_entry.save(action_handler)
+      end
+    end
+  end
+
+  def get_id_from_managed_entry
+    if should_have_managed_entry?
+      entry = managed_entry_store.get(self.class.managed_entry_type, name)
+      if entry
+        driver = self.driver
+        if entry.driver_url != driver.driver_url
+          # TODO some people don't send us run_context (like Drivers).  We might need
+          # to exit early here if the driver_url doesn't match the provided driver.
+          driver = run_context.chef_provisioning.driver_for(entry.driver_url)
+        end
+        [ driver, entry.reference[self.class.managed_entry_id_name], entry ]
+      end
+    end
+  end
+
+  # Formatted output for logging statements - contains resource type, resource name and aws object id (if available)
+  def to_s
+    id = get_driver_and_id[1]
+    "#{declared_type}[#{@name}] (#{ id ? id : 'no AWS object id'})"
+  end
+
+  protected
+
+  #
+  # Update an existing ManagedEntry object.
+  #
+  # @return true if the entry was changed, and false if not
+  #
+  def update_managed_entry(aws_object, managed_entry)
+    new_value = { self.class.managed_entry_id_name => aws_object.public_send(self.class.aws_sdk_class_id) }
+    if managed_entry.reference != new_value
+      managed_entry.reference = new_value
+      changed = true
+    end
+    if managed_entry.driver_url != driver.driver_url
+      managed_entry.driver_url = driver.driver_url
+      changed = true
+    end
+    changed
+  end
+
+  def get_driver_and_id
+    driver, id, entry = get_id_from_managed_entry
+    # If the value isn't already stored, look up the user-specified public_ip
+    driver, id = self.driver, self.public_send(self.class.aws_id_attribute) if !id
+    [ driver, id ]
+  end
+
+  def self.aws_sdk_type(sdk_class,
+                        id: :id,
+                        managed_entry_type: nil,
+                        managed_entry_id_name: 'id',
+                        backcompat_data_bag_name: nil,
+                        **options)
+    super(sdk_class, id: id, **options)
+    @managed_entry_type = managed_entry_type || resource_name.to_sym
+    @managed_entry_id_name = managed_entry_id_name
+    if backcompat_data_bag_name
+      Chef::Provisioning::ChefManagedEntryStore.type_names_for_backcompat[resource_name] = backcompat_data_bag_name
+    end
+  end
+
+  def self.managed_entry_type
+    @managed_entry_type
+  end
+
+  def self.managed_entry_id_name
+    @managed_entry_id_name
+  end
+
+  def should_have_managed_entry?
+    name != public_send(self.class.aws_id_attribute)
+  end
+end