chef-metal-vsphere 0.1.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Rally Software Development Corp
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+chef-metal-vsphere
+==================
+
+This is a [chef-metal](https://github.com/opscode/chef-metal) provisioner for [VMware vSphere](http://www.vmware.com/products/vsphere).
+
+Currently, chef-metal-vsphere supports provisioning Unix/ssh guest VMs.
+
+Try It Out
+----------
+
+### vSphere VM Template
+
+Create or obtain a unix/linux VM template.  The VM template must:
+
+  - be capable of installing Chef 11.8 or newer
+  - run vmware-tools on system boot (provides visiblity to ip address of the running VM)
+  - provide access via ssh
+  - provide a user account with NOPASSWD sudo
+
+### Example recipe
+    require 'chef_metal_vsphere'
+
+    with_vsphere_provisioner vsphere_host: 'vcenter-host-name',
+      vsphere_insecure: true,
+      vsphere_user:     'you_user_name',
+      vsphere_password: 'your_mothers_maiden_name'     # consider using a chef-vault
+
+    with_provisioner_options('bootstrap_options' => {
+      datacenter:      'datacenter_name',
+      cluster:         'cluster_name',
+      resource_pool:   'resource_pool_name',            # often the same as the cluster_name
+      datastore:       'datastore_name',
+      template_name:   'name_of_template_vm',           # may be a VM or a VM Template
+      template_folder: 'folder_containing_template_vm',
+      vm_folder:       'folder_to_clone_vms_into',
+
+      ssh: {                                             # net-ssh start() options
+        user:                  'username_on_vm',         # must have nopasswd sudo
+        password:              'name_of_your_first_pet', # consider using a chef-vault
+        port:                  22,
+        auth_methods:          ['password'],
+        user_known_hosts_file: '/dev/null',              # don't do this in production
+        paranoid:              false,                    # don't do this in production, either
+        keys:                  [ ],                      # consider using a chef-vault
+        keys_only:             false
+        }
+      })
+
+    1.upto 2 do |n|
+      machine "metal_#{n}" do
+        action [:create]
+      end
+
+      machine_file "/tmp/metal_#{n}.txt" do
+        machine "metal_#{n}"
+        content "Hello machine #{n}!"
+      end
+
+      machine "metal_#{n}" do
+        action [:stop]
+      end
+
+      machine "metal_#{n}" do
+        # note: no need to :stop before :delete
+        action [:delete]
+      end
+
+    end
+
+This will clone your VM template to create two VMware Virtual Machines, "metal_1" and "metal_2", in the vSphere Folder specified by vm_folder, bootstrapped to an empty runlist.  It will then stop (guest shutdown) and delete the vms.
+
+Bugs and Contact
+----------------
+
+Please submit bugs at [https://github.com/RallySoftware-cookbooks/chef-metal-vsphere], contact Brian Dupras on Twitter at @briandupras, email at rallysoftware-cookbooks@rallydev.com.
+
+*Warning* if you get an rbvmomi error regarding VMODL::AnyType, add `gem 'nokogiri', '1.5.5'` to your dependencies.

data/Rakefile

@@ -0,0 +1,30 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+
+def gem_server
+  @gem_server ||= ENV['GEM_SERVER'] || 'rubygems.org'
+end
+
+module Bundler
+  class GemHelper
+    unless gem_server == 'rubygems.org'
+      unless method_defined?(:rubygem_push)
+        raise NoMethodError, "Monkey patching Bundler::GemHelper#rubygem_push failed: did the Bundler API change???"
+      end
+
+      def rubygem_push(path)
+        print "Username: "
+        username = STDIN.gets.chomp
+        print "Password: "
+        password = STDIN.gets.chomp
+
+        gem_server_url = "https://#{username}:#{password}@#{gem_server}/"
+        sh %{gem push #{path} --host #{gem_server_url}}
+
+        Bundler.ui.confirm "Pushed #{name} #{version} to #{gem_server}"
+      end
+
+      puts "Monkey patched Bundler::GemHelper#rubygem_push to push to #{gem_server}."
+    end
+  end
+end

data/lib/chef_metal/provisioner_init/vsphere_init.rb

@@ -0,0 +1,3 @@
+require 'chef_metal_vsphere/vsphere_provisioner'
+
+ChefMetal.add_registered_provisioner_class('vsphere', ChefMetalVsphere::VsphereProvisioner)

data/lib/chef_metal_vsphere/version.rb

@@ -0,0 +1,3 @@
+module ChefMetalVsphere
+  VERSION = '0.1.3'
+end

data/lib/chef_metal_vsphere/vsphere_helpers.rb

@@ -0,0 +1,127 @@
+module ChefMetalVsphere
+  module Helpers
+
+    def vim
+      # reconnect on every call - connections may silently timeout during long operations (e.g. cloning)
+      conn_opts = {
+          :host => connect_options['vsphere_host'],
+          :port => connect_options['vsphere_port'],
+          :path => connect_options['vshere_path'],
+          :use_ssl => connect_options['vsphere_ssl'],
+          :insecure => connect_options['vsphere_insecure'],
+          :proxyHost => connect_options['proxy_host'],
+          :proxyPort => connect_options['proxy_port'],
+          :user => connect_options['vsphere_user'],
+          :password => connect_options['vsphere_password']
+      }
+
+      vim = RbVmomi::VIM.connect conn_opts
+      return vim
+    end
+
+    def find_vm(dc_name, vm_folder, vm_name)
+      folder = find_folder(dc_name, vm_folder) or raise("vSphere Folder not found [#{vm_folder}] for vm #{vm_name}")
+      vm     = folder.find(vm_name, RbVmomi::VIM::VirtualMachine)
+    end
+
+    def start_vm(vm, wait_on_port = 22)
+      state = vm.runtime.powerState
+      unless state == 'poweredOn'
+        vm.PowerOnVM_Task.wait_for_completion
+      end
+
+      sleep 1 until port_ready?(vm, wait_on_port)
+    end
+
+    def stop_vm(vm)
+      begin
+        vm.ShutdownGuest
+        sleep 2 until vm.runtime.powerState == 'poweredOff'
+      rescue
+        vm.PowerOffVM_Task.wait_for_completion
+      end
+    end
+
+    def port_ready?(vm, port)
+      vm_ip = vm.guest.ipAddress
+      return false if vm_ip.nil?
+
+      begin
+        tcp_socket = TCPSocket.new(vm_ip, port)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          true
+        else
+          false
+        end
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ECONNREFUSED
+        false
+      rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH
+        false
+      ensure
+        tcp_socket && tcp_socket.close
+      end
+    end
+
+    #folder could be like:  /Level1/Level2/folder_name
+    def find_folder(dc_name, folder_name)
+      #dc(dc_name).vmFolder.childEntity.grep(RbVmomi::VIM::Folder).find { |x| x.name == folder_name }
+      baseEntity = dc(dc_name).vmFolder
+      entityArray = folder_name.split('/')
+      entityArray.each do |entityArrItem|
+        if entityArrItem != ''
+          baseEntity = baseEntity.childEntity.grep(RbVmomi::VIM::Folder).find { |f| f.name == entityArrItem }
+        end
+      end
+      baseEntity
+    end
+
+    def dc(dc_name)
+      vim.serviceInstance.find_datacenter(dc_name) or raise("vSphere Datacenter not found [#{datacenter}]")
+    end
+
+    def do_vm_clone(dc_name, vm_template, vm_name, options)
+      pool = options['resource_pool'] ? find_pool(dc(dc_name), options['resource_pool']) : vm_template.resourcePool
+      raise ':resource_pool must be specified when cloning from a VM Template' if pool.nil?
+
+      clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(
+        location: RbVmomi::VIM.VirtualMachineRelocateSpec(pool: pool),
+        powerOn: false,
+        template: false
+        )
+
+      vm_template.CloneVM_Task(
+        name: vm_name,
+        folder: find_folder(dc_name, options['vm_folder']),
+        spec: clone_spec
+        ).wait_for_completion
+    end
+
+    def find_pool(dc, pool_name)
+      baseEntity = dc.hostFolder
+      entityArray = pool_name.split('/')
+      entityArray.each do |entityArrItem|
+        if entityArrItem != ''
+          if baseEntity.is_a? RbVmomi::VIM::Folder
+            baseEntity = baseEntity.childEntity.find { |f| f.name == entityArrItem } or nil
+          elsif baseEntity.is_a? RbVmomi::VIM::ClusterComputeResource or baseEntity.is_a? RbVmomi::VIM::ComputeResource
+            baseEntity = baseEntity.resourcePool.resourcePool.find { |f| f.name == entityArrItem } or nil
+          elsif baseEntity.is_a? RbVmomi::VIM::ResourcePool
+            baseEntity = baseEntity.resourcePool.find { |f| f.name == entityArrItem } or nil
+          else
+            baseEntity = nil
+          end
+        end
+      end
+
+      raise "vSphere ResourcePool not found [#{pool_name}]" if baseEntity.nil?
+
+      baseEntity = baseEntity.resourcePool if not baseEntity.is_a?(RbVmomi::VIM::ResourcePool) and baseEntity.respond_to?(:resourcePool)
+      baseEntity
+    end
+  end
+end

data/lib/chef_metal_vsphere/vsphere_provisioner.rb

@@ -0,0 +1,299 @@
+require 'chef_metal/provisioner'
+require 'chef_metal/machine/windows_machine'
+require 'chef_metal/machine/unix_machine'
+require 'chef_metal/convergence_strategy/install_msi'
+require 'chef_metal/convergence_strategy/install_cached'
+require 'chef_metal/transport/ssh'
+require 'chef_metal_vsphere/version'
+require 'rbvmomi'
+require 'chef_metal_vsphere/vsphere_helpers'
+
+module ChefMetalVsphere
+  # Provisions machines in vSphere.
+  class VsphereProvisioner < ChefMetal::Provisioner
+
+    include Chef::Mixin::ShellOut
+    include ChefMetalVsphere::Helpers
+
+    def self.inflate(node)
+      url = node['normal']['provisioner_output']['provisioner_url']
+      scheme, provider, id = url.split(':', 3)
+      VsphereProvisioner.new({ :provider => provider }, id)
+    end
+
+    # Create a new Vsphere provisioner.
+    #
+    # ## Parameters
+    # connect_options - hash of options to be passed to RbVmomi::VIM.connect
+    #   :vsphere_host       - required - hostname of the vSphere API server
+    #   :vsphere_port       - optional - port on the vSphere API server (default: 443)
+    #   :vshere_path        - optional - path on the vSphere API server (default: /sdk)
+    #   :vsphere_ssl        - optional - true to use ssl in connection to vSphere API server (default: true)
+    #   :vsphere_insecure   - optional - true to ignore ssl certificate validation errors in connection to vSphere API server (default: false)
+    #   :vsphere_user       - required - user name to use in connection to vSphere API server
+    #   :vsphere_password   - required - password to use in connection to vSphere API server
+    #   :proxy_host         - optional - http proxy host to use in connection to vSphere API server (default: none)
+    #   :proxy_port         - optional - http proxy port to use in connection to vSphere API server (default: none)
+    def initialize(connect_options)
+      connect_options = stringify_keys(connect_options)
+      default_connect_options = {
+        'vsphere_port'     => 443,
+        'vsphere_ssl'      => true,
+        'vsphere_insecure' => false,
+        'vsphere_path'     => '/sdk'
+      }
+
+      @connect_options = default_connect_options.merge(connect_options)
+
+      required_options = %w( vsphere_host vsphere_user vsphere_password )
+      missing_options = []
+      required_options.each do |opt|
+        missing_options << opt unless @connect_options.has_key?(opt)
+      end
+      unless missing_options.empty?
+        raise "missing required options: #{missing_options.join(', ')}"
+      end
+
+      # test vim connection
+      vim || raise("cannot connect to [#{provisioner_url}]")
+
+      @connect_options
+    end
+
+    attr_reader :connect_options
+
+    # Acquire a machine, generally by provisioning it.  Returns a Machine
+    # object pointing at the machine, allowing useful actions like setup,
+    # converge, execute, file and directory.  The Machine object will have a
+    # "node" property which must be saved to the server (if it is any
+    # different from the original node object).
+    #
+    # ## Parameters
+    # action_handler - the action_handler object that is calling this method; this
+    #        is generally a action_handler, but could be anything that can support the
+    #        ChefMetal::ActionHandler interface (i.e., in the case of the test
+    #        kitchen metal driver for acquiring and destroying VMs; see the base
+    #        class for what needs providing).
+    # node - node object (deserialized json) representing this machine.  If
+    #        the node has a provisioner_options hash in it, these will be used
+    #        instead of options provided by the provisioner.  TODO compare and
+    #        fail if different?
+    #        node will have node['normal']['provisioner_options'] in it with any options.
+    #        It is a hash with this format:
+    #
+    #           -- provisioner_url: vsphere://host:port?ssl=[true|false]&insecure=[true|false]
+    #           -- bootstrap_options: hash of options to pass to RbVmomi::VIM::VirtualMachine::CloneTask()
+    #                :datacenter
+    #                :resource_pool
+    #                :cluster
+    #                :datastore
+    #                :template_name
+    #                :template_folder
+    #                :vm_folder
+    #                :winrm {...} (not yet implemented)
+    #                :ssh {...}
+    #
+    #        Example bootstrap_options for vSphere:
+    #          TODO: add other CloneTask params, e.g.: datastore, annotation, resource_pool, ...
+    #          'bootstrap_options' => {
+    #            'template_name' =>'centos6.small',
+    #            'template_folder' =>'Templates',
+    #            'vm_folder' => 'MyApp'
+    #          }
+    #
+    #        node['normal']['provisioner_output'] will be populated with information
+    #        about the created machine.  For vSphere, it is a hash with this
+    #        format:
+    #
+    #           -- provisioner_url: vsphere:host:port?ssl=[true|false]&insecure=[true|false]
+    #           -- vm_folder: name of the vSphere folder containing the VM
+    #
+    def acquire_machine(action_handler, node)
+      # Set up the provisioner output
+      provisioner_options = stringify_keys(node['normal']['provisioner_options'])
+
+      vm_name = node['name']
+      old_provisioner_output = node['normal']['provisioner_output']
+      node['normal']['provisioner_output'] = provisioner_output = {
+        'provisioner_url' => provisioner_url,
+        'vm_name' => vm_name,
+        'bootstrap_options' => provisioner_options['bootstrap_options']
+      }
+
+      bootstrap_options = node['normal']['provisioner_output']['bootstrap_options']
+      vm_folder = bootstrap_options['vm_folder']
+
+      if bootstrap_options['ssh']
+        wait_on_port = bootstrap_options['ssh']['port']
+        raise "Must specify bootstrap_options[:ssh][:port]" if wait_on_port.nil?
+      else
+        raise 'bootstrapping is currently supported for ssh only'
+        # wait_on_port = bootstrap_options['winrm']['port']
+      end
+
+      # TODO compare new options to existing and fail if we cannot change it
+      # over (perhaps introduce a boolean that will force a delete and recreate
+      # in such a case)
+
+      vm = vm_instance(action_handler, node)
+
+      action_handler.perform_action "Start VM and wait for ssh [#{vm_folder}/#{vm_name}]" do
+        start_vm(vm, wait_on_port)
+      end
+
+      machine = machine_for(node)
+
+      machine
+    end
+
+    # Connect to machine without acquiring it
+    def connect_to_machine(node)
+      machine_for(node)
+    end
+
+    def delete_machine(action_handler, node)
+      if node['normal'] && node['normal']['provisioner_output']
+        provisioner_output = node['normal']['provisioner_output']
+      else
+        provisioner_output = {}
+      end
+      vm_name = provisioner_output['vm_name'] || node['name']
+      vm_folder = provisioner_output['bootstrap_options']['vm_folder']
+      vm = vm_for(node)
+
+      unless vm.nil?
+        action_handler.perform_action "Delete VM [#{vm_folder}/#{vm_name}]" do
+          vm.PowerOffVM_Task.wait_for_completion unless vm.runtime.powerState == 'poweredOff'
+          vm.Destroy_Task.wait_for_completion
+        end
+      end
+    end
+
+    def stop_machine(action_handler, node)
+      if node['normal'] && node['normal']['provisioner_output']
+        provisioner_output = node['normal']['provisioner_output']
+      else
+        provisioner_output = {}
+      end
+      vm_name = provisioner_output['vm_name'] || node['name']
+      vm_folder = provisioner_output['bootstrap_options']['vm_folder']
+      action_handler.perform_action "Guest shutdown and power off VM [#{vm_folder}/#{vm_name}]" do
+        stop_vm(vm_for(node))
+      end
+    end
+
+    protected
+
+    def provisioner_url
+      "vsphere://#{connect_options['vsphere_host']}:#{connect_options['vsphere_port']}#{connect_options['vsphere_path']}?ssl=#{connect_options['vsphere_ssl']}&insecure=#{connect_options['vsphere_insecure']}"
+    end
+
+    def vm_instance(action_handler, node)
+      bootstrap_options = node['normal']['provisioner_output']['bootstrap_options']
+
+      datacenter = bootstrap_options['datacenter']
+      vm_name = node['normal']['provisioner_output']['vm_name']
+      vm_folder = bootstrap_options['vm_folder']
+
+      vm = find_vm(datacenter, vm_folder, vm_name)
+      return vm unless vm.nil?
+
+      action_handler.perform_action "Clone a new VM instance for [#{vm_folder}/#{vm_name}]" do
+        vm = clone_vm(vm_name, bootstrap_options)
+      end
+
+      vm
+    end
+
+    def clone_vm(vm_name, bootstrap_options)
+      datacenter      = bootstrap_options['datacenter']
+      template_folder = bootstrap_options['template_folder']
+      template_name   = bootstrap_options['template_name']
+      vm_template = find_vm(datacenter, template_folder, template_name) or raise("vSphere VM Template not found [#{template_folder}/#{template_name}]")
+
+      vm = do_vm_clone(datacenter, vm_template, vm_name, bootstrap_options)
+    end
+
+    def machine_for(node)
+      if is_windows?(vm_for(node))
+        ChefMetal::Machine::WindowsMachine.new(node, transport_for(node), convergence_strategy_for(node))
+      else
+        ChefMetal::Machine::UnixMachine.new(node, transport_for(node), convergence_strategy_for(node))
+      end
+    end
+
+
+    def vm_for(node)
+      bootstrap_options = node['normal']['provisioner_output']['bootstrap_options']
+      datacenter = bootstrap_options['datacenter']
+      vm_folder = bootstrap_options['vm_folder']
+      vm_name = node['normal']['provisioner_output']['vm_name']
+      vm = find_vm(datacenter, vm_folder, vm_name)
+    end
+
+    def is_windows?(vm)
+      vm.guest.guestFamily == 'windowsGuest'
+    end
+
+    def convergence_strategy_for(node)
+      if is_windows?(vm_for(node))
+        @windows_convergence_strategy ||= begin
+          options = {}
+          provisioner_options = node['normal']['provisioner_options'] || {}
+          options[:chef_client_timeout] = provisioner_options['chef_client_timeout'] if provisioner_options.has_key?('chef_client_timeout')
+          ChefMetal::ConvergenceStrategy::InstallMsi.new(options)
+        end
+      else
+        @unix_convergence_strategy ||= begin
+          options = {}
+          provisioner_options = node['normal']['provisioner_options'] || {}
+          options[:chef_client_timeout] = provisioner_options['chef_client_timeout'] if provisioner_options.has_key?('chef_client_timeout')
+          ChefMetal::ConvergenceStrategy::InstallCached.new(options)
+        end
+      end
+    end
+
+    def transport_for(node)
+      if is_windows?(vm_for(node))
+        create_winrm_transport(node)
+      else
+        create_ssh_transport(node)
+      end
+    end
+
+    def create_winrm_transport(node)
+      raise 'Windows guest VMs are not yet supported'
+    end
+
+    def create_ssh_transport(node)
+      bootstrap_options = node['normal']['provisioner_output']['bootstrap_options']
+
+      hostname = vm_for(node).guest.ipAddress
+      ssh_user = bootstrap_options['ssh']['user']
+      ssh_options = symbolize_keys(bootstrap_options['ssh'])
+      transport_options = {
+        :prefix => 'sudo '
+      }
+      ChefMetal::Transport::SSH.new(hostname, ssh_user, ssh_options, transport_options)
+    end
+
+    def stringify_keys(h)
+      Hash === h ?
+        Hash[
+          h.map do |k, v|
+            [k.respond_to?(:to_s) ? k.to_s : k, stringify_keys(v)]
+          end
+        ] : h
+    end
+
+    def symbolize_keys(h)
+      Hash === h ?
+        Hash[
+          h.map do |k, v|
+            [k.respond_to?(:to_sym) ? k.to_sym : k, symbolize_keys(v)]
+          end
+        ] : h
+    end
+
+  end
+end

data/lib/chef_metal_vsphere.rb

@@ -0,0 +1,12 @@
+require 'chef_metal'
+require 'chef_metal_vsphere/vsphere_provisioner'
+
+class Chef
+  module DSL
+    module Recipe
+      def with_vsphere_provisioner(options = {}, &block)
+        run_context.chef_metal.with_provisioner(ChefMetalVsphere::VsphereProvisioner.new(options), &block)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: chef-metal-vsphere
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+  prerelease: 
+platform: ruby
+authors:
+- Rally Software Development Corp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rbvmomi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provisioner for creating vSphere VM instances in Chef Metal.
+email: rallysoftware-cookbooks@rallydev.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- Rakefile
+- LICENSE
+- README.md
+- lib/chef_metal/provisioner_init/vsphere_init.rb
+- lib/chef_metal_vsphere/version.rb
+- lib/chef_metal_vsphere/vsphere_helpers.rb
+- lib/chef_metal_vsphere/vsphere_provisioner.rb
+- lib/chef_metal_vsphere.rb
+homepage: https://github.com/RallySoftware-cookbooks/chef-metal-vsphere
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2191173413187633211
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2191173413187633211
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.28
+signing_key: 
+specification_version: 3
+summary: Provisioner for creating vSphere VM instances in Chef Metal.
+test_files: []