chef-provisioning-aws 0.1.3 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eda6856be96232e40cce33671b0ed5b92ea9b693
-  data.tar.gz: 58a87deccbffab115c4799f7244030e1d60021d8
+  metadata.gz: d4f9c82b6a8923c933077a7055cc31c083291527
+  data.tar.gz: 886d034e57402dacb17d143c1e18e9bb94129a99
 SHA512:
-  metadata.gz: d9b18ddd408a632dd03005160807a3fd398f9326009df0dfe27b270860a0beeba6173bca3c39feec22b990ead226075e1507fa35b89689a4d98078341658952b
-  data.tar.gz: ef03d0848060e8bc2097eba525cc33f61d22fcc5ee544205f3ba09af55b75ea8597dc654c41f8d471a216a89900edef409a95b606a20d066a3e2e44b7f8b7a64
+  metadata.gz: 21596d7e34ff111450d05400eb681844bf8321a1721d409020c5ab7227591f333ff9eb9799b8f4b98526a888a75b5ba066e66026226787c0546477aa7873d65f
+  data.tar.gz: d32aa0894bb97de809bc3bea3ba855c1820cb2aca2208e3a1276b1c00d83ce90ad689cc05b4be90706b3f49c2788e015834c455e7c8ad2bd5d85d8a73deea0b9

data/lib/chef/provider/aws_s3_bucket.rb

@@ -7,23 +7,22 @@ class Chef::Provider::AwsS3Bucket < Chef::Provider::AwsProvider
       converge_by "Creating new S3 bucket #{fqn}" do
         bucket = s3.buckets.create(fqn)
         bucket.tags['Name'] = new_resource.name
-        if new_resource.enable_website_hosting
-          bucket.website_configuration = AWS::S3::WebsiteConfiguration.new(
-            new_resource.website_options)
-        end
       end
-    elsif requires_modification?
-      converge_by "Modifying S3 Bucket #{fqn}" do
-        if existing_bucket.website_configuration == nil && new_resource.enable_website_hosting || 
-          existing_bucket.website_configuration != nil && new_resource.enable_website_hosting
+    end
+    
+    if modifies_website_configuration?
+      if new_resource.enable_website_hosting
+        converge_by "Setting website configuration for bucket #{fqn}" do
           existing_bucket.website_configuration = AWS::S3::WebsiteConfiguration.new(
             new_resource.website_options)
-        else
-          existing_bucket.remove_website_configuration
+        end
+      else
+        converge_by "Disabling website configuration for bucket #{fqn}" do
+          existing_bucket.website_configuration = nil
         end
       end
     end
-
+    new_resource.endpoint "#{fqn}.s3-website-#{s3_website_endpoint_region}.amazonaws.com"
     new_resource.save
   end
 
@@ -37,31 +36,42 @@ class Chef::Provider::AwsS3Bucket < Chef::Provider::AwsProvider
     new_resource.delete
   end
 
-
   def existing_bucket
     Chef::Log.debug("Checking for S3 bucket #{fqn}")
     @existing_bucket ||= s3.buckets[fqn] if s3.buckets[fqn].exists?
   end
 
-  def requires_modification?
-    if existing_bucket.website_configuration == nil
-      new_resource.enable_website_hosting
-    else
-      !new_resource.enable_website_hosting ||
-        !compare_website_configuration
-    end
-  end
-
-  def compare_website_configuration
+  def modifies_website_configuration?
     # This is incomplete, routing rules have many optional values, so its
     # possible aws will put in default values for those which won't be in
     # the requested config.
     new_web_config = new_resource.website_options
-    current_web_config = existing_bucket.website_configuration.to_hash
+    current_web_config = current_website_configuration
+
+    !!existing_bucket.website_configuration != new_resource.enable_website_hosting || 
+      (current_web_config[:index_document] != new_web_config.fetch(:index_document, {}) ||
+      current_web_config[:error_document] != new_web_config.fetch(:error_document, {}) ||
+      current_web_config[:routing_rules] != new_web_config.fetch(:routing_rules, []))
+  end
 
