chef-provisioning-fog 0.15.0 → 0.15.1

data/lib/chef/provisioning/fog_driver/providers/google.rb

@@ -1,85 +1,85 @@
-class Chef
-  module Provisioning
-    module FogDriver
-      module Providers
-        class Google < FogDriver::Driver
-          Driver.register_provider_class('Google', FogDriver::Providers::Google)
-
-          def creator
-            ''
-          end
-
-          def converge_floating_ips(action_handler, machine_spec, machine_options, server)
-          end
-
-          def server_for(machine_spec)
-            if machine_spec.name
-              compute.servers.get(machine_spec.name)
-            else
-              nil
-            end
-          end
-
-          def servers_for(machine_specs)
-            result = {}
-            machine_specs.each do |machine_spec|
-              result[machine_spec] = server_for(machine_spec)
-            end
-            result
-          end
-
-          def bootstrap_options_for(action_handler, machine_spec, machine_options)
-            bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
-            bootstrap_options[:image_name] ||= 'debian-7-wheezy-v20150325'
-            bootstrap_options[:machine_type] ||= 'n1-standard-1'
-            bootstrap_options[:zone_name] ||= 'europe-west1-b'
-            bootstrap_options[:name] ||= machine_spec.name
-            bootstrap_options[:disk_size] ||= 10
-
-            if bootstrap_options[:disks].nil?
-              # create the persistent boot disk
-              disk_defaults = {
-                :name => machine_spec.name,
-                :size_gb => bootstrap_options[:disk_size],
-                :zone_name => bootstrap_options[:zone_name],
-                :source_image => bootstrap_options[:image_name],
-              }
-
-              disk = compute.disks.create(disk_defaults)
-              disk.wait_for { disk.ready? }
-              bootstrap_options[:disks] = [disk]
-            end
-
-            bootstrap_options
-          end
-
-          def destroy_machine(action_handler, machine_spec, machine_options)
-            server = server_for(machine_spec)
-            if server && server.state != 'archive'
-              action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
-                server.destroy
-              end
-            end
-            machine_spec.location = nil
-            strategy = convergence_strategy_for(machine_spec, machine_options)
-            strategy.cleanup_convergence(action_handler, machine_spec)
-          end
-
-          def self.compute_options_for(provider, id, config)
-            new_compute_options = {}
-            new_compute_options[:provider] = provider
-            new_config = { :driver_options => { :compute_options => new_compute_options }}
-            new_defaults = {
-              :driver_options  => { :compute_options => {} },
-              :machine_options => { :bootstrap_options => {}, :ssh_options => {} }
-            }
-            result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
-
-            [result, '']
-          end
-
-        end
-      end
-    end
-  end
-end
+class Chef
+  module Provisioning
+    module FogDriver
+      module Providers
+        class Google < FogDriver::Driver
+          Driver.register_provider_class('Google', FogDriver::Providers::Google)
+
+          def creator
+            ''
+          end
+
+          def converge_floating_ips(action_handler, machine_spec, machine_options, server)
+          end
+
+          def server_for(machine_spec)
+            if machine_spec.name
+              compute.servers.get(machine_spec.name)
+            else
+              nil
+            end
+          end
+
+          def servers_for(machine_specs)
+            result = {}
+            machine_specs.each do |machine_spec|
+              result[machine_spec] = server_for(machine_spec)
+            end
+            result
+          end
+
+          def bootstrap_options_for(action_handler, machine_spec, machine_options)
+            bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+            bootstrap_options[:image_name] ||= 'debian-7-wheezy-v20150325'
+            bootstrap_options[:machine_type] ||= 'n1-standard-1'
+            bootstrap_options[:zone_name] ||= 'europe-west1-b'
+            bootstrap_options[:name] ||= machine_spec.name
+            bootstrap_options[:disk_size] ||= 10
+
+            if bootstrap_options[:disks].nil?
+              # create the persistent boot disk
+              disk_defaults = {
+                :name => machine_spec.name,
+                :size_gb => bootstrap_options[:disk_size],
+                :zone_name => bootstrap_options[:zone_name],
+                :source_image => bootstrap_options[:image_name],
+              }
+
+              disk = compute.disks.create(disk_defaults)
+              disk.wait_for { disk.ready? }
+              bootstrap_options[:disks] = [disk]
+            end
+
+            bootstrap_options
+          end
+
+          def destroy_machine(action_handler, machine_spec, machine_options)
+            server = server_for(machine_spec)
+            if server && server.state != 'archive'
+              action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
+                server.destroy
+              end
+            end
+            machine_spec.location = nil
+            strategy = convergence_strategy_for(machine_spec, machine_options)
+            strategy.cleanup_convergence(action_handler, machine_spec)
+          end
+
+          def self.compute_options_for(provider, id, config)
+            new_compute_options = {}
+            new_compute_options[:provider] = provider
+            new_config = { :driver_options => { :compute_options => new_compute_options }}
+            new_defaults = {
+              :driver_options  => { :compute_options => {} },
+              :machine_options => { :bootstrap_options => {}, :ssh_options => {} }
+            }
+            result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+            [result, '']
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef/provisioning/fog_driver/providers/joyent.rb

