chef-provisioning-fog 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db6ee7ec27d271fb3880b648dcaab0aa3dc6c3e3
-  data.tar.gz: 3562d4b915fae443ef15cbe7f48e9a1bf5d0af40
+  metadata.gz: 538fa22ee7ffaaad27677cbd067e99179a59cc37
+  data.tar.gz: da1a648fc1a069032f7fa60f8028a2e8bfbbe021
 SHA512:
-  metadata.gz: 510f83a7ecc7ef0ab683e767fc0490039b2f812fe6827fbbf46cf85034d05663d974676ec6f8e4891413decb4409d12fc5d08649ba45c6dd8e659fe0c979cbea
-  data.tar.gz: 318681b378186a7219bae547ad29b96eaac2b2053a97f93a0a15fd38150388790eee279bfb91549c8542e4b455b024db5222346dd339cf096c3243ca9f373ed9
+  metadata.gz: 6b4f738999c7633d975d6f60dadedb2efe3a350c290a312aa6a44aea95074520d41abfbda8783dee07024ef471a3943b79d210d39f129683e8e9d97eb4c84d37
+  data.tar.gz: 49d849f17d4187c47f397908b763c2fa41374c26953ab3abd2c4943bce670a5f533521e7843280074f90cc20ae1084d0f531877aa27204775c0e6ab3609b4c95

data/Gemfile

@@ -8,4 +8,5 @@ group :development do
   gem 'guard-rspec'
   gem 'rb-readline'
   gem 'simplecov'
+  gem 'winrm-elevated'
 end

data/chef-provisioning-fog.gemspec

@@ -13,6 +13,7 @@ Gem::Specification.new do |s|
   s.homepage = 'https://github.com/opscode/chef-provisioning-fog'
 
   s.add_dependency 'chef-provisioning', '>= 1.0', '< 3.0'
+  s.add_dependency 'cheffish', '~> 4.0.0'
   s.add_dependency 'fog', '>= 1.37.0'
   s.add_dependency 'google-api-client', "~> 0.8.0"
   s.add_dependency 'fog-softlayer' , '~> 1.1.0'

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

@@ -267,6 +267,8 @@ module FogDriver
 
     # Not meant to be part of public interface
     def transport_for(machine_spec, machine_options, server, action_handler = nil)
+      Chef::Log.debug("Creating transport for #{server}")
+      Chef::Log.debug("Machine Spec: #{machine_spec}")
       if machine_spec.reference['is_windows']
         action_handler.report_progress "Waiting for admin password on #{machine_spec.name} to be ready (may take up to 15 minutes)..." if action_handler
         transport = create_winrm_transport(machine_spec, machine_options, server)
@@ -296,7 +298,7 @@ module FogDriver
     end
 
     def create_servers(action_handler, specs_and_options, parallelizer, &block)
-      specs_and_servers = servers_for(specs_and_options.keys)
+      specs_and_servers = servers_for(specs_and_options)
 
       # Get the list of servers which exist, segmented by their bootstrap options
       # (we will try to create a set of servers for each set of bootstrap options
@@ -324,7 +326,7 @@ module FogDriver
           'allocated_at' => Time.now.to_i
         )
 
