fog 1.3.1 → 1.4.0

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

@@ -69,11 +69,22 @@ module Fog
           # Now find the template itself using the efficient find method
           vm_mob_ref = folder.find(template_name, RbVmomi::VIM::VirtualMachine)
 
-          # Now find _a_ resource pool of the template's host (REVISIT: We need
-          # to support cloning into a specific RP)
-          esx_host = vm_mob_ref.collect!('runtime.host')['runtime.host']
-          # The parent of the ESX host itself is a ComputeResource which has a resourcePool
-          resource_pool = esx_host.parent.resourcePool
+          # Now find _a_ resource pool to use for the clone
+          # (REVISIT: We need to support cloning into a specific RP)
+
+          if ( vm_mob_ref.resourcePool == nil )
+            # If the template is really a template then there is no associated resource pool,
+            # so we need to find one using the template's parent host or cluster
+            esx_host = vm_mob_ref.collect!('runtime.host')['runtime.host']
+            # The parent of the ESX host itself is a ComputeResource which has a resourcePool
+            resource_pool = esx_host.parent.resourcePool
+          else
+            # If the vm given did return a valid resource pool, default to using it for the clone.
+            # Even if specific pools aren't implemented in this environment, we will still get back
+            # at least the cluster or host we can pass on to the clone task
+            resource_pool = vm_mob_ref.resourcePool
+          end
+          
           relocation_spec=nil
           if ( options['linked_clone'] )
             # cribbed heavily from the rbvmomi clone_vm.rb

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

@@ -0,0 +1,47 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_config_vnc(options = { })
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.has_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.has_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/xenserver.rb

@@ -0,0 +1,56 @@
+module Fog
+  module XenServer 
+
+    class InvalidLogin < Fog::Errors::Error; end
+    class NotFound < Fog::Errors::Error; end
+    class RequestFailed < Fog::Errors::Error; end
+
+    extend Fog::Provider
+    
+    service(:compute, 'xenserver/compute', 'Compute')  
+    
+    class Connection
+      require 'xmlrpc/client'
+    
+      def initialize(host)
+        @factory = XMLRPC::Client.new(host, '/')
+        @factory.set_parser(XMLRPC::XMLParser::REXMLStreamParser.new)
+      end
+    
+      def authenticate( username, password )
+        response = @factory.call('session.login_with_password', username, password )
+        raise Fog::XenServer::InvalidLogin.new unless response["Status"] =~ /Success/
+        @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
+
+  end
+end
+
+

data/lib/fog/xenserver/compute.rb

@@ -0,0 +1,122 @@
+require 'fog/xenserver'
+require 'fog/compute'
+
+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
+      
+      model_path 'fog/xenserver/models/compute'
+      model :server
+      collection :servers
+      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
+
+      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 :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
+    
+      class Real
+        
+        def initialize(options={})
+          @host        = options[:xenserver_url]
+          @username    = options[:xenserver_username]
+          @password    = options[:xenserver_password]
+          @defaults    = options[:xenserver_defaults] || {}
+          @connection  = Fog::XenServer::Connection.new(@host)
+          @connection.authenticate(@username, @password)
+        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::Connection.new(@host)
+          @connection.authenticate(@username, @password)
+        end
+        
+      end
+    end
+  end
+end
+
+

data/lib/fog/xenserver/models/compute/guest_metrics.rb

@@ -0,0 +1,28 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+    
+      class GuestMetrics < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/5.6.0/1.0/en_gb/api/?c=VM_guest_metrics
+        
+        identity :reference
+        
+        attribute :uuid
+        attribute :last_updated
+        attribute :live
+        attribute :memory
+        attribute :networks
+        attribute :os_version
+        attribute :other
+        attribute :other_config
+        attribute :pv_drivers_up_to_date,    :aliases => :PV_drivers_up_to_date
+        attribute :pv_drivers_version,       :aliases => :PV_drivers_version
+        
+      end
+      
+    end
+  end
+end

data/lib/fog/xenserver/models/compute/host.rb

@@ -0,0 +1,46 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class Host < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/5.6.0/1.0/en_gb/api/?c=host
+        
+        identity :reference
+        
+        attribute :name,              :aliases => :name_label
+        attribute :uuid
+        attribute :address
+        attribute :allowed_operations
+        attribute :enabled
+        attribute :hostname
+        attribute :metrics
+        attribute :name_description
+        attribute :other_config
+        attribute :__pbds,            :aliases => :PBDs
+        attribute :__pifs,            :aliases => :PIFs
+        attribute :__resident_vms,      :aliases => :resident_VMs
+        
+        def pifs
+          __pifs.collect { |pif| connection.pifs.get pif }
+        end
+
+        def pbds
+          __pbds.collect { |pbd| connection.pbds.get pbd }
+        end
+
+        def resident_servers
+          __resident_vms.collect { |ref| connection.servers.get ref }
+        end
+
+        def resident_vms
+          resident_servers
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/fog/xenserver/models/compute/hosts.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/xenserver/models/compute/host'
+
+module Fog
+  module Compute
+    class XenServer
+      
+      class Hosts < Fog::Collection
+        
+        model Fog::Compute::XenServer::Host
+        
+        def all(options={})
+          data = connection.get_records 'host'
+          load(data)
+        end
+        
+        def get( host_ref )
+          if host_ref && host = connection.get_record( host_ref, 'host' )
+            new(host)
+          else
+            nil
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/fog/xenserver/models/compute/network.rb

@@ -0,0 +1,58 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+    
+      class Network < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/5.6.0/1.0/en_gb/api/?c=network
+        
+        identity :reference
+        
+        attribute :uuid
+        attribute :__vifs,             :aliases => :VIFs 
+        attribute :tags
+        attribute :mtu,                :aliases => :MTU
+        attribute :bridge
+        attribute :description,        :aliases => :name_description
+        attribute :name,               :aliases => :name_label
+        attribute :other_config
+        attribute :__pifs,               :aliases => :PIFs
+        attribute :allowed_operations   
+        attribute :current_operations
+        attribute :blobs
+        
+        def refresh
+          data = connection.get_record( reference, 'network' )
+          merge_attributes( data )
+          true
+        end
+        
+        #
+        # Return the list of network related PIFs
+        #
+        def pifs
+          p = []
+          __pifs.each do |pif|
+            p << connection.pifs.get(pif)
+          end
+          p
+        end
+
+        #
+        # Return the list of network related VIFs
+        #
+        def vifs
+          v = []
+          __vifs.each do |vif|
+            v << connection.vifs.get(vif)
+          end
+          v
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/fog/xenserver/models/compute/networks.rb

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/xenserver/models/compute/network'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class Networks < Fog::Collection
+
+        model Fog::Compute::XenServer::Network
+        
+        def initialize(attributes)
+          super
+        end
+
+        def all(options = {})
+          data = connection.get_records 'network'
+          load(data)
+        end
+
+        def get( ref )
+          if ref && obj = connection.get_record( ref, 'network' )
+            new(obj)
+          end
+        rescue Fog::XenServer::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end