chef-provisioning-aws 0.4.0 → 0.5.0

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

@@ -1,7 +1,10 @@
-resources = %w(sqs_queue sns_topic ebs_volume s3_bucket auto_scaling_group launch_config vpc security_group eip_address subnet)
+# Module under which all AWS resources live
 
-resources.each do |r|
-  Chef::Log.debug "AWS driver loading resource: #{r}"
-  require "chef/resource/aws_#{r}"
-  require "chef/provider/aws_#{r}"
+class Chef
+  module Provisioning
+    module AWSDriver
+      module Resources
+      end
+    end
+  end
 end

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

@@ -0,0 +1,45 @@
+require 'chef/resource/lwrp_base'
+
+class Chef
+  module Provisioning
+    module AWSDriver
+      class SuperLWRP < Chef::Resource::LWRPBase
+        #
+        # Add the :lazy_default and :coerce validation_opts to `attribute`
+        #
+        def self.attribute(attr_name, validation_opts={})
+          lazy_default = validation_opts.delete(:lazy_default)
+          coerce = validation_opts.delete(:coerce)
+          if lazy_default || coerce
+            define_method(attr_name) do |arg=nil|
+              arg = instance_exec(arg, &coerce) if coerce && !arg.nil?
+
+              result = set_or_return(attr_name.to_sym, arg, validation_opts)
+
+              if result.nil? && arg.nil?
+                result = instance_eval(&lazy_default) if lazy_default
+              end
+
+              result
+            end
+            define_method(:"#{attr_name}=") do |arg|
+              if arg.nil?
+                remove_instance_variable(:"@#{arg}")
+              else
+                set_or_return(attr_name.to_sym, arg, validation_opts)
+              end
+            end
+          else
+            super
+          end
+        end
+
+        # FUUUUUU cloning
+        def load_prior_resource(*args)
+          Chef::Log.debug "Overloading #{self.resource_name} load_prior_resource with NOOP"
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 class Chef
 module Provisioning
 module AWSDriver
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end
 end
 end

data/lib/chef/resource/aws_auto_scaling_group.rb

@@ -1,17 +1,19 @@
-require 'chef/resource/aws_resource'
-require 'chef/provisioning/aws_driver'
+require 'chef/provisioning/aws_driver/aws_resource'
 
-class Chef::Resource::AwsAutoScalingGroup < Chef::Resource::AwsResource
-  self.resource_name = 'aws_auto_scaling_group'
-  self.databag_name = 'auto_scaling_groups'
+class Chef::Resource::AwsAutoScalingGroup < Chef::Provisioning::AWSDriver::AWSResource
+  aws_sdk_type AWS::AutoScaling::Group
 
-  actions :create, :delete, :nothing
-  default_action :create
+  attribute :name,                 kind_of: String,  name_attribute: true
+  attribute :options,              kind_of: Hash,    default: {}
+  attribute :availability_zones,   kind_of: Array
+  attribute :desired_capacity,     kind_of: Integer
+  attribute :launch_configuration, kind_of: String
+  attribute :min_size,             kind_of: Integer
+  attribute :max_size,             kind_of: Integer
+  attribute :load_balancers,       kind_of: Array,   coerce: proc { |value| [value].flatten }
 
-  attribute :name, :kind_of => String, :name_attribute => true
-  attribute :desired_capacity, :kind_of => Integer
-  attribute :launch_config, :kind_of => String
-  attribute :min_size, :kind_of => Integer, :default => 1
-  attribute :max_size, :kind_of => Integer, :default => 4
-  attribute :load_balancers, :kind_of => Array
+  def aws_object
+    result = driver.auto_scaling.groups[name]
+    result && result.exists? ? result : nil
+  end
 end

data/lib/chef/resource/aws_dhcp_options.rb

