rubber 2.5.5 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec1e12978f936ceec04c66adb0faaee47bd40b58
-  data.tar.gz: f9d9ad4325c684e4d51c7ac677e96e4613c70107
+  metadata.gz: 3ec3be4c2c2b486ddd2528e9db6b72b96d1fbf2f
+  data.tar.gz: ad0afb86cac74f88bc397e87a851434015d6683c
 SHA512:
-  metadata.gz: e820367d0dce0f9636d08ffd9b2e94bf418cf575bd8b510754924f60b5d7e2a52471118b5e500c1a6ecfa38df9b752e6cfbd1cfd82684929d5c4d92cac8825ce
-  data.tar.gz: 546e2c34cb91151d0012b7c379d8964348960a9403344b7ffa536c0d620ba84bc5c06316299f7f92a46540768bc631c460e1e43f684e1f88c87ff8fe9cfbd29b
+  metadata.gz: 1184ac231a4cbdaad613d17749e53bf4a993d6affae6830ffd0b65a1ea9ea7af9a2a2965e86cc0408344cb4625f97a8071a1d8ac9b27963490687ba53a20f280
+  data.tar.gz: 3f25823f1f87443b3d4f9f0b189e5c3572a74dd5deafd3cdc7368339168308b2d50181b3b717d33343308918049e3742ada873919d1c17e051ced82914efb3bd

data/CHANGELOG

@@ -1,9 +1,24 @@
+2.6.0 (11/05/2013)
+
+New Features:
+============
+
+[core] Added a new provider for vSphere.  See https://github.com/rubber/rubber/wiki/Providers for configuration details.
+
+Improvements:
+============
+
+[base] Upgraded to ruby-build 20131030 <214423d>
+[base]  Enhances database.yml to respond to active environment, not just 'production' <3843caf>
+
+
 2.5.5 (10/16/2013)
 
 New Features:
 ============
 
 [base, core, postgresql] Added a uniform way of handling private network address blocks <61c5e0c>
+[core] Added cleanup hook for 'vagrant destroy' for Vagrant version >= 1.3.0. <2a3c441>
 
 Improvements:
 ============

data/Gemfile.1.8.7

@@ -3,6 +3,7 @@ source "https://rubygems.org"
 gem 'jruby-openssl', :platform => :jruby
 gem 'unlimited-strength-crypto', :platform => :jruby
 gem 'nokogiri', '~>1.5.0'
+gem 'mime-types', '~>1.25'
 
 # Specify your gem's dependencies in rubber.gemspec
 gemspec

data/lib/rubber/cloud/aws.rb

@@ -301,21 +301,27 @@ module Rubber
         groups
       end
 
-      def create_volume(size, zone)
-        volume = @compute_provider.volumes.create(:size => size.to_s, :availability_zone => zone)
-        return volume.id
+      def create_volume(instance, volume_spec)
+        volume = @compute_provider.volumes.create(:size => volume_spec['size'], :availability_zone => volume_spec['zone'])
+        volume.id
       end
 
-      def attach_volume(volume_id, instance_id, device)
+      def after_create_volume(instance, volume_id, volume_spec)
+        # After we create an EBS volume, we need to attach it to the instance.
         volume = @compute_provider.volumes.get(volume_id)
-        server = @compute_provider.servers.get(instance_id)
+        server = @compute_provider.servers.get(instance.instance_id)
         volume.device = device
         volume.server = server
       end
 
-      def detach_volume(volume_id, force=true)
+      def before_destroy_volume(volume_id)
+        # Before we can destroy an EBS volume, we must detach it from any running instances.
         volume = @compute_provider.volumes.get(volume_id)
-        force ? volume.force_detach : (volume.server = nil)
+        volume.force_detach
+      end
+
+      def destroy_volume(volume_id)
+        @compute_provider.volumes.get(volume_id).destroy
       end
 
       def describe_volumes(volume_id=nil)
@@ -323,21 +329,21 @@ module Rubber
         opts = {}
         opts[:'volume-id'] = volume_id if volume_id
         response = @compute_provider.volumes.all(opts)
+
         response.each do |item|
           volume = {}
           volume[:id] = item.id
           volume[:status] = item.state
+
           if item.server_id
             volume[:attachment_instance_id] = item.server_id
             volume[:attachment_status] = item.attached_at ? "attached" : "waiting"
           end