-    current_web_config[:index_document] == new_web_config.fetch(:index_document, {}) &&
-      current_web_config[:error_document] == new_web_config.fetch(:error_document, {}) &&
-      current_web_config[:routing_rules] == new_web_config.fetch(:routing_rules, [])
+  def current_website_configuration
+    if existing_bucket.website_configuration
+      existing_bucket.website_configuration.to_hash
+    else
+      {}
+    end
+  end
+
+  def s3_website_endpoint_region
+    # ¯\_(ツ)_/¯
+    case existing_bucket.location_constraint
+    when nil, 'US'
+      'us-east-1'
+    when 'EU'
+      'eu-west-1'
+    else
+      existing_bucket.location_constraint
+    end
   end
 
   # Fully qualified bucket name (i.e resource_region unless otherwise specified)

data/lib/chef/provider/aws_subnet.rb

@@ -0,0 +1,52 @@
+require 'chef/provider/aws_provider'
+require 'date'
+
+class Chef::Provider::AwsSubnet < Chef::Provider::AwsProvider
+
+  action :create do
+    fail "Can't create a Subnet without a CIDR block" if new_resource.cidr_block.nil?
+
+    if existing_subnet == nil
+      converge_by "Creating new Subnet #{fqn} in VPC #{new_resource.vpc} in #{new_resource.region_name}" do
+        opts = { :vpc => vpc_id }
+	opts[:availability_zone] = new_resource.availability_zone if new_resource.availability_zone
+        subnet = ec2.subnets.create(new_resource.cidr_block, opts)
+        subnet.tags['Name'] = new_resource.name
+        subnet.tags['VPC'] = new_resource.vpc
+        new_resource.subnet_id subnet.id
+        new_resource.save
+      end
+    end
+  end
+
+  action :delete do
+    if existing_subnet
+      converge_by "Deleting subnet #{fqn} in VPC #{new_resource.vpc} in #{new_resource.region_name}" do
+        existing_subnet.delete
+      end
+    end
+
+    new_resource.delete
+  end
+
+  def vpc_id
+    @vpc_id ||= begin
+      ec2.vpcs.with_tag('Name', new_resource.vpc).first
+    rescue
+      nil
+    end
+  end
+
+  def existing_subnet
+      @subnet_id ||= begin
+      ec2.subnets.with_tag('Name', new_resource.name).first
+    rescue
+      nil
+    end
+  end
+
+  def id
+    new_resource.subnet_id
+  end
+
+end

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

@@ -15,7 +15,8 @@ require 'chef/provisioning/aws_driver/credentials'
 
 require 'yaml'
 require 'aws-sdk-v1'
-
+# loads the entire aws-sdk
+AWS.eager_autoload!
 
 class Chef
 module Provisioning
@@ -28,7 +29,7 @@ module AWSDriver
     attr_reader :region
 
     # URL scheme:
-    # aws:account_id:region
+    # aws:profilename:region
     # TODO: migration path from fog:AWS - parse that URL
     # canonical URL calls realpath on <path>
     def self.from_url(driver_url, config)
@@ -37,17 +38,21 @@ module AWSDriver
 
     def initialize(driver_url, config)
       super
-      credentials = aws_credentials.default
-      @region = credentials[:region]
+
+      _, profile_name, region = driver_url.split(':')
+      profile_name = nil if profile_name && profile_name.empty?
+      region = nil if region && region.empty?
+
+      credentials = profile_name ? aws_credentials[profile_name] : aws_credentials.default
+      @region = region || credentials[:region]
       # TODO: fix credentials here
       AWS.config(:access_key_id => credentials[:aws_access_key_id],
                  :secret_access_key => credentials[:aws_secret_access_key],
-                 :region => credentials[:region])
+                 :region => @region)
     end
 
     def self.canonicalize_url(driver_url, config)
-      url = driver_url.split(":")[0]
-      [ "aws:#{url}", config ]
+      [ driver_url, config ]
     end
 
 
@@ -200,12 +205,61 @@ module AWSDriver
 
     # Image methods
     def allocate_image(action_handler, image_spec, image_options, machine_spec)