@@ -0,0 +1,57 @@
+require 'chef/provisioning/aws_driver/aws_resource_with_entry'
+
+#
+# DHCP options for use by VPCs.
+#
+# If you specify nothing, the DHCP options set will use 'AmazonProvidedDNS' for its
+# domain name servers and all other values will be empty.
+#
+# API documentation for the AWS Ruby SDK for DHCP Options (and the object returned from `aws_object` can be found here:
+#
+# - http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html
+#
+class Chef::Resource::AwsDhcpOptions < Chef::Provisioning::AWSDriver::AWSResourceWithEntry
+  aws_sdk_type AWS::EC2::DHCPOptions
+
+  #
+  # The Chef "idempotence name" of this DHCP options set.
+  #
+  attribute :name, kind_of: String, name_attribute: true
+
+  #
+  # A domain name of your choice (e.g., example.com).
+  #
+  attribute :domain_name, kind_of: String
+
+  #
+  # The IP addresses of domain name servers. You can specify up to four addresses.
+  #
+  # Defaults to "AmazonProvidedDNS"
+  #
+  attribute :domain_name_servers, kind_of: Array, coerce: proc { |v| Array[v].flatten }
+
+  #
+  # The IP addresses of Network Time Protocol (NTP) servers. You can specify up to four addresses.
+  #
+  attribute :ntp_servers, kind_of: Array, coerce: proc { |v| Array[v].flatten }
+
+  #
+  # The IP addresses of NetBIOS name servers. You can specify up to four addresses.
+  #
+  attribute :netbios_name_servers, kind_of: Array, coerce: proc { |v| Array[v].flatten }
+
+  #
+  # Value indicating the NetBIOS node type (1, 2, 4, or 8). For more information about the values, go to RFC 2132. We recommend you only use 2 at this time (broadcast and multicast are currently not supported).
+  #
+  attribute :netbios_node_type, kind_of: Integer
+
+  attribute :dhcp_options_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^dopt-[a-f0-9]{8}$/ ? name : nil
+  }
+
+  def aws_object
+    driver, id = get_driver_and_id
+    result = driver.ec2.dhcp_options[id] if id
+    result && result.exists? ? result : nil
+  end
+end

data/lib/chef/resource/aws_ebs_volume.rb

@@ -1,31 +1,29 @@
-require 'chef/resource/aws_resource'
-require 'chef/provisioning/aws_driver'
+require 'chef/provisioning/aws_driver/aws_resource_with_entry'
+require 'chef/resource/aws_instance'
 
-class Chef::Resource::AwsEbsVolume < Chef::Resource::AwsResource
-  self.resource_name = 'aws_ebs_volume'
-  self.databag_name = 'ebs_volumes'
+class Chef::Resource::AwsEbsVolume < Chef::Provisioning::AWSDriver::AWSResourceWithEntry
+  aws_sdk_type AWS::EC2::Volume, backcompat_data_bag_name: 'ebs_volumes'
 
-  actions :create, :delete, :nothing
-  default_action :create
+  attribute :name,    kind_of: String, name_attribute: true
 
-  stored_attribute :volume_id
-  stored_attribute :created_at
+  attribute :machine,           kind_of: [ String, FalseClass, AwsInstance, AWS::EC2::Instance ]
 
-  attribute :name, :kind_of => String, :name_attribute => true
-  attribute :volume_name, :kind_of => String
+  attribute :availability_zone, kind_of: String
+  attribute :size,              kind_of: Integer
+  attribute :snapshot,          kind_of: String
 
-  attribute :size
-  attribute :mount_point
-  attribute :availability_zone
+  attribute :iops,              kind_of: Integer
+  attribute :volume_type,       kind_of: String
+  attribute :encrypted,         kind_of: [ TrueClass, FalseClass ]
+  attribute :device,            kind_of: String
 
+  attribute :volume_id,         kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^vol-[a-f0-9]{8}$/ ? name : nil
+  }
 
-  def initialize(*args)
-    super
+  def aws_object
+    driver, id = get_driver_and_id
+    result = driver.ec2.volumes[id] if id
+    result && result.exists? && ![:deleted, :deleting].include?(result.status) ? result : nil
   end
-
-  def after_created
-    super
-  end
-
-
 end

data/lib/chef/resource/aws_eip_address.rb

@@ -1,29 +1,54 @@
-require 'chef/resource/aws_resource'
-require 'chef/provisioning/aws_driver'
-require 'chef/provisioning/machine_spec'
-
-class Chef::Resource::AwsEipAddress < Chef::Resource::AwsResource
-  self.resource_name = 'aws_eip_address'
-  self.databag_name = 'eip_addresses'
-
-  actions :create, :delete, :nothing, :associate, :disassociate
-  default_action :associate
-
-  stored_attribute :public_ip
-  stored_attribute :domain
-
-  attribute :name, :kind_of => String, :name_attribute => true
-  attribute :associate_to_vpc, :kind_of => [TrueClass, FalseClass], :default => false
-  attribute :machine, :kind_of => String
-  attribute :instance_id, :kind_of => String
-
-  def initialize(*args)
-    super
+require 'chef/provisioning/aws_driver/aws_resource_with_entry'
+require 'ipaddr'
+
+class Chef::Resource::AwsEipAddress < Chef::Provisioning::AWSDriver::AWSResourceWithEntry
+  aws_sdk_type AWS::EC2::ElasticIp, option_names: [ :public_ip ], id: :public_ip, managed_entry_id_name: 'public_ip', backcompat_data_bag_name: 'eip_addresses'
+
+  attribute :name, kind_of: String, name_attribute: true
+
+  # TODO network interface
+  attribute :machine,          kind_of: [String, FalseClass]
+  attribute :associate_to_vpc, kind_of: [TrueClass, FalseClass]
+
+  #
+  # Desired public IP address to associate with this Chef resource.
+  #
+  # Defaults to 'name' if name is an IP address.
+  #
+  # If the IP address is already allocated to your account, Chef will ensure it is
+  # linked to the current .  Thus, this is a way to associate an existing AWS IP
+  # with Chef:
+  #
+  # ```ruby
+  # aws_eip_address 'frontend_ip' do
+  #   public_ip '205.32.21.0'
+  # end
+  # ```
+  #
+  attribute :public_ip, kind_of: String, aws_id_attribute: true, coerce: proc { |v| IPAddr.new(v); v },
+    lazy_default: proc {
+      begin
+        IPAddr.new(name)
+        name
+      rescue
+      end
+    }
+
+  def aws_object
+    driver, public_ip = get_driver_and_id
+    result = driver.ec2.elastic_ips[public_ip] if public_ip
+    result && result.exists? ? result : nil
   end
 
