chef-provisioning-fog 0.13.2 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e8d9aff16a913485687ea30699bc056f40f6550
-  data.tar.gz: 00049afa78c2598b84dd90a1fd019dd9655f4c5b
+  metadata.gz: 52b659938865f82a47d2bd233d5f9e4d62d4b708
+  data.tar.gz: ee9dc1faac3c6e1a2527fcd64079fd7b0521ae73
 SHA512:
-  metadata.gz: b95693417ce3f1791dd1e08ab1448c8250cb6c660aa2df21fe427dc8f0c1a43c927b59e89ca94bbdffe3c0654594a076fce3e0cf2fc21854c56a4666b8d5dc45
-  data.tar.gz: cd886bb181cad6dddb995d7bf0abecdf0fadd4df59cf2b9cf9bf5fcf238011a39f74bbb3088c2acbce46fd18f9030e735720d201892586ee4402455b0dadf8af
+  metadata.gz: 469dcadcf9ca2ad0e608de694abdc3a85b3e1dd9bb677330191ef0e86c2d3041c1197ad89a678718d17980c1ea983f4987805a3593d190760972d418ab865394
+  data.tar.gz: 28fc5d4cce8c2c1b77306d32fc5592bf83eeab2d1b18c82b433c2a272e345c9c7f4b0141296d22052b85dbb82d5cc5e8a3c04c9754777b8fd4f294a28ca37bca

data/README.md

@@ -1,3 +1,3 @@
 # chef-provisioning-fog
 
-This is the Fog driver for Chef Provisioning.  It provides EC2, Rackspace, DigitalOcean, SoftLayer, and Openstack functionality.
+This is the Fog driver for Chef Provisioning.  It provides Amazon EC2, Rackspace, DigitalOcean, SoftLayer, OpenStack, and vCloud Air functionality.

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

@@ -19,6 +19,7 @@ require 'fog/compute'
 require 'socket'
 require 'etc'
 require 'time'
+require 'retryable'
 require 'cheffish/merged_config'
 require 'chef/provisioning/fog_driver/recipe_dsl'
 
@@ -51,15 +52,15 @@ module FogDriver
   #
   # To add a new supported Fog provider, pick an appropriate identifier, go to
   # from_provider and compute_options_for, and add the new provider in the case
-  # statements so that URLs for your fog provider can be generated.  If your
+  # statements so that URLs for your Fog provider can be generated.  If your
   # cloud provider has environment variables or standard config files (like
   # ~/.aws/credentials or ~/.aws/config), you can read those and merge that information
   # in the compute_options_for function.
   #
-  # ## Location format
+  # ## Reference format
   #
-  # All machines have a location hash to find them.  These are the keys used by
-  # the fog provisioner:
+  # All machines have a reference hash to find them.  These are the keys used by
+  # the Fog provisioner:
   #
   # - driver_url: fog:<driver>:<unique_account_info>
   # - server_id: the ID of the server so it can be found again
@@ -102,6 +103,9 @@ module FogDriver
       :ssh_timeout => 20
     }
 
+    RETRYABLE_ERRORS = [Fog::Compute::AWS::Error]
+    RETRYABLE_OPTIONS = { tries: 12, sleep: 5, on: RETRYABLE_ERRORS }
+
     class << self
       alias :__new__ :new
 
@@ -149,7 +153,7 @@ module FogDriver
       Provisioning.driver_for_url(driver_url, config)
     end
 
-    # Create a new fog driver.
+    # Create a new Fog driver.
     #
     # ## Parameters
     # driver_url - URL of driver.  "fog:<provider>:<provider_id>"
@@ -211,7 +215,7 @@ module FogDriver
         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
@@ -235,9 +239,9 @@ module FogDriver
     def destroy_machine(action_handler, machine_spec, machine_options)
       server = server_for(machine_spec)
       if server
-        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
           server.destroy
