fog 1.31.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_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.rb

@@ -1 +0,0 @@
-require 'fog/vsphere/compute'

data/lib/fog/xenserver/CHANGELOG.md

@@ -1,77 +0,0 @@
-# 1.10.1 2013/04/04
-
-* It's now possible to manage XS/XCP VLANs and Networks
-
-  See https://github.com/fog/fog/blob/master/lib/fog/xenserver/examples/networks-and-vlans.rb
-
-# 1.9.0 2013/01/19
-
-* Added missing HostCpu model
-
-  So you can retrieve things like the CPU model, speed, flags
-  utilisation, vendor, etc.
-
-  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host_cpu
-
-* Host model improvements
-
-  Added missing host attributes:
-
-  - edition
-  - software_version
-  - enable
-  - disable
-  - shutdown
-  - reboot
-
-  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host
-
-* PBD model improvements
-
-  - Added missing currently_attached attribute
-  - A PBD can be unplugged now
-
-  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=PBD
-
-* StorageRepository model improvements
-
-  - Added missing create/destroy/save operations
-  - Added missing generic set_attribute method
-
-  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=SR
-
-* Pool model improvements
-
-  - Added missing suspend_image_sr attribute
-  - Added default_sr getter/setter
-  - Added suspend_image_sr getter/setter
-  - Added generic set_attribute method
-
-  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=pool
-
-* Switch to nokogiri XML parser
-
-  Use Nokogiri instead of slow REXML for parsing, greatly improving
-  parsing time under some ruby implementations.
-
-* Greatly improved documentation
-
-  New tutorials included with the provider:
-
-  - Getting started: the compute service
-  - How To Change the Default Storage Repository to File-based VHD-on-EXT3
-  - Example that covers a Citrix KB ctx116324 article
-  - Creating servers (VMs) and templates
-  - Managing Storage Repositories
-
-  See https://github.com/fog/fog/tree/master/lib/fog/xenserver/examples
-
-* Added missing HostMetrics model
-
-  Retrieve the metrics associated with a host.
-
-  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host_metrics
-
-* Fixed authentication issues when using numeric-only passwords
-
-* Better test coverage

data/lib/fog/xenserver/compute.rb

@@ -1,186 +0,0 @@
-require 'fog/xenserver/core'
-
-module Fog
-  module Compute
-    class XenServer < Fog::Service
-      require 'fog/xenserver/utilities'
-      require 'fog/xenserver/parser'
-
-      requires :xenserver_username
-      requires :xenserver_password
-      requires :xenserver_url
-      recognizes :xenserver_defaults
-      recognizes :xenserver_timeout
-      recognizes :xenserver_redirect_to_master
-
-      model_path 'fog/xenserver/models/compute'
-      model :blob
-      collection :blobs
-      model :bond
-      collection :bonds
-      model :crash_dump
-      collection :crash_dumps
-      model :dr_task
-      collection :dr_tasks
-      model :gpu_group
-      collection :gpu_groups
-      model :host_crash_dump
-      collection :host_crash_dumps
-      model :host_patch
-      collection :host_patchs
-      model :pci
-      collection :pcis
-      model :pgpu
-      collection :pgpus
-      model :pif_metrics
-      collection :pifs_metrics
-      model :pool_patch
-      collection :pool_patchs
-      model :role
-      collection :roles
-      model :server
-      collection :servers
-      model :server_appliance
-      collection :server_appliances
-      model :storage_manager
-      collection :storage_managers
-      model :tunnel
-      collection :tunnels
-      model :vmpp
-      collection :vmpps
-      model :vtpm
-      collection :vtpms
-      model :host
-      collection :hosts
-      collection :vifs
-      model :vif
-      collection :storage_repositories
-      model :storage_repository
-      collection :pools
-      model :pool
-      collection :vbds
-      model :vbd
-      collection :vdis
-      model :vdi
-      collection :networks
-      model :network
-      collection :pifs
-      model  :pif
-      collection :pbds
-      model  :pbd
-      model  :guest_metrics
-      model  :vbd_metrics
-      model  :host_metrics
-      model  :host_cpu
-      model  :vlan
-      collection :vlans
-      model  :console
-      collection :consoles
-
-      request_path 'fog/xenserver/requests/compute'
-      request :create_server
-      request :create_vif
-      request :create_vdi
-      request :create_vbd
-      request :destroy_vif
-      request :clone_server
-      request :destroy_server
-      request :destroy_record
-      request :unplug_vbd
-      request :eject_vbd
-      request :insert_vbd
-      request :destroy_vdi
-      request :shutdown_server
-      request :start_vm
-      request :start_server
-      request :get_record
-      request :get_records
-      request :set_affinity
-      request :set_attribute
-      request :reboot_server
-      request :provision_server
-      request :scan_sr
-      request :unplug_pbd
-      request :destroy_sr
-      request :create_sr
-      request :reboot_host
-      request :disable_host
-      request :enable_host
-      request :shutdown_host
-      request :create_network
-      request :destroy_network
-      request :create_vlan
-      request :destroy_vlan
-      request :snapshot_server
-      request :snapshot_revert
-
-      class Real
-
-        attr_reader :connection
-
-        def initialize(options={})
-          @host                 = options[:xenserver_url]
-          @username             = options[:xenserver_username]
-          @password             = options[:xenserver_password]
-          @defaults             = options[:xenserver_defaults] || {}
-          @timeout              = options[:xenserver_timeout] || 30
-          @redirect_to_master   = options[:xenserver_redirect_to_master] || false
-          @connection           = Fog::XenServer::Connection.new(@host, @timeout)
-          begin
-            @connection.authenticate(@username, @password)
-          rescue Fog::XenServer::HostIsSlave => e
-            if @redirect_to_master
-              Fog::Logger.debug "Redirecting to master #{e.master_ip}"
-              @host = e.master_ip
-              @connection  = Fog::XenServer::Connection.new(@host, @timeout)
-              @connection.authenticate(@username, @password)
-            else
-              raise e
-            end
-          end
-        end
-
-        def reload
-          @connection.authenticate(@username, @password)
-        end
-
-        def default_template=(name)
-          @defaults[:template] = name
-        end
-
-        def default_template
-          return nil if @defaults[:template].nil?
-          (servers.custom_templates + servers.builtin_templates).find do |s|
-            (s.name == @defaults[:template]) or (s.uuid == @defaults[:template])
-          end
-        end
-
-        def default_network
-          networks.find { |n| n.name == (@defaults[:network] || "Pool-wide network associated with eth0") }
-        end
-      end
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset_data(keys=data.keys)
-          for key in [*keys]
-            data.delete(key)
-          end
-        end
-
-        def initialize(options={})
-          @host        = options[:xenserver_pool_master]
-          @username    = options[:xenserver_username]
-          @password    = options[:xenserver_password]
-          @connection  = Fog::XML::Connection.new(@host)
-          @connection.authenticate(@username, @password)
-        end
-      end
-    end
-  end
-end