-  def after_created
-    super
+  def action(*args)
+    # Backcompat for associate and disassociate
+    if args == [ :associate ]
+      super(:create)
+    elsif args == [ :disassociate ]
+      machine false
+      super(:create)
+    else
+      super
+    end
   end
-
-
 end

data/lib/chef/resource/aws_image.rb

@@ -0,0 +1,20 @@
+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
+
+  attribute :name, kind_of: String,  name_attribute: true
+
+  attribute :image_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^ami-[a-f0-9]{8}$/ ? name : nil
+  }
+
+  def aws_object
+    driver, id = get_driver_and_id
+    result = driver.ec2.images[id] if id
+    result && result.exists? ? result : nil
+  end
+end

data/lib/chef/resource/aws_instance.rb

@@ -0,0 +1,20 @@
+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
+
+  attribute :name, kind_of: String, name_attribute: true
+
+  attribute :instance_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^i-[a-f0-9]{8}$/ ? name : nil
+  }
+
+  def aws_object
+    driver, id = get_driver_and_id
+    result = driver.ec2.instances[id] if id
+    result && result.exists? ? result : nil
+  end
+end

data/lib/chef/resource/aws_internet_gateway.rb

@@ -0,0 +1,16 @@
+require 'chef/provisioning/aws_driver/aws_resource'
+
+class Chef::Resource::AwsInternetGateway < Chef::Provisioning::AWSDriver::AWSResource
+  aws_sdk_type AWS::EC2::InternetGateway, load_provider: false, id: :id
+
+  attribute :name, kind_of: String, name_attribute: true
+
+  attribute :internet_gateway_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^igw-[a-f0-9]{8}$/ ? name : nil
+  }
+
+  def aws_object
+    result = driver.ec2.internet_gateways[internet_gateway_id]
+    result && result.exists? ? result : nil
+  end
+end

data/lib/chef/resource/aws_key_pair.rb

@@ -1,11 +1,7 @@
-require 'chef/provisioning'
-require 'chef/resource/aws_resource'
+require 'chef/provisioning/aws_driver/aws_resource'
 
-class Chef::Resource::AwsKeyPair < Chef::Resource::AwsResource
-  self.resource_name = 'aws_key_pair'
-
-  actions :create, :delete, :nothing
-  default_action :create
+class Chef::Resource::AwsKeyPair < Chef::Provisioning::AWSDriver::AWSResource
+  aws_sdk_type AWS::EC2::KeyPair, id: :name
 
   # Private key to use as input (will be generated if it does not exist)
   attribute :private_key_path, :kind_of => String
@@ -17,8 +13,8 @@ class Chef::Resource::AwsKeyPair < Chef::Resource::AwsResource
   # TODO what is the right default for this?
   attribute :allow_overwrite, :kind_of => [TrueClass, FalseClass], :default => false
 
-  # Proc that runs after the resource completes.  Called with (resource, private_key, public_key)
-  def after(&block)
-    block ? @after = block : @after
+  def aws_object
+    result = driver.ec2.key_pairs[name]
+    result && result.exists? ? result : nil
   end
 end

data/lib/chef/resource/aws_launch_configuration.rb