-          machine_spec.location = nil
+          machine_spec.reference = nil
         end
       end
       strategy = convergence_strategy_for(machine_spec, machine_options)
@@ -254,7 +258,7 @@ module FogDriver
     end
 
     def image_for(image_spec)
-      compute.images.get(image_spec.location['image_id'])
+      compute.images.get(image_spec.reference['image_id'])
     end
 
     def compute
@@ -263,7 +267,7 @@ module FogDriver
 
     # Not meant to be part of public interface
     def transport_for(machine_spec, machine_options, server, action_handler = nil)
-      if machine_spec.location['is_windows']
+      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)
         action_handler.report_progress 'Admin password available ...' if action_handler
@@ -280,7 +284,7 @@ module FogDriver
     end
 
     def creator
-      raise "unsupported fog provider #{provider} (please implement #creator)"
+      raise "unsupported Fog provider #{provider} (please implement #creator)"
     end
 
     def create_servers(action_handler, specs_and_options, parallelizer, &block)
@@ -299,8 +303,8 @@ module FogDriver
             yield machine_spec, server if block_given?
             next
           end
-        elsif machine_spec.location
-          Chef::Log.warn "Machine #{machine_spec.name} (#{machine_spec.location['server_id']} on #{driver_url}) no longer exists.  Recreating ..."
+        elsif machine_spec.reference
+          Chef::Log.warn "Machine #{machine_spec.name} (#{machine_spec.reference['server_id']} on #{driver_url}) no longer exists.  Recreating ..."
         end
 
         bootstrap_options = bootstrap_options_for(action_handler, machine_spec, machine_options)
@@ -325,16 +329,16 @@ module FogDriver
             # Assign each one to a machine spec
             machine_spec = machine_specs.pop
             machine_options = specs_and_options[machine_spec]