@@ -1,63 +1,63 @@
-require 'fog/joyent'
-
-#   fog:Joyent:<joyent_url>
-class Chef
-module Provisioning
-module FogDriver
-  module Providers
-    class Joyent < FogDriver::Driver
-
-      Driver.register_provider_class('Joyent', FogDriver::Providers::Joyent)
-
-      def creator
-        compute_options[:joyent_username]
-      end
-
-      def bootstrap_options_for(action_handler, machine_spec, machine_options)
-        bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
-
-        bootstrap_options[:tags] = default_tags(machine_spec, bootstrap_options[:tags] || {})
-
-        bootstrap_options[:tags].each do |key, val|
-          bootstrap_options["tag.#{key}"] = val
-        end
-
-        bootstrap_options[:name] ||= machine_spec.name
-
-        bootstrap_options
-      end
-
-      def find_floating_ips(server, action_handler)
-        []
-      end
-
-      def self.compute_options_for(provider, id, config)
-        new_compute_options = {}
-        new_compute_options[:provider] = provider
-        new_config = { :driver_options => { :compute_options => new_compute_options }}
-        new_defaults = {
-          :driver_options => { :compute_options => {} },
-          :machine_options => { :bootstrap_options => {} }
-        }
-        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
-
-        new_compute_options[:joyent_url] = id if (id && id != '')
-        credential = Fog.credentials
-
-        new_compute_options[:joyent_username] ||= credential[:joyent_username]
-        new_compute_options[:joyent_password] ||= credential[:joyent_password]
-        new_compute_options[:joyent_keyname] ||= credential[:joyent_keyname]
-        new_compute_options[:joyent_keyfile] ||= credential[:joyent_keyfile]
-        new_compute_options[:joyent_url] ||= credential[:joyent_url]
-        new_compute_options[:joyent_version] ||= credential[:joyent_version]
-
-        id = result[:driver_options][:compute_options][:joyent_url]
-
-        [result, id]
-      end
-
-    end
-  end
-end
-end
-end
+require 'fog/joyent'
+
+#   fog:Joyent:<joyent_url>
+class Chef
+module Provisioning
+module FogDriver
+  module Providers
+    class Joyent < FogDriver::Driver
+
+      Driver.register_provider_class('Joyent', FogDriver::Providers::Joyent)
+
+      def creator
+        compute_options[:joyent_username]
+      end
+
+      def bootstrap_options_for(action_handler, machine_spec, machine_options)
+        bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+
+        bootstrap_options[:tags] = default_tags(machine_spec, bootstrap_options[:tags] || {})
+
+        bootstrap_options[:tags].each do |key, val|
+          bootstrap_options["tag.#{key}"] = val
+        end
+
+        bootstrap_options[:name] ||= machine_spec.name
+
+        bootstrap_options
+      end
+
+      def find_floating_ips(server, action_handler)
+        []
+      end
+
+      def self.compute_options_for(provider, id, config)
+        new_compute_options = {}
+        new_compute_options[:provider] = provider
+        new_config = { :driver_options => { :compute_options => new_compute_options }}
+        new_defaults = {
+          :driver_options => { :compute_options => {} },
+          :machine_options => { :bootstrap_options => {} }
+        }
+        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+        new_compute_options[:joyent_url] = id if (id && id != '')
+        credential = Fog.credentials
+
+        new_compute_options[:joyent_username] ||= credential[:joyent_username]
+        new_compute_options[:joyent_password] ||= credential[:joyent_password]
+        new_compute_options[:joyent_keyname] ||= credential[:joyent_keyname]
+        new_compute_options[:joyent_keyfile] ||= credential[:joyent_keyfile]
+        new_compute_options[:joyent_url] ||= credential[:joyent_url]
+        new_compute_options[:joyent_version] ||= credential[:joyent_version]
+
+        id = result[:driver_options][:compute_options][:joyent_url]
+
+        [result, id]
+      end
+
+    end
+  end
+end
+end
+end