@@ -0,0 +1,15 @@
+require 'chef/provisioning/aws_driver/aws_resource'
+
+class Chef::Resource::AwsLaunchConfiguration < Chef::Provisioning::AWSDriver::AWSResource
+  aws_sdk_type AWS::AutoScaling::LaunchConfiguration, id: :name
+
+  attribute :name,          kind_of: String, name_attribute: true
+  attribute :image,         kind_of: [ String, AWS::EC2::Image ]
+  attribute :instance_type, kind_of: String
+  attribute :options,       kind_of: Hash,   default: {}
+
+  def aws_object
+    result = driver.auto_scaling.launch_configurations[name]
+    result && result.exists? ? result : nil
+  end
+end

data/lib/chef/resource/aws_load_balancer.rb

@@ -0,0 +1,16 @@
+require 'chef/provisioning/aws_driver/aws_resource'
+
+class Chef::Resource::AwsLoadBalancer < Chef::Provisioning::AWSDriver::AWSResource
+  aws_sdk_type AWS::ELB::LoadBalancer, load_provider: false
+
+  attribute :name, kind_of: String,  name_attribute: true
+
+  attribute :load_balancer_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^elb-[a-f0-9]{8}$/ ? name : nil
+  }
+
+  def aws_object
+    result = driver.elb.load_balancers[name]
+    result && result.exists? ? result : nil
+  end
+end

data/lib/chef/resource/aws_network_interface.rb

@@ -0,0 +1,16 @@
+require 'chef/provisioning/aws_driver/aws_resource'
+
+class Chef::Resource::AwsNetworkInterface < Chef::Provisioning::AWSDriver::AWSResource
+  aws_sdk_type AWS::EC2::NetworkInterface, load_provider: false, id: :id
+
+  attribute :name, kind_of: String, name_attribute: true
+
+  attribute :network_interface_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^eni-[a-f0-9]{8}$/ ? name : nil
+  }
+
+  def aws_object
+    result = driver.ec2.network_interfaces[network_interface_id]
+    result && result.exists? ? result : nil
+  end
+end

data/lib/chef/resource/aws_route_table.rb

@@ -0,0 +1,76 @@
+require 'chef/provisioning/aws_driver/aws_resource_with_entry'
+
+#
+# An AWS route table, specifying where to route traffic destined for particular
+# sets of IPs.
+#
+# `name` is not guaranteed unique for an AWS account; therefore, Chef will
+# store the route table ID associated with this name in your Chef server in the
+# data bag `data/aws_route_Table/<name>`.
+#
+# API documentation for the AWS Ruby SDK for VPCs (and the object returned from `aws_object` can be found here:
+#
+# - http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/EC2/RouteTable.html
+#
+class Chef::Resource::AwsRouteTable < Chef::Provisioning::AWSDriver::AWSResourceWithEntry
+  aws_sdk_type AWS::EC2::RouteTable
+
+  require 'chef/resource/aws_vpc'
+
+  #
+  # The name of this route table.
+  #
+  attribute :name,   kind_of: String, name_attribute: true
+
+  #
+  # The VPC of this route table.
+  #
+  # May be one of:
+  # - The name of an `aws_vpc` Chef resource.
+  # - An actual `aws_vpc` resource.
+  # - An AWS `VPC` object.
+  #
+  # This is required for new route tables.
+  #
+  attribute :vpc,    kind_of: [ String, AwsVpc, AWS::EC2::VPC ], required: true
+
+  #
+  # The routes for this route table.
+  #
+  # If specified, this must be a complete specification of all routes: it will
+  # add any new routes and remove any old ones.
+  #
+  # This is in the form of a Hash, like so:
+  #
+  # ```ruby
+  # main_routes '10.0.0.0/8' => 'internal_vpn',
+  #             '0.0.0.0/0' => :internet_gateway
+  # ```
+  #
+  # The destination (the left side of the `=>`) is always a CIDR block.
+  # The target (the right side of the `=>`) can be one of several things:
+  # - { internet_gateway: <AWS Internet Gateway ID or object> }
+  # - { instance: <Chef machine name or resource, AWS Instance ID or object> }
+  # - { network_interface: <AWS Network Interface ID or object> }
+  # - <AWS Internet Gateway, Instance or Network Interface <ID or object)>
+  # - Chef machine name
+  # - Chef machine resource
+  #
+  attribute :routes, kind_of: Hash
+
+  attribute :route_table_id, kind_of: String, aws_id_attribute: true, lazy_default: proc {
+    name =~ /^rtb-[a-f0-9]{8}$/ ? name : nil
+  }
+
+  def aws_object
+    driver, id = get_driver_and_id
+    result = driver.ec2.route_tables[id] if id
+    begin
+      # try accessing it to find out if it exists
+      result.vpc if result
+    rescue AWS::EC2::Errors::InvalidRouteTableID::NotFound
+      result = nil
+    end
+    result
+  end
+end