-            machine_spec.location = {
+            machine_spec.reference = {
               'driver_url' => driver_url,
               'driver_version' => FogDriver::VERSION,
               'server_id' => server.id,
               'creator' => creator,
               'allocated_at' => Time.now.to_i
             }
-            machine_spec.location['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
+            machine_spec.reference['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]
+              machine_spec.reference[key] = machine_options[key.to_sym] if machine_options[key.to_sym]
             end
             action_handler.performed_action "machine #{machine_spec.name} created as #{server.id} on #{driver_url}"
 
@@ -368,7 +372,7 @@ module FogDriver
       if server.state == 'stopped'
         action_handler.perform_action "start machine #{machine_spec.name} (#{server.id} on #{driver_url})" do
           server.start
-          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
@@ -377,16 +381,16 @@ module FogDriver
     def restart_server(action_handler, machine_spec, server)
       action_handler.perform_action "restart machine #{machine_spec.name} (#{server.id} on #{driver_url})" do
         server.reboot
-        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
 
     def remaining_wait_time(machine_spec, machine_options)
-      if machine_spec.location['started_at']
-        timeout = option_for(machine_options, :start_timeout) - (Time.now.utc - parse_time(machine_spec.location['started_at']))
+      if machine_spec.reference['started_at']
+        timeout = option_for(machine_options, :start_timeout) - (Time.now.utc - parse_time(machine_spec.reference['started_at']))
       else
-        timeout = option_for(machine_options, :create_timeout) - (Time.now.utc - parse_time(machine_spec.location['allocated_at']))
+        timeout = option_for(machine_options, :create_timeout) - (Time.now.utc - parse_time(machine_spec.reference['allocated_at']))
       end
       timeout > 0 ? timeout : 0.01
     end
@@ -402,8 +406,10 @@ module FogDriver
     def wait_until_ready(action_handler, machine_spec, machine_options, server)
       if !server.ready?
         if action_handler.should_perform_actions
-          action_handler.report_progress "waiting for #{machine_spec.name} (#{server.id} on #{driver_url}) to be ready ..."
-          server.wait_for(remaining_wait_time(machine_spec, machine_options)) { ready? }
+          Retryable.retryable(RETRYABLE_OPTIONS) do |retries,exception|
+            action_handler.report_progress "waiting for #{machine_spec.name} (#{server.id} on #{driver_url}) to be ready, API attempt #{retries+1}/#{RETRYABLE_OPTIONS[:tries]} ..."
+            server.wait_for(remaining_wait_time(machine_spec, machine_options)) { ready? }
+          end
           action_handler.report_progress "#{machine_spec.name} is now ready"
         end
       end
@@ -414,12 +420,14 @@ module FogDriver
       transport = transport_for(machine_spec, machine_options, server, action_handler)
       if !transport.available?
         if action_handler.should_perform_actions
-          action_handler.report_progress "waiting for #{machine_spec.name} (#{server.id} on #{driver_url}) to be connectable (transport up and running) ..."
+          Retryable.retryable(RETRYABLE_OPTIONS) do |retries,exception|
+            action_handler.report_progress "waiting for #{machine_spec.name} (#{server.id} on #{driver_url}) to be connectable (transport up and running), API attempt #{retries+1}/#{RETRYABLE_OPTIONS[:tries]} ..."
 
-          _self = self
+            _self = self
 
-          server.wait_for(remaining_wait_time(machine_spec, machine_options)) do
-            transport.available?
+            server.wait_for(remaining_wait_time(machine_spec, machine_options)) do
+              transport.available?
+            end
           end
           action_handler.report_progress "#{machine_spec.name} is now connectable"
         end
@@ -429,7 +437,7 @@ module FogDriver
     def converge_floating_ips(action_handler, machine_spec, machine_options, server)
       pool = option_for(machine_options, :floating_ip_pool)
       floating_ip = option_for(machine_options, :floating_ip)
-      attached_floating_ips = find_floating_ips(server)
+      attached_floating_ips = find_floating_ips(server, action_handler)
       if pool
 
         Chef::Log.debug "Attaching IP from pool #{pool}"
@@ -467,12 +475,15 @@ module FogDriver
     end
 
     # Find all attached floating IPs from all networks
-    def find_floating_ips(server)
+    def find_floating_ips(server, action_handler)
       floating_ips = []
-      server.addresses.each do |network, addrs|
-        addrs.each do | full_addr |
-          if full_addr['OS-EXT-IPS:type'] == 'floating'
-            floating_ips << full_addr['addr']
+      Retryable.retryable(RETRYABLE_OPTIONS) do |retries,exception|
+        action_handler.report_progress "Querying for floating IPs attached to server #{server.id}, API attempt #{retries+1}/#{RETRYABLE_OPTIONS[:tries]} ..."
+        server.addresses.each do |network, addrs|
+          addrs.each do | full_addr |
+            if full_addr['OS-EXT-IPS:type'] == 'floating'
+              floating_ips << full_addr['addr']
+            end
           end
         end
       end
@@ -512,8 +523,8 @@ module FogDriver
     end
 
     def server_for(machine_spec)
-      if machine_spec.location
-        compute.servers.get(machine_spec.location['server_id'])
+      if machine_spec.reference
+        compute.servers.get(machine_spec.reference['server_id'])
       else
         nil
       end
@@ -522,11 +533,11 @@ module FogDriver
     def servers_for(machine_specs)
       result = {}
       machine_specs.each do |machine_spec|
-        if machine_spec.location
-          if machine_spec.location['driver_url'] != driver_url
-            raise "Switching a machine's driver from #{machine_spec.location['driver_url']} to #{driver_url} for is not currently supported!  Use machine :destroy and then re-create the machine on the new driver."
+        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."
           end
-          result[machine_spec] = compute.servers.get(machine_spec.location['server_id'])
+          result[machine_spec] = compute.servers.get(machine_spec.reference['server_id'])
         else
           result[machine_spec] = nil
         end
@@ -537,8 +548,8 @@ module FogDriver
     @@chef_default_lock = Mutex.new
 
     def overwrite_default_key_willy_nilly(action_handler, machine_spec)
-      if machine_spec.location &&
-         Gem::Version.new(machine_spec.location['driver_version']) < Gem::Version.new('0.10')
+      if machine_spec.reference &&
+         Gem::Version.new(machine_spec.reference['driver_version']) < Gem::Version.new('0.10')
         return 'metal_default'
       end
 
@@ -585,7 +596,7 @@ module FogDriver
         raise "Server for node #{machine_spec.name} has not been created!"
       end
 
-      if machine_spec.location['is_windows']
+      if machine_spec.reference['is_windows']
         Machine::WindowsMachine.new(machine_spec, transport_for(machine_spec, machine_options, server), convergence_strategy_for(machine_spec, machine_options))
       else
         Machine::UnixMachine.new(machine_spec, transport_for(machine_spec, machine_options, server), convergence_strategy_for(machine_spec, machine_options))
@@ -594,11 +605,11 @@ module FogDriver
 
     def convergence_strategy_for(machine_spec, machine_options)
       # Defaults
-      if !machine_spec.location
+      if !machine_spec.reference
         return ConvergenceStrategy::NoConverge.new(machine_options[:convergence_options], config)
       end
 
-      if machine_spec.location['is_windows']
+      if machine_spec.reference['is_windows']
         ConvergenceStrategy::InstallMsi.new(machine_options[:convergence_options], config)
       elsif machine_options[:cached_installer] == true
         ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
@@ -622,10 +633,10 @@ module FogDriver
           raise "Server has key name '#{server.key_name}', but the corresponding private key was not found locally.  Check if the key is in Chef::Config.private_key_paths: #{Chef::Config.private_key_paths.join(', ')}"
         end
         key
-      elsif machine_spec.location['key_name']
-        key = get_private_key(machine_spec.location['key_name'])
+      elsif machine_spec.reference['key_name']
+        key = get_private_key(machine_spec.reference['key_name'])
         if !key
-          raise "Server was created with key name '#{machine_spec.location['key_name']}', but the corresponding private key was not found locally.  Check if the key is in Chef::Config.private_key_paths: #{Chef::Config.private_key_paths.join(', ')}"
+          raise "Server was created with key name '#{machine_spec.reference['key_name']}', but the corresponding private key was not found locally.  Check if the key is in Chef::Config.private_key_paths: #{Chef::Config.private_key_paths.join(', ')}"
         end
         key
       elsif machine_options[:bootstrap_options][:key_path]
@@ -634,7 +645,7 @@ module FogDriver
         get_private_key(machine_options[:bootstrap_options][:key_name])
       else
         # TODO make a way to suggest other keys to try ...
-        raise "No key found to connect to #{machine_spec.name} (#{machine_spec.location.inspect})!"
+        raise "No key found to connect to #{machine_spec.name} (#{machine_spec.reference.inspect})!"
       end
     end
 
@@ -661,17 +672,17 @@ module FogDriver
 
     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
-      if machine_options.has_key?(:ssh_username) && machine_options[:ssh_username] != machine_spec.location['ssh_username']
-        Chef::Log.warn("Server #{machine_spec.name} was created with SSH username #{machine_spec.location['ssh_username']} and machine_options specifies username #{machine_options[:ssh_username]}.  Using #{machine_spec.location['ssh_username']}.  Please edit the node and change the chef_provisioning.location.ssh_username attribute if you want to change it.")
+      username = machine_spec.reference['ssh_username'] || default_ssh_username
+      if machine_options.has_key?(:ssh_username) && machine_options[:ssh_username] != machine_spec.reference['ssh_username']
+        Chef::Log.warn("Server #{machine_spec.name} was created with SSH username #{machine_spec.reference['ssh_username']} and machine_options specifies username #{machine_options[:ssh_username]}.  Using #{machine_spec.reference['ssh_username']}.  Please edit the node and change the chef_provisioning.reference.ssh_username attribute if you want to change it.")
       end
       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
 
       remote_host = nil
-      if machine_spec.location['use_private_ip_for_ssh']
+      if machine_spec.reference['use_private_ip_for_ssh']
         remote_host = server.private_ip_address
       elsif !server.public_ip_address
         Chef::Log.warn("Server #{machine_spec.name} has no public floating_ip address.  Using private floating_ip '#{server.private_ip_address}'.  Set driver option 'use_private_ip_for_ssh' => true if this will always be the case ...")
@@ -684,13 +695,13 @@ module FogDriver
 
       #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
 
     def self.compute_options_for(provider, id, config)
-      raise "unsupported fog provider #{provider}"
+      raise "unsupported Fog provider #{provider}"
     end
   end
 end

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

@@ -36,7 +36,7 @@ module FogDriver
         remote_host = if machine_spec.location['use_private_ip_for_ssh']
                         server.private_ip_address
                       elsif !server.public_ip_address
-                        Chef::Log.warn("Server #{machine_spec.name} has no public ip address.  Using private ip '#{server.private_ip_address}'.  Set driver option 'use_private_ip_for_ssh' => true if this will always be the case ...")
+                        Chef::Log.warn("Server #{machine_spec.name} has no public IP address.  Using private IP '#{server.private_ip_address}'.  Set driver option 'use_private_ip_for_ssh' => true if this will always be the case ...")
                         server.private_ip_address
                       elsif server.public_ip_address
                         server.public_ip_address
@@ -349,7 +349,7 @@ module FogDriver
               id = $1
               new_compute_options[:region] = $3
             else
-              Chef::Log.warn("Old-style AWS URL #{id} from an early beta of chef-metal (before 0.11-final) found. If you have servers in multiple regions on this account, you may see odd behavior like servers being recreated. To fix, edit any nodes with attribute chef_provisioning.location.driver_url to include the region like so: fog:AWS:#{id}:<region> (e.g. us-east-1)")
+              Chef::Log.warn("Old-style AWS URL #{id} from an early beta of chef-provisioning (before chef-metal 0.11-final) found. If you have servers in multiple regions on this account, you may see odd behavior like servers being recreated. To fix, edit any nodes with attribute chef_provisioning.location.driver_url to include the region like so: fog:AWS:#{id}:<region> (e.g. us-east-1)")
             end
           else
             # Assume it is a profile name, and set that.
@@ -384,7 +384,7 @@ module FogDriver
       end
 
       def create_many_servers(num_servers, bootstrap_options, parallelizer)
-        # Create all the servers in one request if we have a version of fog that can do that
+        # Create all the servers in one request if we have a version of Fog that can do that
         if compute.servers.respond_to?(:create_many)
           servers = compute.servers.create_many(num_servers, num_servers, bootstrap_options)
           if block_given?

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

@@ -11,7 +11,7 @@ module FogDriver
       end
 
       def converge_floating_ips(action_handler, machine_spec, machine_options, server)
-        # Digital ocean does not have floating IPs
+        # DigitalOcean does not have floating IPs
       end
 
       def bootstrap_options_for(action_handler, machine_spec, machine_options)

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

@@ -0,0 +1,84 @@
+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
+
+            if bootstrap_options[:disks].nil?
+              # create the persistent boot disk
+              disk_defaults = {
+                :name => machine_spec.name,
+                :size_gb => 10,
+                :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/vcair.rb

@@ -0,0 +1,376 @@
+#   fog:Vcair:<client id>
+class Chef
+  module Provisioning
+    module FogDriver
+      module Providers
+        class Vcair < FogDriver::Driver
+          Driver.register_provider_class('Vcair', FogDriver::Providers::Vcair)
+
+          def creator
+            Chef::Config[:knife][:vcair_username]
+          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."
+                           Chef::Log.error(error_message)
+                           raise "#{e.message}. #{error_message}"
+                         rescue Excon::Errors::SocketError => e
+                           error_message = "Connection failure, please check your authentication URL."
+                           Chef::Log.error(error_message)
+                           raise "#{e.message}. #{error_message}"
+                         end
+          end
+
+
+          def create_many_servers(num_servers, bootstrap_options, parallelizer)
+            parallelizer.parallelize(1.upto(num_servers)) do |i|
+              clean_bootstrap_options = Marshal.load(Marshal.dump(bootstrap_options)) # Prevent destructive operations on bootstrap_options.
+              vm=nil
+              begin
+                instantiate(clean_bootstrap_options)
+
+                vapp = vdc.vapps.get_by_name(bootstrap_options[:name])
+                vm = vapp.vms.find {|v| v.vapp_name == bootstrap_options[:name]}
+
+                update_customization(clean_bootstrap_options, vm)
+
+                if bootstrap_options[:cpus]
+                  vm.cpu = bootstrap_options[:cpus]
+                end
+                if bootstrap_options[:memory]
+                  vm.memory = bootstrap_options[:memory]
+                end
+                update_network(bootstrap_options, vapp, vm)
+
+              rescue Excon::Errors::BadRequest => e
+                response = Chef::JSONCompat.from_json(e.response.body)
+                if response['badRequest']['code'] == 400
+                  message = "Bad request (400): #{response['badRequest']['message']}"
+                  Chef::Log.error(message)
+                else
+                  message = "Unknown server error (#{response['badRequest']['code']}): #{response['badRequest']['message']}"
+                  Chef::Log.error(message)
+                end
+                raise message
+              rescue Fog::Errors::Error => e
+                raise e.message
+              end
+
+              yield vm if block_given?
+              vm
+
+            end.to_a
+          end
+
+
+          def start_server(action_handler, machine_spec, server)
+
+            # If it is stopping, wait for it to get out of "stopping" transition state before starting
+            if server.status == 'stopping'
+              action_handler.report_progress "wait for #{machine_spec.name} (#{server.id} on #{driver_url}) to finish stopping ..."
+              # vCloud Air
+              # NOTE: vCloud Air Fog does not get server.status via http every time
+              server.wait_for { server.reload ; server.status != 'stopping' }
+              action_handler.report_progress "#{machine_spec.name} is now stopped"
+            end
+
+            # NOTE: vCloud Air Fog does not get server.status via http every time
+            server.reload
+
+            if server.status == 'off' or 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
+              end
+              machine_spec.save(action_handler)
+            end
+          end
+
+
+          def server_for(machine_spec)
+            if machine_spec.location
+              vapp = 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'] }
+                         end
+                       end
+            else
+              nil
+            end
+          end
+
+          def servers_for(machine_specs)
+            result = {}
+            machine_specs.each do |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 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
+            options = {}
+            if machine_spec.location[:sudo] || (!machine_spec.location.has_key?(:sudo) && username != 'root')
+              options[:prefix] = 'sudo '
+            end
+
+            remote_host = nil
+            # vCloud Air networking is funky
+            #if machine_options[:use_private_ip_for_ssh] # vCloud Air probably needs private ip for now
+            if server.ip_address
+              remote_host = server.ip_address
+            else
+              raise "Server #{server.id} has no private or public IP address!"
+            end
+
+            #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')
+
+            Transport::SSH.new(remote_host, username, ssh_options, options, config)
+          end
+
+          def ready_machine(action_handler, machine_spec, machine_options)
+            server = server_for(machine_spec)
+            if server.nil?
+              raise "Machine #{machine_spec.name} does not have a server associated with it, or server does not exist."
+            end
+
+            # Start the server if needed, and wait for it to start
+            start_server(action_handler, machine_spec, server)
+            wait_until_ready(action_handler, machine_spec, machine_options, server)
+
+            # Attach/detach floating IPs if necessary
+            # vCloud Air is funky for network.  VM has to be powered off or you get this error:
+            #    Primary NIC cannot be changed when the VM is not in Powered-off state
+            # See code in update_network()
+            #DISABLED: converge_floating_ips(action_handler, machine_spec, machine_options, server)
+
+            begin
+              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)
+                raise
+              else
+                # Sometimes (on EC2) the machine comes up but gets stuck or has
+                # some other problem.  If this is the case, we restart the server
+                # to unstick it.  Reboot covers a multitude of sins.
+                Chef::Log.warn "Machine #{machine_spec.name} (#{server.id} on #{driver_url}) was started but SSH did not come up.  Rebooting machine in an attempt to unstick it ..."
+                restart_server(action_handler, machine_spec, server)
+                wait_until_ready(action_handler, machine_spec, machine_options, server)
+                wait_for_transport(action_handler, machine_spec, machine_options, server)
+              end
+            end
+
+            machine_for(machine_spec, machine_options, server)
+          end
+
+          def org
+            @org ||= compute.organizations.get_by_name(Chef::Config[:knife][:vcair_org])
+          end
+
+          def vdc
+            if Chef::Config[:knife][:vcair_vdc]
+              @vdc ||= org.vdcs.get_by_name(Chef::Config[:knife][:vcair_vdc])
+            else
+              @vdc ||= org.vdcs.first
+            end
+          end
+
+          def net
+            if Chef::Config[:knife][:vcair_net]
+              @net ||= org.networks.get_by_name(Chef::Config[:knife][:vcair_net])
+            else
+              # Grab first non-isolated (bridged, natRouted) network
+              @net ||= org.networks.find { |n| n if !n.fence_mode.match("isolated") }
+            end
+          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
+          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
+          end
+
+          def update_customization(bootstrap_options, server)
+            ## Initialization before first power on.
+            c=server.customization
+
+            if bootstrap_options[:customization_script]
+              c.script = open(bootstrap_options[:customization_script]).read
+            end
+
+            # TODO: check machine type and pick accordingly for Chef provisioning
+            # password = case config_value(:bootstrap_protocol)
+            #            when 'winrm'
+            #              config_value(:winrm_password)
+            #            when 'ssh'
+            #              config_value(:ssh_password)
+            #            end
+
+            password = bootstrap_options[:ssh_options][:password]
+            if password
+              c.admin_password =  password 
+              c.admin_password_auto = false
+              c.reset_password_required = false
+            else
+              # Password will be autogenerated
+              c.admin_password_auto=true
+              # API will force password resets when auto is enabled
+              c.reset_password_required = true
+            end
+
+            # TODO: Add support for admin_auto_logon to Fog
+            # c.admin_auto_logon_count = 100
+            # c.admin_auto_logon_enabled = true
+
+            # 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)
+            c.computer_name = bootstrap_options[:name].gsub(/\W/,"-").slice(0..14)
+            c.enabled = true
+            c.save
+          end
+
+          ## vCloud Air
+          ## TODO: make work with floating_ip junk currently used
+          ## NOTE: current vCloud Air networking changes require VM to be powered off
+          def update_network(bootstrap_options, vapp, vm)
+            ## TODO: allow user to specify network to connect to (see above net used)
+            # Define network connection for vm based on existing routed network
+
+            # vCloud Air inlining vapp() and vm()
+            #vapp = vdc.vapps.get_by_name(bootstrap_options[:name])
+            #vm = vapp.vms.find {|v| v.vapp_name == bootstrap_options[:name]}
+            nc = vapp.network_config.find { |n| n if n[:networkName].match(net.name) }
+            networks_config = [nc]
+            section = {PrimaryNetworkConnectionIndex: 0}
+            section[:NetworkConnection] = networks_config.compact.each_with_index.map do |network, i|
+              connection = {
+                network: network[:networkName],
+                needsCustomization: true,
+                NetworkConnectionIndex: i,
+                IsConnected: true
+              }
+              ip_address      = network[:ip_address]
+              ## TODO: support config options for allocation mode
+              #allocation_mode = network[:allocation_mode]
+              #allocation_mode = 'manual' if ip_address
+              #allocation_mode = 'dhcp' unless %w{dhcp manual pool}.include?(allocation_mode)
+              #allocation_mode = 'POOL'
+              #connection[:Dns1] = dns1 if dns1
+              allocation_mode = 'pool'
+              connection[:IpAddressAllocationMode] = allocation_mode.upcase
+              connection[:IpAddress] = ip_address if ip_address
+              connection
+            end
+
+            ## attach the network to the vm
+            nc_task = compute.put_network_connection_system_section_vapp(
+              vm.id,section).body
+              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
+
+            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)
+            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
+                #NOTE: currently doing 1 vm for 1 vapp
+                vapp = vdc.vapps.get_by_name(machine_spec.name)
+                if vapp
+                  vapp.power_off
+                  vapp.undeploy
+                  vapp.destroy
+                else
+                  Chef::Log.warn "No VApp named '#{server_name}' was found."
+                end
+              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] = 'vclouddirector'
+            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, id]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,6 +23,10 @@ class Chef
         with_fog_driver('Rackspace', driver_options, &block)
       end
 