data/lib/fog/xenserver/core.rb

@@ -1,94 +0,0 @@
-require 'fog/core'
-require 'fog/xml'
-
-module Fog
-  module XenServer
-    class InvalidLogin < Fog::Errors::Error; end
-    class NotFound < Fog::Errors::Error; end
-    class RequestFailed < Fog::Errors::Error; end
-    class HostIsSlave < Fog::Errors::Error
-      attr_reader :master_ip
-
-      def initialize(master_ip)
-        @master_ip = master_ip
-      end
-
-    end
-
-    extend Fog::Provider
-
-    service(:compute, 'Compute')
-
-    class Connection
-      require 'xmlrpc/client'
-      attr_reader :credentials
-
-      def initialize(host, timeout)
-        @factory = XMLRPC::Client.new(host, '/')
-        @factory.set_parser(NokogiriStreamParser.new)
-        @factory.timeout = timeout
-      end
-
-      def authenticate( username, password )
-        response = @factory.call('session.login_with_password', username.to_s, password.to_s)
-        if response['Status'] == 'Failure'
-          if response['ErrorDescription'][0] == 'HOST_IS_SLAVE'
-            master_ip = response['ErrorDescription'][1]
-            raise Fog::XenServer::HostIsSlave.new(master_ip)
-          else
-            raise Fog::XenServer::InvalidLogin.new
-          end
-        end
-        @credentials = response["Value"]
-      end
-
-      def request(options, *params)
-        begin
-          parser   = options.delete(:parser)
-          method   = options.delete(:method)
-
-          if params.empty?
-            response = @factory.call(method, @credentials)
-          else
-            if params.length.eql?(1) and params.first.is_a?(Hash)
-              response = @factory.call(method, @credentials, params.first)
-            elsif params.length.eql?(2) and params.last.is_a?(Array)
-              response = @factory.call(method, @credentials, params.first, params.last)
-            else
-              response = eval("@factory.call('#{method}', '#{@credentials}', #{params.map {|p|  p.is_a?(String) ? "'#{p}'" : p}.join(',')})")
-            end
-          end
-          raise RequestFailed.new("#{method}: " + response["ErrorDescription"].to_s) unless response["Status"].eql? "Success"
-          if parser
-            parser.parse( response["Value"] )
-            response = parser.response
-          end
-
-          response
-        end
-      end
-    end
-
-    class NokogiriStreamParser < XMLRPC::XMLParser::AbstractStreamParser
-      def initialize
-        require 'nokogiri/xml/sax/document'
-        require 'nokogiri/xml/sax/parser'
-
-        @parser_class = Class.new(Nokogiri::XML::SAX::Document) do
-
-          include XMLRPC::XMLParser::StreamParserMixin
-
-          alias_method :start_element, :startElement
-          alias_method :end_element,   :endElement
-          alias_method :characters,    :character
-          alias_method :cdata_block,   :character
-
-          def parse(str)
-            Nokogiri::XML::SAX::Parser.new(self).parse(str)
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/fog/xenserver/examples/README.md

@@ -1,11 +0,0 @@
-# fog/xenserver compute examples
-
-fog/xenserver examples contributed by BVox World S.L.U.
-Original examples from https://github.com/bvox/fog-xenserver-examples
-
-Maintainer: Sergio Rubio <rubiojr@bvox.net>
-
-A general introduction to Fog is available at:
-
-http://fog.io
-