+
           volumes << volume
         end
-        return volumes
-      end
 
-      def destroy_volume(volume_id)
-        @compute_provider.volumes.get(volume_id).destroy
+        volumes
       end
 
       # resource_id is any Amazon resource ID (e.g., instance ID or volume ID)

data/lib/rubber/cloud/base.rb

@@ -190,6 +190,10 @@ module Rubber
         groups
       end
 
+      def should_disable_password_based_ssh_login?
+        false
+      end
+
     end
 
   end

data/lib/rubber/cloud/fog.rb

@@ -31,7 +31,8 @@ module Rubber
                                                     :flavor_id => ami_type,
                                                     :groups => security_groups,
                                                     :availability_zone => availability_zone,
-                                                    :key_name => env.key_name)
+                                                    :key_name => env.key_name,
+                                                    :name => instance_alias)
 
         response.id
       end
@@ -120,6 +121,34 @@ module Rubber
       def describe_load_balancers(name=nil)
         raise NotImplementedError, "describe_load_balancers not implemented in generic fog adapter"
       end
+
+      def before_create_volume(instance, volume_spec)
+        # No-op by default.
+      end
+
+      def create_volume(instance, volume_spec)
+        # No-op by default.
+      end
+
+      def after_create_volume(instance, volume_id, volume_spec)
+        # No-op by default.
+      end
+
+      def before_destroy_volume(volume_id)
+        # No-op by default.
+      end
+
+      def destroy_volume(volume_id)
+        # No-op by default.
+      end
+
+      def after_destroy_volume(volume_id)
+        # No-op by default.
+      end
+
+      def should_destroy_volume_when_instance_destroyed?
+        false
+      end
     end
 
   end

data/lib/rubber/cloud/vsphere.rb