+      actual_image = image_for(image_spec)
+      if actual_image.nil? || !actual_image.exists? || actual_image.state == :failed
+        action_handler.perform_action "Create image #{image_spec.name} from machine #{machine_spec.name} with options #{image_options.inspect}" do
+          image_options[:name] ||= image_spec.name
+          image_options[:instance_id] ||= machine_spec.location['instance_id']
+          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)
+          image_spec.location = {
+            'driver_url' => driver_url,
+            'driver_version' => Chef::Provisioning::AWSDriver::VERSION,
+            'image_id' => image.id,
+            'allocated_at' => Time.now.to_i
+          }
+          image_spec.machine_options ||= {}
+          image_spec.machine_options.merge!({
+            :bootstrap_options => {
+                :image_id => image.id
+            }
+          })
+        end
+      end
     end
 
     def ready_image(action_handler, image_spec, image_options)
+      actual_image = image_for(image_spec)
+      if actual_image.nil? || !actual_image.exists?
+        raise 'Cannot ready an image that does not exist'
+      else
+        if actual_image.state != :available
+          action_handler.report_progress 'Waiting for image to be ready ...'
+          wait_until_ready_image(action_handler, image_spec, actual_image)
+        else
+          action_handler.report_progress "Image #{image_spec.name} is ready!"
+        end
+      end
     end
 
     def destroy_image(action_handler, image_spec, image_options)
+      actual_image = image_for(image_spec)
+      snapshots = snapshots_for(image_spec)
+      if actual_image.nil? || !actual_image.exists?
+        Chef::Log.warn "Image #{image_spec.name} doesn't exist"
+      else
+        action_handler.perform_action "De-registering image #{image_spec.name}" do
+          actual_image.deregister
+        end
+        unless snapshots.any?
+          action_handler.perform_action "Deleting image #{image_spec.name} snapshots" do
+            snapshots.each do |snap|
+              snap.delete
+            end
+          end
+        end
+      end
     end
 
     # Machine methods
@@ -213,7 +267,7 @@ module AWSDriver
       actual_instance = instance_for(machine_spec)
       if actual_instance == nil || !actual_instance.exists? || actual_instance.status == :terminated
         image_id = machine_options[:image_id] || default_ami_for_region(@region)
-        bootstrap_options = machine_options[:bootstrap_options] || {}
+        bootstrap_options = (machine_options[:bootstrap_options] || {}).to_h.dup
         bootstrap_options[:image_id] = image_id
         if !bootstrap_options[:key_name]
           Chef::Log.debug('No key specified, generating a default one...')
@@ -224,6 +278,8 @@ module AWSDriver
         action_handler.perform_action "Create #{machine_spec.name} with AMI #{image_id} in #{@region}" do
           Chef::Log.debug "Creating instance with bootstrap options #{bootstrap_options}"
           instance = ec2.instances.create(bootstrap_options)
+          # Make sure the instance is ready to be tagged
+          sleep 5 while instance.status == :pending
           # TODO add other tags identifying user / node url (same as fog)
           instance.tags['Name'] = machine_spec.name
           machine_spec.location = {
@@ -234,10 +290,23 @@ module AWSDriver
               'image_id' => machine_options[:image_id],
               'instance_id' => instance.id
           }