-        bootstrap_options = bootstrap_options_for(action_handler, machine_spec, machine_options)
+        bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
         machine_spec.reference['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
         by_bootstrap_options[bootstrap_options] ||= []
         by_bootstrap_options[bootstrap_options] << machine_spec
@@ -551,9 +553,9 @@ module FogDriver
       end
     end
 
-    def servers_for(machine_specs)
+    def servers_for(specs_and_options)
       result = {}
-      machine_specs.each do |machine_spec|
+      machine_specs.each do |machine_spec, machine_options|
         if machine_spec.reference
           if machine_spec.reference['driver_url'] != driver_url
             raise "Switching a machine's driver from #{machine_spec.reference['driver_url']} to #{driver_url} for is not currently supported!  Use machine :destroy and then re-create the machine on the new driver."
@@ -590,7 +592,7 @@ module FogDriver
       'chef_default'
     end
 
-    def bootstrap_options_for(action_handler, machine_spec, machine_options)
+    def bootstrap_options_for(machine_spec, machine_options)
       bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
 
       bootstrap_options[:tags]  = default_tags(machine_spec, bootstrap_options[:tags] || {})
@@ -669,6 +671,8 @@ module FogDriver
         IO.read(bootstrap_options[:key_path])
       elsif bootstrap_options[:key_name]
         get_private_key(bootstrap_options[:key_name])
+      elsif machine_options.has_key?(:ssh_options) && machine_options[:ssh_options].has_key?(:keys)
+        IO.read(machine_options[:ssh_options][:keys].first)
       else
         # TODO make a way to suggest other keys to try ...
         raise "No key found to connect to #{machine_spec.name} (#{machine_spec.reference.inspect})" \

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

@@ -13,7 +13,7 @@ module FogDriver
         compute_options[:joyent_username]
       end
 
-      def bootstrap_options_for(action_handler, machine_spec, machine_options)
+      def bootstrap_options_for(machine_spec, machine_options)
         bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
 
         bootstrap_options[:tags] = default_tags(machine_spec, bootstrap_options[:tags] || {})

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

@@ -39,7 +39,7 @@ class Chef
             [result, id]
           end
 
-          def bootstrap_options_for(action_handler, machine_spec, machine_options)
+          def bootstrap_options_for(machine_spec, machine_options)
             # probably best to only ADD options here since super class looks
             # for some values; for example, :key_name doesn't get saved to
             # chef_provisioning.reference if you remove it here.
@@ -104,9 +104,9 @@ class Chef
               end
           end
 
-          def servers_for(machine_specs)
+          def servers_for(specs_and_options)
             result = {}
-            machine_specs.each do |machine_spec|
+            specs_and_options.each do |machine_spec, _machine_options|
               result[machine_spec] = server_for(machine_spec)
             end
 

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

@@ -1,38 +1,28 @@
-#   fog:Vcair:<client id>
+#   fog:vcair:<vcair host>
 class Chef
   module Provisioning
     module FogDriver
       module Providers
         class Vcair < FogDriver::Driver
-          Driver.register_provider_class('Vcair', FogDriver::Providers::Vcair)
+          Driver.register_provider_class('vcair', FogDriver::Providers::Vcair)
 
           def creator
-            Chef::Config[:knife][:vcair_username]
+            driver_options[:username]
+          end
+
+          def initialize(driver_url, config)
+            super(driver_url, config)
+
+            @auth_params = {provider: 'vclouddirector'}
+            _fog, _vcair, @auth_params[:vcloud_director_host] = driver_url.split(':', 3)
+            @auth_params[:vcloud_director_username] = "#{driver_options[:username]}@#{driver_options[:org]}"
+            @auth_params[:vcloud_director_password] = driver_options[:password]
+            @auth_params[:vcloud_director_show_progress] = driver_options[:show_progress] || false
+            Chef::Log.debug('Initialized driver for vcair')
           end
 
           def compute
             @compute ||= begin
-                           Chef::Log.debug("vcair_username #{Chef::Config[:knife][:vcair_username]}")
-                           Chef::Log.debug("vcair_org #{Chef::Config[:knife][:vcair_org]}")
-                           Chef::Log.debug("vcair_api_host #{Chef::Config[:knife][:vcair_api_host]}")
-                           #Chef::Log.debug("vcair_api_version #{Chef::Config[:knife][:vcair_api_version]}")
-                           Chef::Log.debug("vcair_show_progress #{Chef::Config[:knife][:vcair_show_progress]}")
-
-                           username = [
-                             Chef::Config[:knife][:vcair_username],
-                             Chef::Config[:knife][:vcair_org]
-                           ].join('@')
-
-                           @auth_params = {
-                             :provider => 'vclouddirector', #TODO: see compute_options_for, and grab else where
-                             :vcloud_director_username => username,
-                             :vcloud_director_password => Chef::Config[:knife][:vcair_password],
-                             :vcloud_director_host => Chef::Config[:knife][:vcair_api_host],
-                             #:vcair_api_host => Chef::Config[:knife][:vcair_api_host],
-                             :vcloud_director_api_version => Chef::Config[:knife][:vcair_api_version],
-                             :vcloud_director_show_progress => false
-                           }
-
                            Fog::Compute.new(@auth_params)
                          rescue Excon::Errors::Unauthorized => e
                            error_message = "Connection failure, please check your username and password."
@@ -45,6 +35,23 @@ class Chef
                          end
           end
 
+          # Overrides the parent method and adds some additional vCloud specific metadata
+          def create_servers(action_handler, specs_and_options, parallelizer, &block)
+
+            specs_and_options.each do |machine_spec, machine_options|
+              machine_spec.reference ||= {}
+              # Add some vCloud info to the machine_spec
+              bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+              machine_spec.reference['vdc'] = vdc(bootstrap_options).name
+              machine_spec.reference['net'] = net(bootstrap_options).name
+
+              # Save the key and whether we're using sudo
+              machine_spec.reference['key_name'] = bootstrap_options[:key_name] if bootstrap_options.has_key?(:key_name)
+              machine_spec.reference['sudo'] = bootstrap_options[:sudo] if bootstrap_options.has_key?(:sudo)
+            end
+
+            super
+          end
 
           def create_many_servers(num_servers, bootstrap_options, parallelizer)
             parallelizer.parallelize(1.upto(num_servers)) do |i|
@@ -52,25 +59,36 @@ class Chef
               vm=nil
               begin
                 begin
+                  Chef::Log.debug('Creating vApp...')
                   instantiate(clean_bootstrap_options)
+                  Chef::Log.debug('Created vApp')
                 rescue Fog::Errors::Error => e
                   unless e.minor_error_code == "DUPLICATE_NAME"
                     # if it's already there, just use the current one
                     raise e
                   end
+                  Chef::Log.warn('Found existing vApp with the same name!')
                 end
-
-                vapp = vdc.vapps.get_by_name(bootstrap_options[:name])
-                vm = vapp.vms.find {|v| v.vapp_name == bootstrap_options[:name]}
+                vdc = vdc(clean_bootstrap_options)
+
+                Chef::Log.debug("Searching for #{bootstrap_options[:name]}...")
+                vapp = vdc.vapps.get_by_name(clean_bootstrap_options[:name])
+                raise "Couldn't find vApp #{bootstrap_options[:name]} that was just created!" if vapp.nil?
+                vm = vapp.vms.find {|v| v.vapp_name == clean_bootstrap_options[:name]}
+                raise "No VMs found in vApp!" if vm.nil?
+                Chef::Log.debug("Found #{vm.name}")
                 update_customization(clean_bootstrap_options, vm)
 
                 if bootstrap_options[:cpus]
-                  vm.cpu = bootstrap_options[:cpus]
+                  vm.cpu = clean_bootstrap_options[:cpus]
                 end
                 if bootstrap_options[:memory]
-                  vm.memory = bootstrap_options[:memory]
+                  vm.memory = clean_bootstrap_options[:memory]
                 end
-                update_network(bootstrap_options, vapp, vm)
+
+                Chef::Log.debug("Updating network for #{vm.name}...")
+                update_network(clean_bootstrap_options, vapp, vm)
+                Chef::Log.debug("Updated network for #{vm.name}")
 
               rescue Excon::Errors::BadRequest => e
                 response = Chef::JSONCompat.from_json(e.response.body)
@@ -107,10 +125,10 @@ class Chef
             # NOTE: vCloud Air Fog does not get server.status via http every time
             server.reload
 
-            if server.status == 'off' or server.status != 'on'
+            if server.status == 'off' || server.status != 'on'
               action_handler.perform_action "start machine #{machine_spec.name} (#{server.id} on #{driver_url})" do
                 server.power_on
-                machine_spec.location['started_at'] = Time.now.to_i
+                machine_spec.reference['started_at'] = Time.now.to_i
               end
               machine_spec.save(action_handler)
             end
@@ -118,12 +136,13 @@ class Chef
 
 
           def server_for(machine_spec)
-            if machine_spec.location
-              vapp = vdc.vapps.get_by_name(machine_spec.name)
+            if machine_spec.reference
+              Chef::Log.debug("Checking for VDC #{machine_spec.reference['vdc']}...")
+              vapp = org.vdcs.get_by_name(machine_spec.reference['vdc']).vapps.get_by_name(machine_spec.name)
 
               server = unless vapp.nil?
                          unless vapp.vms.first.nil?
-                           vapp.vms.find{|vm| vm.id == machine_spec.location['server_id'] }
+                           vapp.vms.find{|vm| vm.id == machine_spec.reference['server_id'] }
                          end
                        end
             else
@@ -131,26 +150,27 @@ class Chef
             end
           end
 
-          def servers_for(machine_specs)
+          def servers_for(specs_and_options)
             result = {}
-            machine_specs.each do |machine_spec|
-              server_for(machine_spec)
+            specs_and_options.each do |machine_spec, _machine_options|
+              result[machine_spec] = server_for(machine_spec)
             end
             result
           end
 
-          def ssh_options_for(machine_spec, machine_options, server)
-            { auth_methods: [ 'password' ],
-              timeout: (machine_options[:ssh_timeout] || 600),
-              password: machine_options[:ssh_password]
-            }.merge(machine_options[:ssh_options] || {})
-          end
+          # def ssh_options_for(machine_spec, machine_options, server)
+          #   ssh_options = {
+          #     auth_methods: ['password'],
+          #     timeout: (machine_options[:ssh_timeout] || 600),
+          #     password: machine_options[:ssh_password]
+          #   }.merge(machine_options[:ssh_options] || {})
+          # end
 
           def create_ssh_transport(machine_spec, machine_options, server)
             ssh_options = ssh_options_for(machine_spec, machine_options, server)
-            username = machine_spec.location['ssh_username'] || default_ssh_username
+            username = machine_spec.reference['ssh_username'] || default_ssh_username
             options = {}
-            if machine_spec.location[:sudo] || (!machine_spec.location.has_key?(:sudo) && username != 'root')
+            if machine_spec.reference[:sudo] || (!machine_spec.reference.has_key?(:sudo) && username != 'root')
               options[:prefix] = 'sudo '
             end
 
@@ -165,7 +185,7 @@ class Chef
 
             #Enable pty by default
             options[:ssh_pty_enable] = true
-            options[:ssh_gateway] = machine_spec.location['ssh_gateway'] if machine_spec.location.has_key?('ssh_gateway')
+            options[:ssh_gateway] = machine_spec.reference['ssh_gateway'] if machine_spec.reference.has_key?('ssh_gateway')
 
             Transport::SSH.new(remote_host, username, ssh_options, options, config)
           end
@@ -190,7 +210,7 @@ class Chef
               wait_for_transport(action_handler, machine_spec, machine_options, server)
             rescue Fog::Errors::TimeoutError
               # Only ever reboot once, and only if it's been less than 10 minutes since we stopped waiting
-              if machine_spec.location['started_at'] || remaining_wait_time(machine_spec, machine_options) < -(10*60)
+              if machine_spec.reference['started_at'] || remaining_wait_time(machine_spec, machine_options) < -(10*60)
                 raise
               else
                 # Sometimes (on EC2) the machine comes up but gets stuck or has
@@ -207,50 +227,64 @@ class Chef
           end
 
           def org
-            @org ||= compute.organizations.get_by_name(Chef::Config[:knife][:vcair_org])
+            @org ||= compute.organizations.get_by_name(driver_options[:org])
           end
 
-          def vdc
-            if Chef::Config[:knife][:vcair_vdc]
-              @vdc ||= org.vdcs.get_by_name(Chef::Config[:knife][:vcair_vdc])
+          def vdc(bootstrap_options)
+            if bootstrap_options[:vdc]
+              @vdc ||= org.vdcs.get_by_name(bootstrap_options[:vdc])
+              raise "VDC #{bootstrap_options[:vdc]} not found" unless @vdc
             else
               @vdc ||= org.vdcs.first
+              raise 'No VDC found' unless @vdc
             end
+
+            Chef::Log.debug("VDC set to #{@vdc.name}")
+            @vdc
           end
 
-          def net
-            if Chef::Config[:knife][:vcair_net]
-              @net ||= org.networks.get_by_name(Chef::Config[:knife][:vcair_net])
+          def net(bootstrap_options)
+            if bootstrap_options[:net]
+              @net ||= org.networks.get_by_name(bootstrap_options[:net])
+              raise "Network #{bootstrap_options[:net]} not found" unless @net
             else
               # Grab first non-isolated (bridged, natRouted) network
               @net ||= org.networks.find { |n| n if !n.fence_mode.match("isolated") }
+              raise 'No non-isolated network found' unless @net
             end
+
+            Chef::Log.debug("Network set to #{@net.name}")
+            @net
           end
 
           def template(bootstrap_options)
-            # TODO: find by catalog item ID and/or NAME
-            # TODO: add option to search just public and/or private catalogs
-
-            #TODO: maybe make a hash for caching
-            org.catalogs.map do |cat|
-              #cat.catalog_items.get_by_name(config_value(:image))
-              cat.catalog_items.get_by_name(bootstrap_options[:image_name])
-            end.compact.first
+            # If we specify a catalog name, search for the image in it,
+            # otherwise return the first image we find in any catalog.
+            if bootstrap_options[:catalog_name].nil?
+              #TODO: maybe make a hash for caching
+              org.catalogs.map do |cat|
+                #cat.catalog_items.get_by_name(config_value(:image))
+                cat.catalog_items.get_by_name(bootstrap_options[:image_name])
+              end.compact.first
+            else
+              catalog = org.catalogs.get_by_name(bootstrap_options[:catalog_name])
+              raise "No catalog named #{bootstrap_options[:catalog_name]} could be found!" if catalog.nil?
+              catalog.catalog_items.get_by_name(bootstrap_options[:image_name])
+            end
           end
 
           def instantiate(bootstrap_options)
-            begin
-              #node_name = config_value(:chef_node_name)
-              node_name = bootstrap_options[:name]
-              template(bootstrap_options).instantiate(
-                node_name,
-                vdc_id: vdc.id,
-                network_id: net.id,
-                description: "id:#{node_name}")
-              #rescue CloudExceptions::ServerCreateError => e
-            rescue => e
-              raise e
-            end
+            #node_name = config_value(:chef_node_name)
+            node_name = bootstrap_options[:name]
+            vdc = vdc(bootstrap_options)
+            net = net(bootstrap_options)
+
+            template(bootstrap_options).instantiate(
+              node_name,
+              vdc_id: vdc.id,
+              network_id: net.id,
+              description: "id:#{node_name}")
+            #rescue CloudExceptions::ServerCreateError => e
           end
 
           # Create a WinRM transport for a vCloud Air Vapp VM instance
@@ -259,7 +293,7 @@ class Chef
           # @param [Fog::Compute::Server] server A Fog mapping to the AWS instance
           # @return [ChefMetal::Transport::WinRM] A WinRM Transport object to talk to the server
           def create_winrm_transport(machine_spec, machine_options, server)
-            port = machine_spec.location['winrm_port'] || 5985
+            port = machine_spec.reference['winrm_port'] || 5985
             endpoint = "http://#{server.ip_address}:#{port}/wsman"
             type = :plaintext
 
@@ -276,6 +310,7 @@ class Chef
           end
 
           def update_customization(bootstrap_options, server)
+            Chef::Log.debug("Customizing vApp: #{server.name}")
             ## Initialization before first power on.
             custom=server.customization
 
@@ -291,9 +326,9 @@ class Chef
                                          end
             password = case bootstrap_options[:protocol]
                        when 'ssh'
-                         bootstrap_options[:ssh_options][:password]
+                         bootstrap_options[:ssh_options][:password] unless bootstrap_options[:ssh_options].nil?
                        when 'winrm'
-                         bootstrap_options[:winrm_options][:password]
+                         bootstrap_options[:winrm_options][:password] unless bootstrap_options[:winrm_options].nil?
                        end
 
             if password
@@ -313,11 +348,16 @@ class Chef
 
             # DNS and Windows want AlphaNumeric and dashes for hostnames
             # Windows can only handle 15 character hostnames
-            # TODO: only change name for Windows!
-            #c.computer_name = config_value(:chef_node_name).gsub(/\W/,"-").slice(0..14)
-            custom.computer_name = bootstrap_options[:name].gsub(/\W/,"-").slice(0..14)
+            custom.computer_name = case server.operating_system
+                                   when /Windows/
+                                     bootstrap_options[:name].gsub(/\W/,"-").slice(0..14)
+                                   else
+                                     bootstrap_options[:name]
+                                   end
+
             custom.enabled = true
             custom.save
+            Chef::Log.debug("vApp customized: #{server.name}")
           end
 
           ## vCloud Air
@@ -331,7 +371,11 @@ class Chef
             #vapp = vdc.vapps.get_by_name(bootstrap_options[:name])
             #vm = vapp.vms.find {|v| v.vapp_name == bootstrap_options[:name]}
             return if vm.ip_address != "" # return if ip address is set, as this isn't a new VM
+            Chef::Log.debug('No IP address found.  Must be a new VM.')
+            net = net(bootstrap_options)
+            Chef::Log.debug("Searching for network: #{net.name}")
             nc = vapp.network_config.find { |netc| netc if netc[:networkName].match(net.name) }
+            Chef::Log.debug("Found network configuration: #{nc}")
             networks_config = [nc]
             section = {PrimaryNetworkConnectionIndex: 0}
             section[:NetworkConnection] = networks_config.compact.each_with_index.map do |network, i|
@@ -360,23 +404,24 @@ class Chef
             compute.process_task(nc_task)
           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[:name] ||= machine_spec.name
+          def self.bootstrap_options_for(machine_spec, machine_options)
+            bootstrap_options = machine_options.key?(:bootstrap_options) ? machine_options[:bootstrap_options] : {}
+            bootstrap_options[:name] = machine_spec.name unless machine_spec.nil?
 
-            bootstrap_options = bootstrap_options.merge(machine_options.configs[1])
             bootstrap_options
           end
 
           def destroy_machine(action_handler, machine_spec, machine_options)
             server = server_for(machine_spec)
+            Chef::Log.info("Destroying machine #{machine_spec.name}...")
+            bootstrap_options = bootstrap_options_for(machine_spec, machine_options)
+            vdc = vdc(bootstrap_options)
             if server && server.status != 'archive' # TODO: does vCloud Air do archive?
-              action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
+              action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.reference['server_id']} at #{driver_url})" do
                 #NOTE: currently doing 1 vm for 1 vapp
                 vapp = vdc.vapps.get_by_name(machine_spec.name)
                 if vapp
