fog 1.36.0 → 1.37.0

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

@@ -1,45 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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/tests/vsphere/compute_tests.rb

@@ -1,53 +0,0 @@
-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/vsphere/models/compute/server_tests.rb

@@ -1,70 +0,0 @@
-Shindo.tests('Fog::Compute[:vsphere] | server model', ['vsphere']) do
-  servers = Fog::Compute[:vsphere].servers
-  server = servers.last
-
-  tests('The server model should') do
-    tests('have the action') do
-      test('reload') { server.respond_to? 'reload' }
-      %w{ stop start destroy reboot }.each do |action|
-        test(action) { server.respond_to? action }
-        test("#{action} returns successfully") { server.send(action.to_sym) ? true : false }
-      end
-      test('guest_processes') { server.respond_to? 'guest_processes' }
-      test('take_snapshot') do
-        test('responds') { server.respond_to? 'take_snapshot'}
-        test('returns successfully') { server.take_snapshot('name' => 'foobar').kind_of? Hash }
-      end
-      test('snapshots') do
-        test('responds') { server.respond_to? 'snapshots'}
-        test('returns successfully') { server.snapshots.kind_of? Fog::Compute::Vsphere::Snapshots }
-      end
-      test('find_snapshot') do
-        test('responds') { server.respond_to? 'find_snapshot'}
-        test('returns successfully') do
-          server.find_snapshot('snapshot-0101').kind_of? Fog::Compute::Vsphere::Snapshot
-        end
-        test('returns correct snapshot') do
-          server.find_snapshot('snapshot-0101').ref == 'snapshot-0101'
-        end
-      end
-      tests('revert_snapshot') do
-        test('responds') { server.respond_to? 'revert_snapshot'}
-        tests('returns correctly') do
-          test('when correct input given') { server.revert_snapshot('snapshot-0101').kind_of? Hash }
-          test('when incorrect input given') do
-            raises(ArgumentError) { server.revert_snapshot(1) }
-          end
-        end
-      end
-    end
-    tests('have attributes') do
-      model_attribute_hash = server.attributes
-      attributes = [ :id,
-        :instance_uuid,
-        :uuid,
-        :power_state,
-        :tools_state,
-        :mo_ref,
-        :tools_version,
-        :hostname,
-        :mac_addresses,
-        :operatingsystem,
-        :connection_state,
-        :hypervisor,
-        :name,
-        :public_ip_address]
-      tests("The server model should respond to") do
-        attributes.each do |attribute|
-          test("#{attribute}") { server.respond_to? attribute }
-        end
-      end
-      tests("The attributes hash should have key") do
-        attributes.each do |attribute|
-          test("#{attribute}") { model_attribute_hash.key? attribute }
-        end
-      end
-    end
-    test('be a kind of Fog::Compute::Vsphere::Server') { server.kind_of? Fog::Compute::Vsphere::Server }
-  end
-
-end