@@ -0,0 +1,291 @@
+require 'rubber/cloud/fog'
+
+module Rubber
+  module Cloud
+    class Vsphere < Fog
+      def initialize(env, capistrano)
+        compute_credentials = {
+          :provider => 'vsphere',
+          :vsphere_username => env.vcenter_username,
+          :vsphere_password => env.vcenter_password,
+          :vsphere_server => env.vcenter_host,
+          :vsphere_expected_pubkey_hash => env.expected_pubkey_hash
+        }
+
+        if env.cloud_providers && env.cloud_providers.aws
+          storage_credentials = {
+              :provider => 'AWS',
+              :aws_access_key_id => env.cloud_providers.aws.access_key,
+              :aws_secret_access_key => env.cloud_providers.aws.secret_access_key
+          }
+
+          storage_credentials[:region] = env.cloud_providers.aws.region
+
+          env['storage_credentials'] = storage_credentials
+        end
+
+        env['compute_credentials'] = compute_credentials
+        super(env, capistrano)
+      end
+
+      def create_instance(instance_alias, image_name, image_type, security_groups, availability_zone, datacenter)
+        if env.domain.nil?
+          raise "'domain' value must be configured"
+        end
+
+        rubber_cfg = Rubber::Configuration.get_configuration(Rubber.env)
+        host_env = rubber_cfg.environment.bind(nil, instance_alias)
+
+        if host_env.public_nic.nil? && host_env.private_nic.nil?
+          raise "You must configure a private or a public NIC for this host in your rubber YAML"
+        end
+
+        if host_env.public_nic && env.public_network_name.nil?
+          raise "You must configure the 'public_network_name' in the provider configuration"
+        end
+
+        if host_env.private_nic && env.private_network_name.nil?
+          raise "You must configure the 'private_network_name' in the provider configuration"
+        end
+
+        nics = []
+
+        if host_env.public_nic
+          nic = nic_to_vsphere_config(host_env.public_nic, env.public_nic || {})
+          validate_nic_vsphere_config(nic, :public)
+          nics << nic
+        end
+
+        if host_env.private_nic
+          nic = nic_to_vsphere_config(host_env.private_nic, env.private_nic || {})
+          validate_nic_vsphere_config(nic, :private)
+          nics << nic
+        end
+
+        vm_clone_options = {
+          'datacenter' => datacenter,
+          'template_path' => image_name,
+          'name' => instance_alias,
+          'power_on' => false
+        }
+
+        if host_env.memory
+          vm_clone_options['memoryMB'] = host_env.memory
+        end
+
+        if host_env.cpus
+          vm_clone_options['numCPUs'] = host_env.cpus
+        end
+
+        vm = compute_provider.vm_clone(vm_clone_options)
+
+        server = compute_provider.servers.get(vm['new_vm']['id'])
+
+        # Destroy all existing NICs.  We need the public and private IPs to line up with the NICs attached to the
+        # correct virtual switches.  Rather than take the cross-product and try to work that out, it's easier to
+        # just start fresh and guarantee everything works as intended.
+        server.interfaces.each(&:destroy)
+
+        server.interfaces.create(:network => env.public_network_name) if host_env.public_nic
+        server.interfaces.create(:network => env.private_network_name) if host_env.private_nic
+
+        vm_ref = compute_provider.send(:get_vm_ref, server.id)
+        vm_ref.CustomizeVM_Task(:spec => customization_spec(instance_alias, nics))
+
+        server.start
+
+        vm['new_vm']['id']
+      end
+
+      def describe_instances(instance_id=nil)
+        instances = []
+        opts = {}
+
+        if instance_id
+          response = [compute_provider.servers.get(instance_id)]
+        else
+          response = compute_provider.servers.all(opts)
+        end
+
+        response.each do |item|
+          rubber_cfg = Rubber::Configuration.get_configuration(Rubber.env)
+          host_env = rubber_cfg.environment.bind(nil, item.name)
+
+          instance = {}
+          instance[:id] = item.id
+          instance[:state] = item.tools_state
+
+          # We can't trust the describe operation when the instance is newly created because the VM customization
+          # step likely hasn't completed yet.  This means we'll get back the IP address for the VM template, rather
+          # than the one we just configured.
+          if host_env.public_nic
+            instance[:external_ip] = host_env.public_nic.ip_address
+
+            if host_env.private_nic.nil?
+              instance[:internal_ip] = host_env.public_nic.ip_address
+            end
+          end
+
+          if host_env.private_nic
+            instance[:internal_ip] = host_env.private_nic.ip_address
+
+            if host_env.public_nic.nil?
+              instance[:external_ip] = host_env.private_nic.ip_address
+            end
+          end
+
+          instance[:region_id] = item.datacenter
+          instance[:provider] = 'vsphere'
+          instance[:platform] = 'linux'
+          instances << instance
+        end
+
+        return instances
+      end
+
+      def active_state
+        'toolsOk'
+      end
+
+      def create_volume(instance, volume_spec)
+        server = @compute_provider.servers.get(instance.instance_id)
+        datastore = volume_spec['datastore']
+        thin_disk = volume_spec.has_key?('thin') ? volume_spec['thin'] : true
+
+        # This craziness here is so we can map the device name to an appropriate SCSI channel index, which is zero-based.
+        # E.g., /dev/sdc would correspond to a unit_number of 2.  We do this by chopping off the SCSI device letter and
+        # then doing some ASCII value math to convert to the appropriate decimal value.
+        unit_number = volume_spec['device'][-1].ord - 97
+
+        config = { :size_gb => volume_spec['size'], :unit_number => unit_number }
+
+        if datastore
+          config[:datastore] = datastore
+        end
+
+        unless thin_disk
+          eager_zero = volume_spec.has_key?('eager_zero') ? volume_spec['eager_zero'] : false
+
+          config[:thin] = false
+          config[:eager_zero] = eager_zero
+        end
+
+        volume = server.volumes.create(config)
+
+        volume.id
+      end
+
+      def destroy_volume(volume_id)
+        # TODO (nirvdrum 10/28/13): Fog currently lacks the ability to fetch a volume by ID, so we need to fetch all volumes for all servers to find the volume we want.  This is terribly inefficient and fog should be updated.
+        volume = @compute_provider.servers.collect { |s| s.volumes.all }.flatten.find { |v| v.id == volume_id }
+
+        if volume.unit_number == 0
+          raise "Cannot destroy volume because it is the VM root device.  Destroy the VM if you really want to free this volume."
+        end
+
+        volume.destroy
+      end
+
+      def describe_volumes(volume_id=nil)
+        volumes = []
+        opts = {}
+        opts[:'volume-id'] = volume_id if volume_id
+
+        if volume_id
+          response = [@compute_provider.servers.collect { |s| s.volumes.all }.flatten.find { |v| v.id == volume_id }]
+        else
+          response = @compute_provider.servers.collect { |s| s.volumes.all }.flatten
+        end
+
+        response.each do |item|
+          volume = {}
+          volume[:id] = item.id
+          volume[:status] = item.unit_number == 0 ? 'root' : 'extra'
+
+          if item.server_id
+            volume[:attachment_instance_id] = item.server_id
+            volume[:attachment_status] = Thread.current[:detach_volume] == item.id ? 'detached' : 'attached'
+          end
+
+          volumes << volume
+        end
+
+        volumes
+      end
+
+      def should_destroy_volume_when_instance_destroyed?
+        true
+      end
+
+      def should_disable_password_based_ssh_login?
+        true
+      end
+
+      private
+
+      def validate_nic_vsphere_config(nic_config, type)
+        %w[ip subnetMask dnsServerList].each do |attr|
+          if nic_config[attr].nil?
+            raise "Missing '#{attr}' for #{type} NIC configuaration"
+          end
+        end
+
+        nic_config
+      end
+
+      def nic_to_vsphere_config(nic, default_nic)
+        hash = {
+          'ip' => nic['ip_address'],
+          'subnetMask' => nic['subnet_mask'] || default_nic['subnet_mask'],
+          'dnsServerList' => nic['dns_servers'] || default_nic['dns_servers']
+        }
+
+        # We want to allow overriding the gateway on a per-host basis by setting the value to nil.  As such, we
+        # can't fall back to the default config just because the value is nil.
+        if nic.has_key?('gateway')
+
+          # Null values are represented as "null" in YAML, but Rubyists tend to use "nil", which will get translated
+          # to the literal String "nil". Which guarding against this is arguably bad, letting "nil" go through as a valid
+          # gateway value is even worse.
+          puts "\n\nGateway: #{nic['gateway']}\n\n"
+          if nic['gateway'] && nic['gateway'] != 'nil'
+            hash['gateway'] = [nic['gateway']]
+          end
+
+        elsif default_nic['gateway']
+          hash['gateway'] = [default_nic['gateway']]
+        end
+
+        hash
+      end
+
+      def customization_spec(instance_alias, ip_settings)
+        nics = []
+
+        ip_settings.each do |nic|
+          custom_ip_settings = RbVmomi::VIM::CustomizationIPSettings.new(nic)
+          custom_ip_settings.ip = RbVmomi::VIM::CustomizationFixedIp("ipAddress" => nic['ip'])
+          custom_ip_settings.dnsDomain = env.domain
+
+          nics << custom_ip_settings
+        end
+
+        custom_global_ip_settings = RbVmomi::VIM::CustomizationGlobalIPSettings.new
+        custom_global_ip_settings.dnsServerList = nics.first.dnsServerList
+        custom_global_ip_settings.dnsSuffixList = [env.domain]
+
+        custom_adapter_mapping = nics.collect { |nic| RbVmomi::VIM::CustomizationAdapterMapping.new("adapter" => nic) }
+
+        custom_prep = RbVmomi::VIM::CustomizationLinuxPrep.new(
+            :domain => env.domain,
+            :hostName => RbVmomi::VIM::CustomizationFixedName.new(:name => instance_alias))
+
+        puts "Adapters: #{custom_adapter_mapping}"
+
+        RbVmomi::VIM::CustomizationSpec.new(:identity => custom_prep,
+                                            :globalIPSettings => custom_global_ip_settings,
+                                            :nicSettingMap => custom_adapter_mapping)
+      end
+    end
+  end
+end

