vmonkey 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c80f0a833b6907731b9809f68d81af87f3886cd0
+  data.tar.gz: 40ca2aa1adb647c8fc244834e46a6411b26775ec
+SHA512:
+  metadata.gz: 0c785b37bee04305d7151a99d707364895ef5021ebfd405830d8c9d7eab47e54aa96997502274887e91842399b35a48d8ba2b2ceb3e988df790c4f77554d630f
+  data.tar.gz: f48409e63777562785d8c9c14c8f4b756bf5fb0d8fef9e478d5b181a1255c233910851b5e7dec29b620dc94b42d28944fe68a50c0e16f9edb9a46799a35b98cd

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.vmonkey

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vmonkey.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+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,120 @@
+# VMonkey
+
+VMonkey is a cheeky little feller who wants so very badly to make interacintg with vSphere more enjoyable.  Let VMonkey fetch your VMs, clone your templates, set your properties, and more.  VMonkey tinkers around in the uglier parts of the vSphere API so you don't have to.  Enjoy!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vmonkey'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vmonkey
+
+## Usage
+
+### $HOME/.vmonkey (optional)
+
+```yml
+host: vsphere.host.name
+user: vsphere_user
+password: monkey!
+insecure: false #or true
+ssl: true #or false
+datacenter: your_dc_name
+cluster: your_cluster_or_compute_resource_name
+```
+
+### initial connection
+
+```ruby
+# use connect opts from $HOME/.vmonkey
+monkey = VMonkey.connect
+```
+
+or
+
+```ruby
+# use your own connect opts
+monkey = VMonkey.connect opts_hash
+```
+
+### what is VMonkey
+
+VMonkey.connect simply returns an instance of RbVmomi::VIM with added utility methods.  The utility methods operate within the datacenter and cluster specified by the connection options.
+
+
+### VMonkey finds stuff
+
+```ruby
+monkey.folder  '/path/to/my/folder' # returns a Folder or nil
+monkey.folder! '/path/to/my/folder' # returns a Folder or raises an error
+
+monkey.vm  '/path/to/my/vm' # returns a VirtualMachine or nil
+monkey.vm! '/path/to/my/vm' # returns a VirtualMachine or raises an error
+
+monkey.vapp  '/path/to/my/vapp' # returns a VirtualApp or nil
+monkey.vapp! '/path/to/my/vapp' # returns a VirtualApp or raises an error
+```
+
+### VMonkey puts his glitter on VirtualMachine instances
+    
+```ruby
+vm.annotation
+vm.annotation = 'VMonkey is hot'
+
+vm.move_to  '/path/to/some_folder/clone_name' # moves the VM or raises if the destination exists
+vm.move_to! '/path/to/some_folder/clone_name' # moves the VM, overwrting the detinsation VM if necessary
+
+vm.clone_to '/path/to/some_folder/clone_name' # clones the VM to a Folder
+vm.clone_to '/path/to/some_vapp/clone_name'   # clones the VM to a VirtualApp
+
+vm.property  :foo        # returns the value of a vApp property, or nil
+vm.property! :foo        # returns the value of a vApp property, or raises an error
+vm.property  :foo, 'bar' # set the value of a vApp property
+
+vm.port_ready? 22   # true if the VM is listening a TCP port
+vm.wait_for_port 22 # blocks until the port_ready? is true
+
+vm.start   # power on if needed
+vm.stop    # guest shutdown and power off
+vm.destroy # deletes the VM from the inventory, no need to power off first
+```
+
+### VMonkey gives some love to other types, too
+
+```ruby
+datacenter.find_pool                    # returns the default datacenter ResourcePool
+datacenter.find_pool '/path/to/cluster' # returns the cluster's default ResourcePool
+datacenter.find_pool '/path/to/vapp'    # returns the vApp, since it's already a ResourcePool
+
+vapp.find_vm  'vm_name' # returns a VM of the given name, or nil
+```
+
+### VMonkey earns his keep
+
+Before:
+
+```ruby
+config = [annotation: 'This makes VMonkey sad.']
+spec = RbVmomi::VIM.VirtualMachineConfigSpec(config)
+vm.ReconfigVM_Task(spec: spec).wait_for_completion
+```
+
+After:
+
+```ruby
+vm.annotation = 'VMonkey is so easy!'
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/vmonkey )
+2. Setup your test environment (`bundle exec rake spec` and follow the test setup instructions)
+3. Hack
+4. Pull request ( be sure to include updated specs )

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+ENV['VMONKEY_YML'] ||= File.expand_path(File.join(File.dirname(__FILE__), 'spec', '.vmonkey'))
+RSpec::Core::RakeTask.new(:spec)

data/lib/vmonkey.rb

@@ -0,0 +1,29 @@
+require 'rbvmomi'
+require_relative 'vmonkey/version'
+require_relative 'vmonkey/vim/vim'
+
+monkey_vim = File.join(File.dirname(__FILE__), 'vmonkey', 'vim')
+RbVmomi::VIM.add_extension_dir monkey_vim
+
+module VMonkey
+  def self.connect(opts = nil)
+    RbVmomi::VIM.monkey_connect(opts)
+  end
+end
+
+class String
+  def parent
+    p = self.split('/')[0...-1].join('/')
+    p == '' ? '/' : p
+  end
+
+  def basename
+    p = self.split('/').last
+  end
+end
+
+class RbVmomi::BasicTypes::ManagedObject
+  def monkey
+    _connection
+  end
+end

data/lib/vmonkey/version.rb

@@ -0,0 +1,3 @@
+module Vmonkey
+  VERSION = '0.1.0'
+end

data/lib/vmonkey/vim/Datacenter.rb

@@ -0,0 +1,34 @@
+class RbVmomi::VIM::Datacenter
+
+  ## modified from knife-vsphere / base_vsphere_command.rb
+  def find_pool(pool_path = '/')
+    parent = self.hostFolder
+
+    pool_path.split('/').each do |path_element|
+      next if path_element == ''
+
+      case parent
+      when RbVmomi::VIM::Folder
+        chilln = parent.childEntity
+      when RbVmomi::VIM::ClusterComputeResource, RbVmomi::VIM::ComputeResource
+        chilln = parent.resourcePool.resourcePool
+      when RbVmomi::VIM::ResourcePool
+        chilln = parent.resourcePool
+      else
+        parent = nil
+        break
+      end
+
+      parent = chilln.find { |f| f.name == path_element }
+    end
+
+    unless parent.is_a?(RbVmomi::VIM::ResourcePool)
+      if parent.respond_to?(:resourcePool)
+        parent = parent.resourcePool
+      end
+    end
+
+    parent
+  end
+
+end

data/lib/vmonkey/vim/Folder.rb

@@ -0,0 +1,9 @@
+class RbVmomi::VIM::Folder
+  def vm_pool
+    monkey.cluster.resourcePool
+  end
+
+  def vm_folder
+    self
+  end
+end

data/lib/vmonkey/vim/VirtualApp.rb

@@ -0,0 +1,16 @@
+class RbVmomi::VIM::VirtualApp
+  def vm_pool
+    self
+  end
+
+  def vm_folder
+    parentVApp.nil? ? parentFolder : self.parentVApp.vm_folder
+  end
+
+  def find_vm(vm_name)
+    vm.find { |vm| vm.name == vm_name }
+  end
+end
+
+
+

data/lib/vmonkey/vim/VirtualMachine.rb

@@ -0,0 +1,178 @@
+class RbVmomi::VIM::VirtualMachine
+
+  def destroy
+    self.PowerOffVM_Task.wait_for_completion unless runtime.powerState == 'poweredOff'
+    self.Destroy_Task.wait_for_completion
+  end
+
+  def clone_to(path, opts = {})
+    dest = monkey.get(path.parent)
+    unless dest.is_a? RbVmomi::VIM::Folder or dest.is_a? RbVmomi::VIM::VirtualApp
+      raise "Cannot clone_to [#{dest.pretty_path}] - destination must specify a Folder or VirtualApp"
+    end
+
+    params = _clone_params(path.basename, dest, opts)
+
+    self.CloneVM_Task(params).wait_for_completion
+  end
+
+  def annotation
+    config.annotation
+  end
+
+  def annotation=(value)
+    ReconfigVM_Task(spec: RbVmomi::VIM.VirtualMachineConfigSpec(annotation: value)).wait_for_completion
+  end
+
+  def property(*args)
+    case args.size
+    when 1
+      read_property(*args)
+    when 2
+      set_property(*args)
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.size} for 1 or 2)")
+    end
+  end
+
+  def property!(name)
+    read_property(name) || raise("vApp Property not found. [#{name}]")
+  end
+
+  def move_to(path)
+    monkey.vm(path) && raise("VirtualMachine already exists. [#{path}]")
+    rename = name != path.basename
+
+    to_folder = monkey.folder! path.parent
+    reparent = parent != to_folder
+
+    if reparent
+      Rename_Task(newName: "#{path.basename}-tmp").wait_for_completion if rename
+      to_folder.MoveIntoFolder_Task(list: [self]).wait_for_completion
+      Rename_Task(newName: path.basename).wait_for_completion if rename
+    else
+      Rename_Task(newName: path.basename).wait_for_completion
+    end
+  end
+
+  unless self.method_defined? :guest_ip
+    ## backported from rbvmomi 1.8 for rbvmomi 1.5 support
+    def guest_ip 
+      g = self.guest
+      if g.ipAddress && (g.toolsStatus == "toolsOk" || g.toolsStatus == "toolsOld")
+        g.ipAddress
+      else
+        nil
+      end
+    end  
+  end
+
+  def move_to!(path)
+    dest_vm = monkey.vm(path)
+    dest_vm.destroy if dest_vm
+
+    move_to(path)
+  end
+
+  def port_ready?(port)
+    ip = guest_ip or return false
+    tcp_socket = TCPSocket.new(ip, port)
+    readable = IO.select([tcp_socket], nil, nil, 5)
+    if readable
+      true
+    else
+      false
+    end
+  rescue Errno::ETIMEDOUT, Errno::EPERM, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
+    false
+  ensure
+    tcp_socket && tcp_socket.close
+  end
+
+  def wait_for_port(port)
+    sleep 2 until port_ready?(port)
+  end
+
+  def stop
+    return if runtime.powerState == 'poweredOff'
+    ShutdownGuest
+    sleep 2 until runtime.powerState == 'poweredOff'
+  rescue
+    PowerOffVM_Task().wait_for_completion unless runtime.powerState == 'poweredOff'
+  end
+
+  def start
+    PowerOnVM_Task().wait_for_completion unless runtime.powerState == 'poweredOn'
+  end
+
+  def find_property(name)
+    config.vAppConfig.property.find { |p| p.props[:id] == name.to_s  }
+  end
+
+  def read_property(name)
+    p = find_property(name)
+    p.nil? ? nil : p[:value]
+  end
+
+  def set_property(name, value)
+    if config.vAppConfig && config.vAppConfig.property
+      existing_property = find_property(name)
+    end
+
+    if existing_property
+      operation = 'edit'
+      property_key = existing_property.props[:key]
+    else
+      operation = 'add'
+      property_key = name.object_id
+    end
+
+    vm_config_spec = RbVmomi::VIM.VirtualMachineConfigSpec(
+      vAppConfig: RbVmomi::VIM.VmConfigSpec(
+        property: [
+          RbVmomi::VIM.VAppPropertySpec(
+            operation: operation,
+            info: {
+              key: property_key,
+              id: name.to_s,
+              type: 'string',
+              userConfigurable: true,
+              value: value
+              })]))
+
+    if config.vAppConfig.nil? || config.vAppConfig.ovfEnvironmentTransport.empty?
+      vm_config_spec[:vAppConfig][:ovfEnvironmentTransport] = ['com.vmware.guestInfo']
+    end
+
+    ReconfigVM_Task( spec: vm_config_spec ).wait_for_completion
+  end
+
+  def _clone_params(vm_name, dest, opts)
+    {
+      name: vm_name,
+      folder: dest.vm_folder,
+      spec: _clone_spec(dest, opts)
+    }
+  end
+
+  def _clone_spec(dest, opts)
+    opts[:config] ||= {}
+
+    clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(
+      location: RbVmomi::VIM.VirtualMachineRelocateSpec(pool: dest.vm_pool),
+      powerOn: false,
+      template: false
+    )
+
+    clone_spec.config = RbVmomi::VIM.VirtualMachineConfigSpec(deviceChange: Array.new)
+
+    clone_spec.customization = monkey.customization_spec(opts[:customization_spec])
+    clone_spec.config.annotation = opts[:config][:annotation]
+    clone_spec.config.numCPUs = opts[:config][:num_cpus]
+    clone_spec.config.memoryMB = opts[:config][:memory_mb]
+
+    clone_spec
+  end
+
+end
+

data/lib/vmonkey/vim/vim.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+
+module RbVmomi
+  class VIM
+
+    attr_accessor :dc
+    attr_accessor :cluster
+    attr_accessor :opts
+
+    def self.monkey_connect(opts = nil)
+      opts ||= self.read_yml_opts
+      vim = self.connect(opts)
+      vim.opts = opts
+      vim.dc = vim.serviceInstance.find_datacenter(vim.opts[:datacenter]) or raise "Datacenter not found [#{vim.opts[:datacenter]}]"
+      vim.cluster = vim.dc.find_compute_resource(vim.opts[:cluster]) or raise "Cluster not found [#{vim.opts[:cluster]}]"
+
+      vim
+    end
+
+    def folder(path)
+      dc.vmFolder.traverse path, RbVmomi::VIM::Folder
+    end
+
+    def folder!(path)
+      folder(path) || raise("Folder not found. [#{path}]")
+    end
+
+    def vm(path)
+      dc.vmFolder.traverse path, RbVmomi::VIM::VirtualMachine
+    end
+
+    def vm!(path)
+      vm(path) || raise("VirtualMachine not found. [#{path}]")
+    end
+
+    def vapp(path)
+      dc.vmFolder.traverse path, RbVmomi::VIM::VirtualApp
+    end
+
+    def vapp!(path)
+      vapp(path) || raise("VirtualApp not found. [#{path}]")
+    end
+
+    def get(path)
+      dc.vmFolder.traverse path
+    end
+
+    def customization_spec(spec_name)
+      return nil if spec_name.nil?
+      serviceContent.customizationSpecManager.GetCustomizationSpec(name: spec_name).spec
+    rescue
+      nil
+    end
+
+    private
+
+    def self.read_yml_opts
+      yml_path = File.expand_path( ENV['VMONKEY_YML'] || File.join(ENV['HOME'], '.vmonkey') )
+      YAML::load_file(yml_path).inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+  end
+end

data/spec/datacenter_spec.rb

@@ -0,0 +1,31 @@
+require_relative 'spec_helper'
+
+describe RbVmomi::VIM::Datacenter do
+  before :all do
+    @monkey = VMonkey.connect
+    @cluster_path = "/#{@monkey.opts[:cluster]}"
+  end
+
+  describe '#find_pool' do
+    context 'with no params' do
+      subject { @pool ||= VMonkey.connect.dc.find_pool }
+
+      it { should_not be_nil }
+      its(:name) { should == 'host' }
+    end
+
+    context 'with cluster path' do
+      subject { @pool ||= VMonkey.connect.dc.find_pool @cluster_path }
+
+      it { should_not be_nil }
+      its(:name) { should == 'Resources' }
+    end
+
+    context 'with vApp path' do
+      subject { @pool ||= VMonkey.connect.dc.find_pool VM_SPEC_OPTS[:vapp_pool_path] }
+
+      it { should_not be_nil }
+      its(:name) { should == VM_SPEC_OPTS[:vapp_pool_path].split('/').last }
+    end
+  end
+end

data/spec/folder_spec.rb

@@ -0,0 +1,13 @@
+require_relative 'spec_helper'
+
+describe RbVmomi::VIM::Folder do
+  before :all do
+    @monkey ||= VMonkey.connect
+    @folder ||= @monkey.folder VM_SPEC_OPTS[:working_folder]
+  end
+
+  describe '#vm_pool' do
+    subject { @folder.vm_pool }
+    it { should_not be_nil }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require_relative '../lib/vmonkey'
+
+instructions = "
+  For the integration tests to run, you need:
+    - On the machine running the specs:
+      + #{ENV['VMONKEY_YML']} (see below)
+
+    - On your vSphere system
+      + A VM or Template from which VMs will be cloned (:template_path)
+        (Clones of this VM must listen on TCP port 22 on bootup)
+      + A working Folder into which VMs will be cloned (:working_folder)
+      + A working Folder into which VM will be moved (:working_folder2)
+      + An empty vApp into which cloned VMs will be placed (:vapp_path)
+      + A Customization Spec which will be applied to cloned VMs (:customization_spec)
+
+  Place the following in #{ENV['VMONKEY_YML']}
+    host: host_name_or_ip_address
+    user: user_name
+    password: password
+    insecure: true
+    ssl: true
+    datacenter: datacenter_name
+    cluster: cluster_name
+    spec:
+      :template_path: /path/to/a/vm_or_template
+      :working_folder: /path/to/a/folder
+      :working_folder2: /path/to/another/folder
+      :vapp_pool_path: /cluster_name/monkey_vapp
+      :vapp_path: /path/to/a/vapp
+      :customization_spec: name-of-a-cust-spec
+  "
+
+raise instructions unless File.exists? ENV['VMONKEY_YML']
+
+monkey = VMonkey.connect
+VM_SPEC_OPTS = monkey.opts[:spec]
+raise instructions unless monkey.folder VM_SPEC_OPTS[:working_folder]
+raise instructions unless monkey.folder VM_SPEC_OPTS[:working_folder2]
+raise instructions unless monkey.vm VM_SPEC_OPTS[:template_path]
+raise instructions unless monkey.vapp VM_SPEC_OPTS[:vapp_path]
+raise instructions unless monkey.dc.find_pool VM_SPEC_OPTS[:vapp_pool_path]
+raise instructions unless monkey.customization_spec VM_SPEC_OPTS[:customization_spec]
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = :documentation
+end

data/spec/vapp_spec.rb

@@ -0,0 +1,14 @@
+require_relative 'spec_helper'
+
+describe RbVmomi::VIM::Folder do
+
+  before :all do
+    @monkey ||= VMonkey.connect
+    @vapp ||= @monkey.vapp VM_SPEC_OPTS[:vapp_path]
+  end
+
+  describe '#vm_pool' do
+    subject { @vapp.vm_pool }
+    it { should_not be_nil }
+  end
+end

data/spec/vim_spec.rb

@@ -0,0 +1,77 @@
+require_relative 'spec_helper'
+
+describe RbVmomi::VIM do
+  before :all do
+    @monkey ||= VMonkey.connect
+  end
+
+  describe '#folder' do
+    subject { @folder ||= @monkey.folder VM_SPEC_OPTS[:working_folder] }
+
+    it { should_not be_nil }
+    its(:name) { should == VM_SPEC_OPTS[:working_folder].split('/').last }
+  end
+
+  describe '#folder!' do
+    it 'should raise a RuntimeError given a path to a non-existent folder' do
+      expect { @monkey.folder! '/xyzzy' }.to raise_error RuntimeError
+    end
+  end
+
+  describe '#vm' do
+    subject { @vm ||= @monkey.vm VM_SPEC_OPTS[:template_path] }
+
+    it { should_not be_nil }
+    its(:name) { should == VM_SPEC_OPTS[:template_path].split('/').last }
+  end
+
+  describe '#vm!' do
+    it 'should raise a RuntimeError given a path to a non-existent vm' do
+      expect { @monkey.vm! '/xyzzy' }.to raise_error RuntimeError
+    end
+  end
+
+  describe '#vapp' do
+    subject { @vapp ||= @monkey.vapp VM_SPEC_OPTS[:vapp_path] }
+
+    it { should_not be_nil }
+    its(:name) { should == VM_SPEC_OPTS[:vapp_path].split('/').last }
+  end
+
+  describe '#vapp!' do
+    it 'should raise a RuntimeError given a path to a non-existent vapp' do
+      expect { @monkey.vapp! '/xyzzy' }.to raise_error RuntimeError
+    end
+  end
+
+  describe '#get' do
+    context 'given a path to a real object' do
+      subject { @get ||= @monkey.get VM_SPEC_OPTS[:working_folder] }
+
+      it { should_not be_nil }
+      its(:name) { should == VM_SPEC_OPTS[:working_folder].split('/').last }
+    end
+
+    context 'given a path to a non-existent object' do
+      subject { @get_nil ||= @monkey.get '/xyzzy' }
+
+      it { should be_nil }
+    end
+  end
+
+  describe '#customization_spec' do
+    context 'given an existing customization spec' do
+      subject { @cspec ||= @monkey.customization_spec VM_SPEC_OPTS[:customization_spec] }
+
+      it { should_not be_nil }
+    end
+
+    context 'given a non-existing customization spec' do
+      subject { @cspec ||= @monkey.customization_spec 'xyzzy' }
+
+      it { should be_nil }
+    end
+
+  end
+
+end

data/spec/virtualmachine_spec.rb

@@ -0,0 +1,211 @@
+require_relative 'spec_helper'
+
+describe RbVmomi::VIM::VirtualMachine do
+  before :all do
+    @monkey ||= VMonkey.connect
+    @template = @monkey.vm VM_SPEC_OPTS[:template_path]
+    @vm_path = "#{VM_SPEC_OPTS[:working_folder]}/vmonkey_spec"
+  end
+
+  describe '#_clone_params' do
+    context 'with Folder destination' do
+      subject { @params ||= @template._clone_params(@vm_path.basename, @monkey.get(@vm_path.parent), {}) }
+
+      it { expect(subject[:name]).to eq @vm_path.basename }
+      it { expect(subject[:folder].name).to eq @vm_path.parent.basename }
+      it { expect(subject[:spec].powerOn).to eq false }
+      it { expect(subject[:spec].template).to eq false }
+      it { expect(subject[:spec].location.pool.name).to eq 'Resources' }
+    end
+
+    context 'with vApp destination' do
+      subject { @params ||= @template._clone_params(@vm_path.basename, @monkey.vapp(VM_SPEC_OPTS[:vapp_path]), {}) }
+
+      it { expect(subject[:name]).to eq @vm_path.basename }
+      it { expect(subject[:folder].name).to eq VM_SPEC_OPTS[:vapp_path].parent.basename }
+      it { expect(subject[:spec].powerOn).to eq false }
+      it { expect(subject[:spec].template).to eq false }
+      it { expect(subject[:spec].location.pool.name).to eq VM_SPEC_OPTS[:vapp_path].basename }
+
+      it { expect(subject[:spec].customization).to be_nil }
+      it { expect(subject[:spec].config.annotation).to be_nil }
+      it { expect(subject[:spec].config.numCPUs).to be_nil }
+      it { expect(subject[:spec].config.memoryMB).to be_nil }
+    end
+
+    context 'with config' do
+      subject do
+        @params ||=
+          @template._clone_params(
+            @vm_path.basename,
+            @monkey.get(@vm_path.parent),
+            customization_spec: VM_SPEC_OPTS[:customization_spec],
+            config: {
+              annotation: 'an annotation',
+              num_cpus: 3,
+              memory_mb: 1024
+            })
+      end
+
+      it { expect(subject[:spec].customization).to_not be_nil }
+      it { expect(subject[:spec].config.annotation).to eq 'an annotation' }
+      it { expect(subject[:spec].config.numCPUs).to eq 3 }
+      it { expect(subject[:spec].config.memoryMB).to eq 1024 }
+    end
+  end
+
+  context 'with a cloned VM' do
+    before(:all) { @spec_vm = @template.clone_to @vm_path }
+    after(:all)  { @spec_vm.destroy }
+
+    describe '#clone' do
+      context 'to a Folder' do
+        subject { @monkey.vm @vm_path }
+        it { should_not be_nil }
+      end
+    end
+
+    describe '#annotation=' do
+      it 'sets the annotation' do
+        @spec_vm.annotation = 'xyzzy'
+        expect(@spec_vm.annotation).to eq 'xyzzy'
+      end
+    end
+
+    describe '#property' do
+      before(:all) do
+        @spec_vm.property :prop, 'xyzzy'
+        @spec_vm.property :prop2, 'abc123'
+        @spec_vm.property :prop2, 'abc456'
+      end
+
+      it { expect(@spec_vm.property :prop).to eq 'xyzzy' }
+      it { expect(@spec_vm.property :prop2).to eq 'abc456' }
+      it { expect(@spec_vm.property :xyzzy).to be_nil }
+    end
+
+    describe '#property!' do
+      it 'should raise a RuntimeError given a path to a non-existent property' do
+        expect { @spec_vm.property! :xyzzy }.to raise_error RuntimeError
+      end
+    end
+
+    describe '#move_to' do
+      it 'should raise a RuntimeError when given a path of an existing VM' do
+        expect { @spec_vm.move_to @vm_path }.to raise_error RuntimeError
+      end
+
+      it 'should move a vm to a new name in the same folder' do
+        parent = @spec_vm.parent
+
+        @spec_vm.move_to "#{@vm_path}-moved"
+        expect(@spec_vm.name).to eq "#{@vm_path.basename}-moved"
+        expect(@spec_vm.parent).to eq parent
+
+        @spec_vm.move_to @vm_path
+        expect(@spec_vm.name).to eq @vm_path.basename
+        expect(@spec_vm.parent).to eq parent
+      end
+
+      it 'should move a vm to the same name in a new folder' do
+        from_folder = @spec_vm.parent
+        from_name = @spec_vm.name
+        to_path = "#{VM_SPEC_OPTS[:working_folder2]}/#{@vm_path.basename}"
+        to_folder = @monkey.folder VM_SPEC_OPTS[:working_folder2]
+
+        @spec_vm.move_to to_path
+        expect(@spec_vm.name).to eq from_name
+        expect(@spec_vm.parent).to eq to_folder
+
+        @spec_vm.move_to @vm_path
+        expect(@spec_vm.name).to eq from_name
+        expect(@spec_vm.parent).to eq from_folder
+      end
+
+      it 'should move a vm to a new name in a new folder' do
+        from_folder = @spec_vm.parent
+        from_name = @spec_vm.name
+        to_name = "#{@vm_path.basename}-different"
+        to_path = "#{VM_SPEC_OPTS[:working_folder2]}/#{to_name}"
+        to_folder = @monkey.folder VM_SPEC_OPTS[:working_folder2]
+
+        @spec_vm.move_to to_path
+        expect(@spec_vm.name).to eq to_name
+        expect(@spec_vm.parent).to eq to_folder
+
+        @spec_vm.move_to @vm_path
+        expect(@spec_vm.name).to eq from_name
+        expect(@spec_vm.parent).to eq from_folder
+      end
+    end
+
+    describe '#move_to!' do
+      before(:all) do
+        @other_path = "#{@vm_path}-other"
+        @other_vm = @spec_vm.clone_to @other_path
+      end
+      
+      after(:all) do
+        other_vm = @monkey.vm @other_path
+        other_vm.destroy if other_vm
+      end
+
+      it 'should overwrite a VM when given a path of an existing VM' do
+        @spec_vm.move_to! @other_path
+        expect(@monkey.vm @other_path).to_not be_nil
+
+        @spec_vm.move_to @vm_path
+        expect(@monkey.vm @other_path).to be_nil
+      end
+    end
+
+    describe '#stop' do
+      it 'should return successfully when the VM is already powered off' do
+        expect { @spec_vm.stop }.to_not raise_error
+      end
+    end
+
+    describe '#port_ready?' do
+      it 'should be false when the VM is powered off' do
+        expect( @spec_vm.port_ready? 22 ).to be_false
+      end
+    end
+
+    context 'that has had #start called' do
+      before(:all) { @spec_vm.start }
+
+      describe '#port_ready?' do
+        it 'should be false immediately following start' do
+          expect(@spec_vm.port_ready? 22).to be_false
+        end
+
+        it 'should be true after wait_for_port' do
+          @spec_vm.wait_for_port 22
+          expect(@spec_vm.port_ready? 22).to be_true
+        end
+      end
+
+      after(:all) { @spec_vm.stop }
+    end
+
+  end
+
+  describe '#clone' do
+    context 'to a vApp' do
+      before :all do
+        @vm_name_in_vapp = "#{@vm_path.basename}-vapp"
+        @template.clone_to "#{VM_SPEC_OPTS[:vapp_path]}/#{@vm_name_in_vapp}"
+        @spec_vapp = @monkey.vapp VM_SPEC_OPTS[:vapp_path]
+      end
+
+      subject { @spec_vapp.find_vm @vm_name_in_vapp }
+
+      it { should_not be_nil }
+
+      after :all do
+        (@spec_vapp.find_vm @vm_name_in_vapp).destroy
+      end
+    end
+  end
+
+end

data/spec/vmonkey_spec.rb

@@ -0,0 +1,12 @@
+require_relative 'spec_helper'
+
+describe VMonkey do
+  describe '#connect' do
+    subject { @vim ||= VMonkey.connect }
+
+    it { should_not be_nil }
+    its(:dc) { should_not be_nil }
+    its(:cluster) { should_not be_nil }
+  end
+end
+

data/vmonkey.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vmonkey/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'vmonkey'
+  spec.version       = Vmonkey::VERSION
+  spec.authors       = ['Brian Dupras', 'Dave Smith']
+  spec.email         = ['brian@duprasville.com', 'dsmith@rallydev.com']
+  spec.summary       = %q{ simple to use vsphere methods }
+  spec.description   = %q{ simple to use vsphere methods }
+  spec.homepage      = 'https://github.com/something/vmonkey'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'nokogiri', '= 1.5.5' #until vmware/rbvmomi issue #32 is fixed
+  spec.add_dependency 'rbvmomi', '~> 1.5'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: vmonkey
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brian Dupras
+- Dave Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+- !ruby/object:Gem::Dependency
+  name: rbvmomi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' simple to use vsphere methods '
+email:
+- brian@duprasville.com
+- dsmith@rallydev.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vmonkey.rb
+- lib/vmonkey/version.rb
+- lib/vmonkey/vim/Datacenter.rb
+- lib/vmonkey/vim/Folder.rb
+- lib/vmonkey/vim/VirtualApp.rb
+- lib/vmonkey/vim/VirtualMachine.rb
+- lib/vmonkey/vim/vim.rb
+- spec/datacenter_spec.rb
+- spec/folder_spec.rb
+- spec/spec_helper.rb
+- spec/vapp_spec.rb
+- spec/vim_spec.rb
+- spec/virtualmachine_spec.rb
+- spec/vmonkey_spec.rb
+- vmonkey.gemspec
+homepage: https://github.com/something/vmonkey
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: simple to use vsphere methods
+test_files:
+- spec/datacenter_spec.rb
+- spec/folder_spec.rb
+- spec/spec_helper.rb
+- spec/vapp_spec.rb
+- spec/vim_spec.rb
+- spec/virtualmachine_spec.rb
+- spec/vmonkey_spec.rb