+          machine_spec.location['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
+          %w(is_windows ssh_username sudo use_private_ip_for_ssh ssh_gateway).each do |key|
+            machine_spec.location[key] = machine_options[key.to_sym] if machine_options[key.to_sym]
+          end
         end
       end
     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
+    end
+
     def ready_machine(action_handler, machine_spec, machine_options)
       instance = instance_for(machine_spec)
 
@@ -246,18 +315,27 @@ module AWSDriver
       end
 
       if instance.status != :running
-        wait_until(action_handler, machine_spec, instance) { instance.status != :stopping }
+        wait_until_machine(action_handler, machine_spec, instance) { instance.status != :stopping }
         if instance.status == :stopped
           action_handler.perform_action "Start #{machine_spec.name} (#{machine_spec.location['instance_id']}) in #{@region} ..." do
             instance.start
           end
         end
-        wait_until_ready(action_handler, machine_spec, instance)
+        wait_until_ready_machine(action_handler, machine_spec, instance)
         wait_for_transport(action_handler, machine_spec, machine_options)
       end
 
       machine_for(machine_spec, machine_options, instance)
+    end
+
+    def connect_to_machine(name, chef_server = nil)
+      if name.is_a?(MachineSpec)
+        machine_spec = name
+      else
+        machine_spec = Chef::Provisioning::ChefMachineSpec.get(name, chef_server)
+      end
 
+      machine_for(machine_spec, machine_spec.location)
     end
 
     def destroy_machine(action_handler, machine_spec, machine_options)
@@ -332,8 +410,37 @@ module AWSDriver
     def instance_for(machine_spec)
       if machine_spec.location && machine_spec.location['instance_id']
         ec2.instances[machine_spec.location['instance_id']]
-      else
-        nil
+      end
+    end
+
+    def instances_for(machine_specs)
+      result = {}
+      machine_specs.each do |machine_spec|
+        if machine_spec.location && machine_spec.location['instance_id']
+          if machine_spec.location['driver_url'] != driver_url
+            raise "Switching a machine's driver from #{machine_spec.location['driver_url']} to #{driver_url} is not currently supported!  Use machine :destroy and then re-create the machine on the new driver."
+          end
+          #returns nil if not found
+          result[machine_spec] = ec2.instances[machine_spec.location['instance_id']]
+        end
+      end
+      result
+    end
+
+    def image_for(image_spec)
+      if image_spec.location && image_spec.location['image_id']
+        ec2.images[image_spec.location['image_id']]
+      end
+    end
+
+    def snapshots_for(image_spec)
+      if image_spec.location && image_spec.location['image_id']
+        actual_image = image_for(image_spec)
+        snapshots = []
+        actual_image.block_device_mappings.each do |dev, opts|
+            snapshots << ec2.snapshots[opts[:snapshot_id]]
+        end
+        snapshots
       end
     end
 
@@ -457,28 +564,49 @@ module AWSDriver
 
     def convergence_strategy_for(machine_spec, machine_options)
       # Tell Ohai that this is an EC2 instance so that it runs the EC2 plugin
-      machine_options[:convergence_options] ||= {}
-      machine_options[:convergence_options][:ohai_hints] = { 'ec2' => ''}
+      convergence_options = Cheffish::MergedConfig.new(
+        machine_options[:convergence_options] || {},
+        ohai_hints: { 'ec2' => '' })
 
       # Defaults
       if !machine_spec.location
-        return Chef::Provisioning::ConvergenceStrategy::NoConverge.new(machine_options[:convergence_options], config)
+        return Chef::Provisioning::ConvergenceStrategy::NoConverge.new(convergence_options, config)
       end
 
       if machine_spec.location['is_windows']
-        Chef::Provisioning::ConvergenceStrategy::InstallMsi.new(machine_options[:convergence_options], config)
+        Chef::Provisioning::ConvergenceStrategy::InstallMsi.new(convergence_options, config)
       elsif machine_options[:cached_installer] == true
-        Chef::Provisioning::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
+        Chef::Provisioning::ConvergenceStrategy::InstallCached.new(convergence_options, config)
       else
-        Chef::Provisioning::ConvergenceStrategy::InstallSh.new(machine_options[:convergence_options], config)
+        Chef::Provisioning::ConvergenceStrategy::InstallSh.new(convergence_options, config)
+      end
+    end
+
+    def wait_until_ready_image(action_handler, image_spec, image=nil)
+      wait_until_image(action_handler, image_spec, image) { image.state == :available }
+    end
+
+    def wait_until_image(action_handler, image_spec, image=nil, &block)
+      image ||= image_for(image_spec)
+      time_elapsed = 0
+      sleep_time = 10
+      max_wait_time = 120
+      if !yield(image)
+        action_handler.report_progress "waiting for #{image_spec.name} (#{image.id} on #{driver_url}) to be ready ..."
+        while time_elapsed < 120 && !yield(image)
+          action_handler.report_progress "been waiting #{time_elapsed}/#{max_wait_time} -- sleeping #{sleep_time} seconds for #{image_spec.name} (#{image.id} on #{driver_url}) to be ready ..."
+          sleep(sleep_time)
+          time_elapsed += sleep_time
+        end
+        action_handler.report_progress "Image #{image_spec.name} is now ready"
       end
     end
 
-    def wait_until_ready(action_handler, machine_spec, instance=nil)
-      wait_until(action_handler, machine_spec, instance) { instance.status == :running }
+    def wait_until_ready_machine(action_handler, machine_spec, instance=nil)
+      wait_until_machine(action_handler, machine_spec, instance) { instance.status == :running }
     end
 
-    def wait_until(action_handler, machine_spec, instance=nil, &block)
+    def wait_until_machine(action_handler, machine_spec, instance=nil, &block)
       instance ||= instance_for(machine_spec)
       time_elapsed = 0
       sleep_time = 10
@@ -540,12 +668,86 @@ module AWSDriver
       end
 
       # Only warn the first time
-      default_warning = 'Using default key, which is not shared between machines!  It is recommended to create an AWS key pair with the fog_key_pair resource, and set :bootstrap_options => { :key_name => <key name> }'
+      default_warning = 'Using default key, which is not shared between machines!  It is recommended to create an AWS key pair with the aws_key_pair resource, and set :bootstrap_options => { :key_name => <key name> }'
       Chef::Log.warn(default_warning) if updated
 
       default_key_name
     end
 
+    def create_servers(action_handler, specs_and_options, parallelizer, &block)
+      specs_and_servers = instances_for(specs_and_options.keys)
+
+      by_bootstrap_options = {}
+      specs_and_options.each do |machine_spec, machine_options|
+        actual_instance = specs_and_servers[machine_spec]
+        if actual_instance
+          if actual_instance.status == :terminated
+            Chef::Log.warn "Machine #{machine_spec.name} (#{actual_instance.id}) is terminated.  Recreating ..."
+          else
+            yield machine_spec, actual_instance if block_given?
+            next
+          end
+        elsif machine_spec.location
+          Chef::Log.warn "Machine #{machine_spec.name} (#{machine_spec.location['instance_id']} on #{driver_url}) no longer exists.  Recreating ..."
+        end
+
+        bootstrap_options = machine_options[:bootstrap_options] || {}
+        by_bootstrap_options[bootstrap_options] ||= []
+        by_bootstrap_options[bootstrap_options] << machine_spec
+      end
+
+      # Create the servers in parallel
+      parallelizer.parallelize(by_bootstrap_options) do |bootstrap_options, machine_specs|
+        machine_description = if machine_specs.size == 1
+          "machine #{machine_specs.first.name}"
+        else
+          "machines #{machine_specs.map { |s| s.name }.join(", ")}"
+        end
+        description = [ "creating #{machine_description} on #{driver_url}" ]
+        bootstrap_options.each_pair { |key,value| description << "  #{key}: #{value.inspect}" }
+        action_handler.report_progress description
+        if action_handler.should_perform_actions
+          # Actually create the servers
+          create_many_instances(machine_specs.size, bootstrap_options, parallelizer) do |instance|
+
+            # Assign each one to a machine spec
+            machine_spec = machine_specs.pop
+            machine_options = specs_and_options[machine_spec]
+            machine_spec.location = {
+              'driver_url' => driver_url,
+              'driver_version' => Chef::Provisioning::AWSDriver::VERSION,
+              'allocated_at' => Time.now.utc.to_s,
+              'host_node' => action_handler.host_node,
+              'image_id' => bootstrap_options[:image_id],
+              'instance_id' => instance.id
+            }
+            instance.tags['Name'] = machine_spec.name
+            machine_spec.location['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
+            %w(is_windows ssh_username sudo use_private_ip_for_ssh ssh_gateway).each do |key|
+              machine_spec.location[key] = machine_options[key.to_sym] if machine_options[key.to_sym]
+            end
+            action_handler.performed_action "machine #{machine_spec.name} created as #{instance.id} on #{driver_url}"
+
+            yield machine_spec, instance if block_given?
+          end
+
+          if machine_specs.size > 0
+            raise "Not all machines were created by create_servers"
+          end
+        end
+      end.to_a
+    end
+
+    def create_many_instances(num_servers, bootstrap_options, parallelizer)
+      parallelizer.parallelize(1.upto(num_servers)) do |i|
+        clean_bootstrap_options = Marshal.load(Marshal.dump(bootstrap_options))
+        instance = ec2.instances.create(clean_bootstrap_options)
+
+        yield instance if block_given?
+        instance
+      end.to_a
+    end
+
   end
 end
 end

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

@@ -1,4 +1,4 @@
-resources = %w(sqs_queue sns_topic ebs_volume s3_bucket auto_scaling_group launch_config vpc security_group eip_address)
+resources = %w(sqs_queue sns_topic ebs_volume s3_bucket auto_scaling_group launch_config vpc security_group eip_address subnet)
 
 resources.each do |r|
   Chef::Log.debug "AWS driver loading resource: #{r}"

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

@@ -1,7 +1,7 @@
 class Chef
 module Provisioning
 module AWSDriver
-  VERSION = '0.1.3'
+  VERSION = '0.2'
 end
 end
 end

data/lib/chef/resource/aws_s3_bucket.rb

@@ -13,6 +13,8 @@ class Chef::Resource::AwsS3Bucket < Chef::Resource::AwsResource
   attribute :enable_website_hosting, :kind_of => [TrueClass, FalseClass], :default => false
   attribute :website_options, :kind_of => Hash
 
+  stored_attribute :endpoint
+
   def initialize(*args)
     super
   end

data/lib/chef/resource/aws_subnet.rb

@@ -0,0 +1,25 @@
+require 'chef/resource/aws_resource'
+require 'chef/provisioning/aws_driver'
+
+class Chef::Resource::AwsSubnet < Chef::Resource::AwsResource
+  self.resource_name = 'aws_subnet'
+  self.databag_name = 'aws_subnet'
+
+  actions :create, :delete, :nothing
+  default_action :create
+
+  attribute :name, :kind_of => String, :name_attribute => true
+  attribute :cidr_block, :kind_of => String
+  attribute :vpc, :kind_of => String
+  attribute :availability_zone, :kind_of => String
+
+  stored_attribute :subnet_id
+
+  def initialize(*args)
+    super
+  end
+
+  def after_created
+    super
+  end
+end

metadata

@@ -1,97 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-aws
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: '0.2'
 platform: ruby
 authors:
 - John Ewart
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-15 00:00:00.000000000 Z
+date: 2015-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 11.16.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 11.16.4
 - !ruby/object:Gem::Dependency
   name: chef-provisioning
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-v1
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Provisioner for creating aws containers in Chef Provisioning.
@@ -115,6 +115,7 @@ files:
 - lib/chef/provider/aws_security_group.rb
 - lib/chef/provider/aws_sns_topic.rb
 - lib/chef/provider/aws_sqs_queue.rb
+- lib/chef/provider/aws_subnet.rb
 - lib/chef/provider/aws_vpc.rb
 - lib/chef/provisioning/aws_driver.rb
 - lib/chef/provisioning/aws_driver/aws_profile.rb
@@ -123,9 +124,7 @@ files:
 - lib/chef/provisioning/aws_driver/resources.rb
 - lib/chef/provisioning/aws_driver/version.rb
 - lib/chef/provisioning/driver_init/aws.rb
-- lib/chef/resource/.DS_Store
 - lib/chef/resource/aws_auto_scaling_group.rb
-- lib/chef/resource/aws_ebs_mount.rb
 - lib/chef/resource/aws_ebs_volume.rb
 - lib/chef/resource/aws_eip_address.rb
 - lib/chef/resource/aws_key_pair.rb
@@ -135,6 +134,7 @@ files:
 - lib/chef/resource/aws_security_group.rb
 - lib/chef/resource/aws_sns_topic.rb
 - lib/chef/resource/aws_sqs_queue.rb
+- lib/chef/resource/aws_subnet.rb
 - lib/chef/resource/aws_vpc.rb
 - spec/spec_helper.rb
 - spec/unit/aws_driver/credentials_spec.rb
@@ -147,12 +147,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -162,3 +162,4 @@ signing_key:
 specification_version: 4
 summary: Provisioner for creating aws containers in Chef Provisioning.
 test_files: []
+has_rdoc: 

data/lib/chef/resource/aws_ebs_mount.rb

@@ -1,31 +0,0 @@
-require 'chef/resource/aws_resource'
-require 'chef_metal_aws'
-
-class Chef::Resource::AwsEbsVolume < Chef::Resource::AwsResource
-  self.resource_name = 'aws_ebs_mount'
-  self.databag_name = 'ebs_mounts'
-
-  actions :create, :delete, :nothing
-  default_action :create
-
-  stored_attribute :instance_id
-  stored_attribute :volume_id
-
-  attribute :name, :kind_of => String, :name_attribute => true
-  attribute :volume_name, :kind_of => String
-
-  attribute :size
-  attribute :mount_point
-  attribute :availability_zone
-
-
-  def initialize(*args)
-    super
-  end
-
-  def after_created
-    super
-  end
-
-
-end