data/lib/rubber/recipes/rubber/instances.rb

@@ -440,8 +440,8 @@ namespace :rubber do
     end
 
     if instance_item.volumes
-      value = Capistrano::CLI.ui.ask("Instance has persistent volumes, do you want to destroy them? [y/N]?: ") unless force
-      if value =~ /^y/ || force
+      value = Capistrano::CLI.ui.ask("Instance has persistent volumes, do you want to destroy them? [y/N]?: ") unless force || cloud.should_destroy_volume_when_instance_destroyed?
+      if value =~ /^y/ || force || cloud.should_destroy_volume_when_instance_destroyed?
         instance_item.volumes.clone.each do |volume_id|
           destroy_volume(volume_id)
         end

data/lib/rubber/recipes/rubber/setup.rb

@@ -26,7 +26,15 @@ namespace :rubber do
     # We special-case the 'ubuntu' user since the Canonical AMIs on EC2 don't set the password for
     # this account, making any password prompt potentially confusing.
     orig_password = fetch(:password)
-    set(:password, initial_ssh_user == 'ubuntu' || ENV.has_key?('RUN_FROM_VAGRANT') ? nil : Capistrano::CLI.password_prompt("Password for #{initial_ssh_user} @ #{ip}: "))
+    initial_ssh_password = fetch(:initial_ssh_password, nil)
+
+    if initial_ssh_user == 'ubuntu' || ENV.has_key?('RUN_FROM_VAGRANT')
+      set(:password, nil)
+    elsif initial_ssh_password
+      set(:password, initial_ssh_password)
+    else
+      set(:password, Capistrano::CLI.password_prompt("Password for #{initial_ssh_user} @ #{ip}: "))
+    end
 
     task :_ensure_key_file_present, :hosts => "#{initial_ssh_user}@#{ip}" do
       public_key_filename = "#{cloud.env.key_file}.pub"