data/lib/chef/provisioning/fog_driver/providers/openstack.rb

@@ -1,117 +1,117 @@
-# fog:OpenStack:https://identifyhost:portNumber/v2.0
-class Chef
-module Provisioning
-module FogDriver
-  module Providers
-    class OpenStack < FogDriver::Driver
-
-      Driver.register_provider_class('OpenStack', FogDriver::Providers::OpenStack)
-
-      def creator
-        compute_options[:openstack_username]
-      end
-
-      def self.compute_options_for(provider, id, config)
-        new_compute_options = {}
-        new_compute_options[:provider] = provider
-        new_config = { :driver_options => { :compute_options => new_compute_options }}
-        new_defaults = {
-          :driver_options => { :compute_options => {} },
-          :machine_options => { :bootstrap_options => {} }
-        }
-        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
-
-        new_compute_options[:openstack_auth_url] = id if (id && id != '')
-        credential = Fog.credentials
-
-        new_compute_options[:openstack_username] ||= credential[:openstack_username]
-        new_compute_options[:openstack_api_key] ||= credential[:openstack_api_key]
-        new_compute_options[:openstack_auth_url] ||= credential[:openstack_auth_url]
-        new_compute_options[:openstack_tenant] ||= credential[:openstack_tenant]
-
-        id = result[:driver_options][:compute_options][:openstack_auth_url]
-
-        [result, id]
-      end
-
-      # Image methods
-      def allocate_image(action_handler, image_spec, image_options, machine_spec, machine_options)
-        image = image_for(image_spec)
-        if image
-          raise "The image already exists, why are you asking me to create it?  I can't do that, Dave."
-        end
-        action_handler.perform_action "Create image #{image_spec.name} from machine #{machine_spec.name} with options #{image_options.inspect}" do
-          response = compute.create_image(
-            machine_spec.reference['server_id'], image_spec.name,
-            {
-              description: "The Image named '#{image_spec.name}"
-            })
-
-          image_spec.reference = {
-            driver_url: driver_url,
-            driver_version: FogDriver::VERSION,
-            image_id: response.body['image']['id'],
-            creator: creator,
-            allocated_it: Time.new.to_i
-          }
-        end
-      end
-
-      def ready_image(action_handler, image_spec, image_options)
-        actual_image = image_for(image_spec)
-        if actual_image.nil?
-          raise 'Cannot ready an image that does not exist'
-        else
-          if actual_image.status != 'ACTIVE'
-            action_handler.report_progress 'Waiting for image to be active ...'
-            wait_until_ready_image(action_handler, image_spec, actual_image)
-          else
-            action_handler.report_progress "Image #{image_spec.name} is active!"
-          end
-        end
-      end
-
-      def destroy_image(action_handler, image_spec, image_options)
-        image = image_for(image_spec)
-        unless image.status == "DELETED"
-          image.destroy
-        end
-      end
-
-      def wait_until_ready_image(action_handler, image_spec, image=nil)
-        wait_until_image(action_handler, image_spec, image) { image.status == 'ACTIVE' }
-      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 = 300
-        if !yield(image)
-          action_handler.report_progress "waiting for image #{image_spec.name} (#{image.id} on #{driver_url}) to be active ..."
-          while time_elapsed < max_wait_time && !yield(image)
-           action_handler.report_progress "been waiting #{time_elapsed}/#{max_wait_time} -- sleeping #{sleep_time} seconds for image #{image_spec.name} (#{image.id} on #{driver_url}) to be ACTIVE instead of #{image.status}..."
-           sleep(sleep_time)
-           image.reload
-           time_elapsed += sleep_time
-          end
-          unless yield(image)
-            raise "Image #{image.id} did not become ready within #{max_wait_time} seconds"
-          end
-          action_handler.report_progress "Image #{image_spec.name} is now ready"
-        end
-      end
-
-      def image_for(image_spec)
-        if image_spec.reference
-          compute.images.get(image_spec.reference[:image_id]) || compute.images.get(image_spec.reference['image_id'])
-        else
-          nil
-        end
-      end
-
-    end
-  end
-end
-end
-end
+# fog:OpenStack:https://identifyhost:portNumber/v2.0
+class Chef
+module Provisioning
+module FogDriver
+  module Providers
+    class OpenStack < FogDriver::Driver
+
+      Driver.register_provider_class('OpenStack', FogDriver::Providers::OpenStack)
+
+      def creator
+        compute_options[:openstack_username]
+      end
+
+      def self.compute_options_for(provider, id, config)
+        new_compute_options = {}
+        new_compute_options[:provider] = provider
+        new_config = { :driver_options => { :compute_options => new_compute_options }}
+        new_defaults = {
+          :driver_options => { :compute_options => {} },
+          :machine_options => { :bootstrap_options => {} }
+        }
+        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+        new_compute_options[:openstack_auth_url] = id if (id && id != '')
+        credential = Fog.credentials
+
+        new_compute_options[:openstack_username] ||= credential[:openstack_username]
+        new_compute_options[:openstack_api_key] ||= credential[:openstack_api_key]
+        new_compute_options[:openstack_auth_url] ||= credential[:openstack_auth_url]
+        new_compute_options[:openstack_tenant] ||= credential[:openstack_tenant]
+
+        id = result[:driver_options][:compute_options][:openstack_auth_url]
+
+        [result, id]
+      end
+
+      # Image methods
+      def allocate_image(action_handler, image_spec, image_options, machine_spec, machine_options)
+        image = image_for(image_spec)
+        if image
+          raise "The image already exists, why are you asking me to create it?  I can't do that, Dave."
+        end
+        action_handler.perform_action "Create image #{image_spec.name} from machine #{machine_spec.name} with options #{image_options.inspect}" do
+          response = compute.create_image(
+            machine_spec.reference['server_id'], image_spec.name,
+            {
+              description: "The Image named '#{image_spec.name}"
+            })
+
+          image_spec.reference = {
+            driver_url: driver_url,
+            driver_version: FogDriver::VERSION,
+            image_id: response.body['image']['id'],
+            creator: creator,
+            allocated_it: Time.new.to_i
+          }
+        end
+      end
+
+      def ready_image(action_handler, image_spec, image_options)
+        actual_image = image_for(image_spec)
+        if actual_image.nil?
+          raise 'Cannot ready an image that does not exist'
+        else
+          if actual_image.status != 'ACTIVE'
+            action_handler.report_progress 'Waiting for image to be active ...'
+            wait_until_ready_image(action_handler, image_spec, actual_image)
+          else
+            action_handler.report_progress "Image #{image_spec.name} is active!"
+          end
+        end
+      end
+
+      def destroy_image(action_handler, image_spec, image_options)
+        image = image_for(image_spec)
+        unless image.status == "DELETED"
+          image.destroy
+        end
+      end
+
+      def wait_until_ready_image(action_handler, image_spec, image=nil)
+        wait_until_image(action_handler, image_spec, image) { image.status == 'ACTIVE' }
+      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 = 300
+        if !yield(image)
+          action_handler.report_progress "waiting for image #{image_spec.name} (#{image.id} on #{driver_url}) to be active ..."
+          while time_elapsed < max_wait_time && !yield(image)
+           action_handler.report_progress "been waiting #{time_elapsed}/#{max_wait_time} -- sleeping #{sleep_time} seconds for image #{image_spec.name} (#{image.id} on #{driver_url}) to be ACTIVE instead of #{image.status}..."
+           sleep(sleep_time)
+           image.reload
+           time_elapsed += sleep_time
+          end
+          unless yield(image)
+            raise "Image #{image.id} did not become ready within #{max_wait_time} seconds"
+          end
+          action_handler.report_progress "Image #{image_spec.name} is now ready"
+        end
+      end
+
+      def image_for(image_spec)
+        if image_spec.reference
+          compute.images.get(image_spec.reference[:image_id]) || compute.images.get(image_spec.reference['image_id'])
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end
+end
+end