+                  Chef::Log.debug("Found vApp #{machine_spec.name}")
                   vapp.power_off
                   vapp.undeploy
                   vapp.destroy
@@ -385,7 +430,7 @@ class Chef
                 end
               end
             end
-            machine_spec.location = nil
+            machine_spec.reference = nil
             strategy = convergence_strategy_for(machine_spec, machine_options)
             strategy.cleanup_convergence(action_handler, machine_spec)
           end

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

@@ -11,7 +11,7 @@ class Chef
             compute_options[:xenserver_username]
           end
 
-          def bootstrap_options_for(action_handler, machine_spec, machine_options)
+          def bootstrap_options_for(machine_spec, machine_options)
             bootstrap_options = super
             bootstrap_options[:tags] = bootstrap_options[:tags].map {|k,v| "#{k}: #{v}" }
             bootstrap_options
@@ -56,9 +56,9 @@ class Chef
             end
           end
 
-          def servers_for(machine_specs)
+          def servers_for(specs_and_options)
             result = {}
-            machine_specs.each do |machine_spec|
+            specs_and_options.each do |machine_spec, _machine_options|
               if machine_spec.reference
                 if machine_spec.reference['driver_url'] != driver_url
                   raise "Switching a machine's driver from #{machine_spec.reference['driver_url']} to #{driver_url} for is not currently supported!  Use machine :destroy and then re-create the machine on the new driver."
@@ -209,7 +209,7 @@ end
 # Otherwise machine_batch will fail since parallel calls will clash.
 #
 # See http://ruby-doc.org//stdlib-2.1.1//libdoc/xmlrpc/rdoc/XMLRPC/Client.html
-# 
+#
 module Fog
   module XenServer
     class Connection

data/lib/chef/provisioning/fog_driver/recipe_dsl.rb

@@ -26,7 +26,7 @@ class Chef
       end
 
       def with_fog_vcair_driver(driver_options = nil, &block)
-        with_fog_driver('Vcair', driver_options, &block)
+        with_fog_driver('vcair', driver_options, &block)
       end
 
       def with_fog_scaleway_driver(driver_options = nil, &block)

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

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module FogDriver
-      VERSION = '0.21.0'
+      VERSION = '0.22.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-fog
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors:
 - John Keiser
@@ -34,6 +34,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: cheffish
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: fog
   requirement: !ruby/object:Gem::Requirement