@@ -50,9 +58,19 @@ namespace :rubber do
       rsudo "mkdir -p /root/.ssh && cp /home/#{initial_ssh_user}/.ssh/authorized_keys /root/.ssh/"
     end
 
+    task :_disable_password_based_ssh_login, :hosts => "#{initial_ssh_user}@#{ip}" do
+      rubber.sudo_script 'disable_password_based_ssh_login', <<-ENDSCRIPT
+        if ! grep -q 'PasswordAuthentication no' /etc/ssh/sshd_config; then
+          echo 'PasswordAuthentication no' >> /etc/ssh/sshd_config
+          service ssh restart
+        fi
+      ENDSCRIPT
+    end
+
     begin
       _ensure_key_file_present
       _allow_root_ssh
+      _disable_password_based_ssh_login if cloud.should_disable_password_based_ssh_login?
     rescue ConnectionError => e
       if e.message =~ /Net::SSH::AuthenticationFailed/
         logger.info "Can't connect as user #{initial_ssh_user} to #{ip}, assuming root allowed"
@@ -332,7 +350,8 @@ namespace :rubber do
     core_packages = [
         'python-software-properties', # Needed for add-apt-repository, which we use for adding PPAs.
         'bc',                         # Needed for comparing version numbers in bash, which we do for various setup functions.
-        'update-notifier-common'      # Needed for notifying us when a package upgrade requires a reboot.
+        'update-notifier-common',     # Needed for notifying us when a package upgrade requires a reboot.
+        'scsitools'                   # Needed to rescan SCSI channels for any added devices.
     ]
 
     rsudo "apt-get -q update"

data/lib/rubber/recipes/rubber/volumes.rb

@@ -38,6 +38,10 @@ namespace :rubber do
         setup_lvm_group(ic, lvm_volume_group_spec)
       end
     end
+
+    # The act of setting up volumes might blow away previously deployed code, so reset the update state so it can
+    # be deployed again if needed.
+    set :rubber_code_was_updated, false
   end
 
   desc <<-DESC
@@ -72,26 +76,18 @@ namespace :rubber do
     detach_volume(volume_id)
   end
 
-  def create_volume(size, zone)
-    volumeId = cloud.create_volume(size.to_s, zone)
-    fatal "Failed to create volume" if volumeId.nil?
-    return volumeId
-  end
-
-  def attach_volume(vol_id, instance_id, device)
-    cloud.attach_volume(vol_id, instance_id, device)
-  end
-
   def setup_volume(ic, vol_spec)
     created = nil
     key = "#{ic.name}_#{vol_spec['device']}"
     artifacts = rubber_instances.artifacts
     vol_id = artifacts['volumes'][key]
 
+    cloud.before_create_volume(ic, vol_spec)
+
     # first create the volume if we don't have a global record (artifacts) for it
     if ! vol_id
       logger.info "Creating volume for #{ic.full_name}:#{vol_spec['device']}"
-      vol_id = create_volume(vol_spec['size'], vol_spec['zone'])
+      vol_id = cloud.create_volume(ic, vol_spec)
       artifacts['volumes'][key] = vol_id
       rubber_instances.save
       created = vol_spec['device']
@@ -101,7 +97,7 @@ namespace :rubber do
     ic.volumes ||= []
     if ! ic.volumes.include?(vol_id)
       logger.info "Attaching volume #{vol_id} to #{ic.full_name}:#{vol_spec['device']}"