+      def with_fog_vcair_driver(driver_options = nil, &block)
+        with_fog_driver('Vcair', driver_options, &block)
+      end
+
     end
   end
 end

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

@@ -1,7 +1,7 @@
 class Chef
 module Provisioning
 module FogDriver
-  VERSION = '0.13.2'
+  VERSION = '0.14.0'
 end
 end
 end

data/spec/unit/providers/rackspace_spec.rb

@@ -8,7 +8,7 @@ describe Chef::Provisioning::FogDriver::Providers::Rackspace do
     expect(subject).to be_an_instance_of Chef::Provisioning::FogDriver::Providers::Rackspace
   end
 
-  it "has a fog backend" do
+  it "has a Fog backend" do
     pending unless Fog.mock?
     expect(subject.compute).to be_an_instance_of Fog::Compute::RackspaceV2::Mock
   end

metadata

@@ -1,59 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-fog
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.14.0
 platform: ruby
 authors:
 - John Keiser
+- Chris McClimans
+- Taylor Carpenter
+- Wavell Watson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-02 00:00:00.000000000 Z
+date: 2015-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: chef
+  name: chef-provisioning
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: cheffish
+  name: fog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.4'
-- !ruby/object:Gem::Dependency
-  name: chef-provisioning
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: fog
+  name: retryable
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +84,11 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Driver for creating Fog instances in Chef Provisioning.
-email: jkeiser@getchef.com
+email:
+- jkeiser@getchef.com
+- hh@vulk.co
+- t@vulk.co
+- w@vulk.co
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -112,10 +105,12 @@ files:
 - lib/chef/provisioning/fog_driver/providers/aws/credentials.rb
 - lib/chef/provisioning/fog_driver/providers/cloudstack.rb
 - lib/chef/provisioning/fog_driver/providers/digitalocean.rb
+- lib/chef/provisioning/fog_driver/providers/google.rb
 - lib/chef/provisioning/fog_driver/providers/joyent.rb
 - lib/chef/provisioning/fog_driver/providers/openstack.rb
 - lib/chef/provisioning/fog_driver/providers/rackspace.rb
 - lib/chef/provisioning/fog_driver/providers/softlayer.rb
+- lib/chef/provisioning/fog_driver/providers/vcair.rb
 - lib/chef/provisioning/fog_driver/recipe_dsl.rb
 - lib/chef/provisioning/fog_driver/version.rb
 - lib/chef/resource/fog_key_pair.rb
@@ -145,9 +140,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Driver for creating Fog instances in Chef Provisioning.
 test_files: []
-has_rdoc: