fog-vsphere 0.1.0

data/lib/fog/vsphere/requests/compute/vm_config_vnc.rb

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_config_vnc(options = { })
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref    = @connection.searchIndex.FindAllByUuid(search_filter).first
+          task          = vm_mob_ref.ReconfigVM_Task(:spec => {
+            :extraConfig => [
+              { :key => 'RemoteDisplay.vnc.enabled',  :value => options[:enabled] ? 'true' : 'false' },
+              { :key => 'RemoteDisplay.vnc.password', :value => options[:password].to_s },
+              { :key => 'RemoteDisplay.vnc.port',     :value => options[:port].to_s || '5910' }
+            ]
+          })
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+
+        # return a hash of VNC attributes required to view the console
+        def vm_get_vnc uuid
+          search_filter = { :uuid => uuid, 'vmSearch' => true, 'instanceUuid' => true }
+          vm = @connection.searchIndex.FindAllByUuid(search_filter).first
+          Hash[vm.config.extraConfig.map do |config|
+            if config.key =~ /^RemoteDisplay\.vnc\.(\w+)$/
+              [$1.to_sym, config.value]
+            end
+          end.compact]
+        end
+      end
+
+      class Mock
+        def vm_config_vnc(options = { })
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+
+        def vm_get_vnc uuid
+          {:password => 'secret', :port => '5900', :enabled => 'true'}
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_destroy.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_destroy(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+
+          vm_mob_ref = get_vm_ref(options['instance_uuid'])
+          task = vm_mob_ref.Destroy_Task
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_destroy(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_execute.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        # NOTE: you must be using vsphere_rev 5.0 or greater to use this functionality
+        # e.g. Fog::Compute.new(provider: "vsphere", vsphere_rev: "5.5", etc)
+        # * options<~Hash>:
+        #   * 'instance_uuid'<~String> - *REQUIRED* the instance uuid you would like to operate on
+        #   * 'command'<~String> *REQUIRED* the command to execute
+        #   * 'args'<~String> arguments to pass the command
+        #   * 'working_dir'<~String> path to the working directory
+        #   * 'user'<~String> *REQUIRED* the ssh username you would like to login as
+        #   * 'password'<~String> *REQUIRED* the ssh password for the user you would like to log in as
+        def vm_execute(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, "command is a required parameter" unless options.key? 'command'
+          raise ArgumentError, "user is a required parameter" unless options.key? 'user'
+          raise ArgumentError, "password is a required parameter" unless options.key? 'password'
+
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+
+          auth = RbVmomi::VIM::NamePasswordAuthentication(:interactiveSession => false,
+                                                          :username => options['user'],
+                                                          :password => options['password'])
+
+          spec = RbVmomi::VIM::GuestProgramSpec(:programPath => options['command'],
+                                                :arguments => options['args'],
+                                                :workingDirectory => options['working_dir'])
+
+          gom = @connection.serviceContent.guestOperationsManager
+          gom.processManager.StartProgramInGuest(:vm => vm_mob_ref, :auth => auth, :spec => spec)
+        end
+      end
+
+      class Mock
+        def vm_execute(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, "command is a required parameter" unless options.key? 'command'
+          raise ArgumentError, "user is a required parameter" unless options.key? 'user'
+          raise ArgumentError, "password is a required parameter" unless options.key? 'password'
+          return 12345
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_migrate.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_migrate(options = {})
+          #priority is the only required option, and it has a sane default option.
+          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+
+          # Find the VM Object
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+
+          unless vm_mob_ref.kind_of? RbVmomi::VIM::VirtualMachine
+            raise Fog::Vsphere::Errors::NotFound,
+              "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
+          end
+          task = vm_mob_ref.MigrateVM_Task(:pool => options['pool'], :host => options['host'], :priority => "#{priority}", :state => options['state'] )
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_migrate(options = {})
+          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_power_off.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_power_off(options = {})
+          options = { 'force' => false }.merge(options)
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+
+          if options['force'] then
+            task = vm_mob_ref.PowerOffVM_Task
+            task.wait_for_completion
+            { 'task_state' => task.info.result, 'power_off_type' => 'cut_power' }
+          else
+            vm_mob_ref.ShutdownGuest
+            {
+              'task_state'     => "running",
+              'power_off_type' => 'shutdown_guest',
+            }
+          end
+        end
+      end
+
+      class Mock
+        def vm_power_off(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          vm = get_virtual_machine(options['instance_uuid'])
+          vm["power_state"] = "poweredOff"
+          {
+            'task_state'     => "running",
+            'power_off_type' => options['force'] ? 'cut_power' : 'shutdown_guest',
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_power_on.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_power_on(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+
+          task = vm_mob_ref.PowerOnVM_Task
+          task.wait_for_completion
+          # 'success', 'running', 'queued', 'error'
+          { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_power_on(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_reboot.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reboot(options = {})
+          options = { 'force' => false }.merge(options)
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
+
+          if options['force'] then
+            task = vm_mob_ref.ResetVM_Task
+            task.wait_for_completion
+            { 'task_state' => task.info.result, 'reboot_type' => 'reset_power' }
+          else
+            vm_mob_ref.RebootGuest
+            { 'task_state' => "running", 'reboot_type' => 'reboot_guest' }
+          end
+        end
+      end
+
+      class Mock
+        def vm_reboot(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          { 'task_state'     => "running", 'reboot_type' => options['force'] ? 'reset_power' : 'reboot_guest' }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_reconfig_cpus.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_cpus(options = {})
+          raise ArgumentError, "cpus is a required parameter" unless options.key? 'cpus'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          hardware_spec={'numCPUs' => options['cpus'], 'numCoresPerSocket' => options['corespersocket']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+
+      class Mock
+        def vm_reconfig_cpus(options = {})
+          raise ArgumentError, "cpus is a required parameter" unless options.key? 'cpus'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          hardware_spec={'numCPUs' => options['cpus'], 'numCoresPerSocket' => options['corespersocket']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_reconfig_hardware.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_hardware(options = {})
+          raise ArgumentError, "hardware_spec is a required parameter" unless options.key? 'hardware_spec'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          vm_mob_ref = get_vm_ref(options['instance_uuid'])
+          task = vm_mob_ref.ReconfigVM_Task(:spec => RbVmomi::VIM.VirtualMachineConfigSpec(options['hardware_spec']))
+          task.wait_for_completion
+           { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_reconfig_hardware(options = {})
+          raise ArgumentError, "hardware_spec is a required parameter" unless options.key? 'hardware_spec'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_reconfig_memory.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_reconfig_memory(options = {})
+          raise ArgumentError, "memory is a required parameter" unless options.key? 'memory'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          hardware_spec={'memoryMB' => options['memory']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+
+      class Mock
+        def vm_reconfig_memory(options = {})
+          raise ArgumentError, "memory is a required parameter" unless options.key? 'memory'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          hardware_spec={'memoryMB' => options['memory']}
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_take_snapshot.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_take_snapshot(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, "name is a required parameter" unless options.key? 'name'
+          vm = get_vm_ref(options['instance_uuid'])
+          task = vm.CreateSnapshot_Task(
+            :name => options['name'],
+            :description => options['description'] || '',
+            :memory => options['memory'] || true,
+            :quiesce => options['quiesce'] || false
+          )
+
+          task.wait_for_completion
+
+          {
+            'task_state' => task.info.state,
+            'was_cancelled' => task.info.cancelled
+          }
+        end
+      end
+
+      class Mock
+        def vm_take_snapshot(options = {})
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, "name is a required parameter" unless options.key? 'name'
+          {
+            'task_state' => 'success',
+            'was_cancelled' => false
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/version.rb

@@ -0,0 +1,5 @@
+module Fog
+  module Vsphere
+    VERSION = "0.1.0"
+  end
+end

data/tests/compute_tests.rb

@@ -0,0 +1,53 @@
+Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  tests("| convert_vm_mob_ref_to_attr_hash") do
+    # Mock the RbVmomi::VIM::ManagedObject class
+    class MockManagedObject
+      attr_reader :parent, :_ref
+
+      def initialize
+        @parent = @_ref = 'vm-123'
+      end
+
+      def collect! *pathSet
+        { '_ref' => 'vm-123', 'name' => 'fakevm' }
+      end
+    end
+
+    fake_vm_mob_ref = MockManagedObject.new
+
+    tests("When converting an incomplete vm object") do
+      test("it should return a Hash") do
+        compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref).kind_of? Hash
+      end
+      tests("The converted Hash should") do
+        attr_hash = compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref)
+        test("have a name") { attr_hash['name'] == 'fakevm' }
+        test("have a mo_ref") {attr_hash['mo_ref'] == 'vm-123' }
+        test("have an id") { attr_hash['id'] == 'vm-123' }
+        test("not have a instance_uuid") { attr_hash['instance_uuid'].nil? }
+      end
+    end
+
+    tests("When passed a nil object") do
+      attr_hash = compute.send :convert_vm_mob_ref_to_attr_hash, nil
+      test("it should return a nil object") do
+        attr_hash.nil?
+      end
+    end
+  end
+
+  tests("Compute attributes") do
+    %w{ vsphere_is_vcenter vsphere_rev vsphere_username vsphere_server }.each do |attr|
+      test("it should respond to #{attr}") { compute.respond_to? attr }
+    end
+  end
+
+  tests("Compute collections") do
+    %w{ servers }.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+end

data/tests/helper.rb

@@ -0,0 +1,8 @@
+begin
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+rescue LoadError => e
+  $stderr.puts "not recording test coverage: #{e.inspect}"
+end
+
+require File.expand_path('../../lib/fog/vsphere', __FILE__)

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,9 @@
+Fog.mock! if ENV['FOG_MOCK'] == 'true'
+
+if Fog.mock?
+  Fog.credentials = {
+    :vsphere_server   => 'fake_vsphere_server',
+    :vsphere_username => 'fake_vsphere_username',
+    :vsphere_password => 'fake_vsphere_password'
+  }.merge(Fog.credentials)
+end