-      attach_volume(vol_id, ic.instance_id, vol_spec['device'])
+      cloud.after_create_volume(ic, vol_id, vol_spec)
       ic.volumes << vol_id
       rubber_instances.save
 
@@ -119,13 +115,16 @@ namespace :rubber do
         # then format/mount/etc if we don't have an entry in hosts file
         task :_setup_volume, :hosts => ic.external_ip do
           rubber.sudo_script 'setup_volume', <<-ENDSCRIPT
+            # Make sure the newly added volume was found.
+            rescan-scsi-bus || true
+
             if ! grep -q '#{vol_spec['mount']}' /etc/fstab; then
               if mount | grep -q '#{vol_spec['mount']}'; then
                 umount '#{vol_spec['mount']}'
               fi
               mv /etc/fstab /etc/fstab.bak
               cat /etc/fstab.bak | grep -v '#{vol_spec['mount']}' > /etc/fstab
-              if [ `lsb_release -r -s | sed 's/[.].*//'` -gt "10" ]; then
+              if [ #{rubber_env.cloud_provider == 'aws'} && `lsb_release -r -s | sed 's/[.].*//'` -gt "10" ]; then
 		            device=`echo #{vol_spec['device']} | sed 's/sd/xvd/'`
 	            else
 		            device='#{vol_spec['device']}'
@@ -416,11 +415,13 @@ namespace :rubber do
   end
   
   def destroy_volume(volume_id)
-    detach_volume(volume_id)
+    cloud.before_destroy_volume(volume_id)
 
     logger.info "Deleting volume #{volume_id}"
     cloud.destroy_volume(volume_id) rescue logger.info("Volume did not exist in cloud")
 
+    cloud.after_destroy_volume(volume_id)
+
     logger.info "Removing volume #{volume_id} from rubber instances file"
     artifacts = rubber_instances.artifacts
     artifacts['volumes'].delete_if {|k,v| v == volume_id}

data/lib/rubber/version.rb

@@ -1,3 +1,3 @@
 module Rubber
-  VERSION = "2.5.5"
+  VERSION = "2.6.0"
 end

data/rubber.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'thor'
   s.add_dependency 'clamp'
   s.add_dependency 'open4'
-  s.add_dependency 'fog', '~> 1.6', '< 1.16.0'
+  s.add_dependency 'fog', '~> 1.6'
   s.add_dependency 'json'
   
   s.add_development_dependency('rake')

data/templates/base/config/rubber/rubber-ruby.yml

@@ -12,7 +12,7 @@ packages: [build-essential, git-core, subversion, curl, autoconf, bison, ruby, z
 
 # REQUIRED: The version of ruby-build to use for building ruby.
 # It must be one of the versions from https://github.com/sstephenson/ruby-build/blob/master/CHANGELOG.md
-ruby_build_version: 20130923
+ruby_build_version: 20131030
 
 # REQUIRED: Set to the version string for the ruby version you wish to use
 # Run "ruby-build --definitions" to see the list of possible options or look through the list of

data/templates/mysql/config/rubber/common/database.yml

@@ -3,7 +3,7 @@
 %>
 
 <%= Rubber.env %>:
-  adapter: <%= YAML::load(File.open("#{Rubber.root}/config/database.yml"))["production"]["adapter"] %>
+  adapter: <%= YAML::load(File.open("#{Rubber.root}/config/database.yml"))[Rubber.env]["adapter"] %>
   encoding: utf8
   database: <%= rubber_env.db_name %>
   username: <%= rubber_env.db_user %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubber
 version: !ruby/object:Gem::Version
-  version: 2.5.5
+  version: 2.6.0
 platform: ruby
 authors:
 - Matt Conway
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-16 00:00:00.000000000 Z
+date: 2013-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -88,9 +88,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-    - - <
-      - !ruby/object:Gem::Version
-        version: 1.16.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -98,9 +95,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-    - - <
-      - !ruby/object:Gem::Version
-        version: 1.16.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -223,6 +217,7 @@ files:
 - lib/rubber/cloud/fog_storage.rb
 - lib/rubber/cloud/generic.rb
 - lib/rubber/cloud/vagrant.rb
+- lib/rubber/cloud/vsphere.rb
 - lib/rubber/commands/config.rb
 - lib/rubber/commands/cron.rb
 - lib/rubber/commands/util.rb