fog 1.8.0 → 1.9.0

data/lib/fog/vsphere/models/compute/servers.rb

@@ -17,7 +17,7 @@ module Fog
         # 'folder' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
         # than simply listing everything.
         def all(filters = { })
-          load connection.list_virtual_machines(filters.merge(
+          load service.list_virtual_machines(filters.merge(
                                                   :datacenter    => datacenter,
                                                   :cluster       => cluster,
                                                   :network       => network,
@@ -27,7 +27,7 @@ module Fog
         end
 
         def get(id, datacenter = nil)
-          new connection.get_virtual_machine id, datacenter
+          new service.get_virtual_machine id, datacenter
         rescue Fog::Compute::Vsphere::NotFound
           nil
         end

data/lib/fog/vsphere/models/compute/templates.rb

@@ -10,11 +10,11 @@ module Fog
         model Fog::Compute::Vsphere::Template
 
         def all(filters = {})
-          load connection.list_templates(filters)
+          load service.list_templates(filters)
         end
 
         def get(id)
-          new connection.get_template(id)
+          new service.get_template(id)
         end
 
       end

data/lib/fog/vsphere/models/compute/volumes.rb

@@ -15,16 +15,16 @@ module Fog
           requires :vm
           case vm
             when Fog::Compute::Vsphere::Server
-              load connection.list_vm_volumes(vm.id)
+              load service.list_vm_volumes(vm.id)
             when Fog::Compute::Vsphere::Template
-              load connection.list_template_volumes(vm.id)
+              load service.list_template_volumes(vm.id)
             else
               raise 'volumes should have vm or template'
           end
         end
 
         def get(id)
-          new connection.get_volume(id)
+          new service.get_volume(id)
         end
 
      end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def create_folder(datacenter, path, name)
+          #Path cannot be nil but it can be an empty string
+          raise ArgumentError, "Path cannot be nil" if path.nil?
+
+          parent_folder = get_raw_vmfolder(path, datacenter)
+          begin
+            new_folder = parent_folder.CreateFolder(:name => name)
+            # output is cleaned up to return the new path
+            # new path will be path/name, example: "Production/Pool1"
+            new_folder.path.reject { |a| a.first.class == "Folder" }.collect { |a| a.first.name }.join("/").sub(/^\/?Datacenters\/#{datacenter}\/vm\/?/, '')
+          rescue => e
+            raise e, "failed to create folder: #{e}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -75,7 +75,7 @@ module Fog
           }
         end
 
-        def create_disk disk, index = 0, operation = :add, controller_key = 1000, unit_id = 0
+        def create_disk disk, index = 0, operation = :add, controller_key = 1000
           {
             :operation     => operation,
             :fileOperation => :create,
@@ -87,7 +87,7 @@ module Fog
                 :thinProvisioned => disk.thin
               ),
               :controllerKey => controller_key,
-              :unitNumber    => unit_id,
+              :unitNumber    => index,
               :capacityInKB  => disk.size
             )
           }

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

@@ -51,7 +51,7 @@ module Fog
             :parent     => folder.parent.name,
             :datacenter => datacenter_name,
             :type       => folder_type(folder),
-            :path       => folder.path.map(&:last).join('/'),
+            :path       => "/"+folder.path.map(&:last).join('/'),
           }
         end
 

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

@@ -12,7 +12,12 @@ module Fog
 
         def get_raw_network(name, datacenter_name)
           dc = find_raw_datacenter(datacenter_name)
-          dc.networkFolder.find(name)
+
+          @connection.serviceContent.viewManager.CreateContainerView({
+            :container  => dc.networkFolder,
+            :type       =>  ["Network"],
+            :recursive  => true
+          }).view.select{|n| n.name == name}.first
         end
       end
 

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

@@ -16,7 +16,7 @@ module Fog
                  else
                    # try to find based on VM name
                    if dc
-                     get_datacenter(dc).find_vm(id)
+                     get_raw_datacenter(dc).find_vm(id)
                    else
                      raw_datacenters.map { |d| d.find_vm(id) }.compact.first
                    end

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

@@ -9,7 +9,7 @@ module Fog
 
           options[:folder] ||= options['folder']
           if options['instance_uuid'] then
-            [connection.get_virtual_machine(options['instance_uuid'])]
+            [service.get_virtual_machine(options['instance_uuid'])]
           elsif options[:folder] && options[:datacenter] then
             list_all_virtual_machines_in_folder(options[:folder], options[:datacenter])
           else
@@ -27,8 +27,14 @@ module Fog
 
         def list_all_virtual_machines(options = { })
           datacenters = find_datacenters(options[:datacenter])
-          # TODO: go though nested folders
-          vms         = datacenters.map { |dc| dc.vmFolder.childEntity.grep(RbVmomi::VIM::VirtualMachine) }.flatten
+
+          vms = datacenters.map do |dc|
+            @connection.serviceContent.viewManager.CreateContainerView({
+              :container  => dc.vmFolder,
+              :type       =>  ["VirtualMachine"],
+              :recursive  => true
+            }).view
+          end.flatten
           # remove all template based virtual machines
           vms.delete_if { |v| v.config.template }
 

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

@@ -10,19 +10,17 @@ module Fog
             'linked_clone' => false,
           }
           options = default_options.merge(options)
-          required_options = %w{ path name }
+          # Backwards compat for "path" option
+          options["template_path"] ||= options["path"]
+          options["path"] ||= options["template_path"]
+          required_options = %w{ datacenter template_path name }
           required_options.each do |param|
             raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
           end
-          # The tap removes the leading empty string
-          path_elements = options['path'].split('/').tap { |o| o.shift }
-          first_folder = path_elements.shift
-          if first_folder != 'Datacenters' then
-            raise ArgumentError, "vm_clone path option must start with /Datacenters.  Got: #{options['path']}"
-          end
-          dc_name = path_elements.shift
-          if not datacenters.get dc_name then
-            raise ArgumentError, "Datacenter #{dc_name} does not exist, only datacenters #{datacenters.all.map(:name).join(",")} are accessible."
+          # TODO This is ugly and needs to rethink mocks
+          unless ENV['FOG_MOCK']
+            raise ArgumentError, "#{options["datacenter"]} Doesn't Exist!" unless get_datacenter(options["datacenter"])
+            raise ArgumentError, "#{options["template_path"]} Doesn't Exist!" unless get_virtual_machine(options["template_path"], options["datacenter"])
           end
           options
         end
@@ -36,22 +34,41 @@ module Fog
         #
         # ==== Parameters
         # * options<~Hash>:
+        #   * 'datacenter'<~String> - *REQUIRED* Datacenter name your cloning 
+        #     in. Make sure this datacenter exists, should if you're using
+        #     the clone function in server.rb model.
         #   * 'template_path'<~String> - *REQUIRED* The path to the machine you 
-        #     want to clone FROM. (Example:
-        #     "/Datacenter/DataCenterNameHere/FolderNameHere/VMNameHere")
+        #     want to clone FROM. Relative to Datacenter (Example:
+        #     "FolderNameHere/VMNameHere")
         #   * 'name'<~String> - *REQUIRED* The VMName of the Destination  
-        #   * 'resource_pool'<~String> - The resource pool on your datacenter 
-        #     cluster you want to use.
         #   * 'dest_folder'<~String> - Destination Folder of where 'name' will
-        #     be placed on your cluster. *NOT TESTED OR VALIDATED*
+        #     be placed on your cluster. Relative Path to Datacenter E.G.
+        #     "FolderPlaceHere/anotherSub Folder/onemore"
         #   * 'power_on'<~Boolean> - Whether to power on machine after clone. 
         #     Defaults to true.
         #   * 'wait'<~Boolean> - Whether the method should wait for the virtual
-        #     machine to close finish cloning before returning information from 
-        #     vSphere. Returns the value of the machine if it finishes cloning 
-        #     in 150 seconds (1m30s) else it returns nil. 'wait' Defaults to nil. 
-        #     Saves a little time.
+        #     machine to finish cloning before returning information from 
+        #     vSphere. Broken right now as you cannot return a model of a serer
+        #     that isn't finished cloning. Defaults to True
+        #   * 'resource_pool'<~Array> - The resource pool on your datacenter 
+        #     cluster you want to use. Only works with clusters within same
+        #     same datacenter as where you're cloning from. Datacenter grabbed
+        #     from template_path option. 
+        #     Example: ['cluster_name_here','resource_pool_name_here']
+        #   * 'datastore'<~String> - The datastore you'd like to use.
+        #       (datacenterObj.datastoreFolder.find('name') in API)
         #   * 'transform'<~String> - Not documented - see http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.RelocateSpec.html
+        #   * customization_spec<~Hash>: Options are marked as required if you
+        #     use this customization_spec. Static IP Settings not configured.
+        #     This only support cloning and setting DHCP on the first interface
+        #     * 'domain'<~String> - *REQUIRED* This is put into 
+        #       /etc/resolve.conf (we hope)
+        #     * 'hostname'<~String> - Hostname of the Guest Os - default is 
+        #       options['name']
+        #     * 'hw_utc_clock'<~Boolean> - *REQUIRED* Is hardware clock UTC? 
+        #       Default true
+        #     * 'time_zone'<~String> - *REQUIRED* Only valid linux options 
+        #       are valid - example: 'America/Denver'
         #
         def vm_clone(options = {})
           # Option handling
@@ -59,55 +76,116 @@ module Fog
 
           # Added for people still using options['path']
           template_path = options['path'] || options['template_path']
+          
+          # Default wait enabled
+          options['wait'] = true
 
-          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
-
-          # Find the template in the folder.  This is more efficient than
-          # searching ALL VM's looking for the template.
-          # Tap gets rid of the leading empty string and "Datacenters" element
-          # and returns the array.
-          path_elements = template_path.split('/').tap { |ary| ary.shift 2 }
-          # The DC name itself.
-          template_dc = path_elements.shift
-          # If the first path element contains "vm" this denotes the vmFolder
-          # and needs to be shifted out
-          path_elements.shift if path_elements[0] == 'vm'
-          # The template name.  The remaining elements are the folders in the
-          # datacenter.
-          template_name = path_elements.pop
-
-          dc = find_raw_datacenter(template_dc)
-          # Get the VM Folder (Group) efficiently
-          vm_folder = dc.vmFolder
-          # Walk the tree resetting the folder pointer as we go
-          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
-            # JJM VIM::Folder#find appears to be quite efficient as it uses the
-            # searchIndex It certainly appears to be faster than
-            # VIM::Folder#inventory since that returns _all_ managed objects of
-            # a certain type _and_ their properties.
-            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
-            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
-            sub_folder
-          end
-
+          # Options['template_path']<~String>
+          # Added for people still using options['path']
+          template_path = options['path'] || options['template_path']
           # Now find the template itself using the efficient find method
-          vm_mob_ref = folder.find(template_name, RbVmomi::VIM::VirtualMachine)
+          vm_mob_ref = get_vm_ref(template_path, options['datacenter'])
+
+          # Options['dest_folder']<~String>
+          # Grab the destination folder object if it exists else use cloned mach
+          dest_folder = get_raw_vmfolder(options['dest_folder'], options['datacenter']) if options.has_key?('dest_folder')
+          dest_folder ||= vm_mob_ref.parent
 
+          # Options['resource_pool']<~Array>
           # Now find _a_ resource pool to use for the clone if one is not specified
-          if ( options.has_key?('resource_pool') )
-            resource_pool = options['resource_pool']
+          if ( options.has_key?('resource_pool') && options['resource_pool'].is_a?(Array) && options['resource_pool'].length == 2 )
+            cluster_name = options['resource_pool'][0]
+            pool_name = options['resource_pool'][1]
+            resource_pool = get_raw_resource_pool(pool_name, cluster_name, options['datacenter'])
           elsif ( 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
+          # 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
+          # This catches if resource_pool option is set but comes back nil and if resourcePool is 
+          # already set. 
+          resource_pool ||= vm_mob_ref.resourcePool.nil? ? esx_host.parent.resourcePool : vm_mob_ref.resourcePool
+                    
+          # Options['datastore']<~String>
+          # Grab the datastore object if option is set
+          datastore_obj = get_raw_datastore(options['datastore'], options['datacenter']) if options.has_key?('datastore')
+          # confirm nil if nil or option is not set
+          datastore_obj ||= nil
+          
+          # Options['network']
+          # Build up the config spec
+          if ( options.has_key?('network_label') )
+            #network_obj = datacenter_obj.networkFolder.find(options['network_label'])
+            config_spec_operation = RbVmomi::VIM::VirtualDeviceConfigSpecOperation('edit')
+            nic_backing_info = RbVmomi::VIM::VirtualEthernetCardNetworkBackingInfo(:deviceName => options['network_label'])
+              #:deviceName => "Network adapter 1",
+              #:network => network_obj)
+            connectable = RbVmomi::VIM::VirtualDeviceConnectInfo(
+              :allowGuestControl => true,
+              :connected => true,
+              :startConnected => true)
+            device = RbVmomi::VIM::VirtualE1000(
+              :backing => nic_backing_info,
+              :deviceInfo => RbVmomi::VIM::Description(:label => "Network adapter 1", :summary => options['network_label']),
+              :key => options['network_adapter_device_key'],
+              :connectable => connectable)
+            device_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(
+              :operation => config_spec_operation,
+              :device => device)
+            virtual_machine_config_spec = RbVmomi::VIM::VirtualMachineConfigSpec(
+              :deviceChange => [device_spec])
+          end
+          
+          # Options['customization_spec']
+          # Build up all the crappy tiered objects like the perl method
+          # Collect your variables ifset (writing at 11pm revist me)
+          # * domain <~String> - *REQUIRED* - Sets the server's domain for customization
+          # * ipsettings <~Hash> - Optional - If not set defaults to dhcp
+          #  * ip <~String> - *REQUIRED* Sets the ip address of the VM - Example: 10.0.0.10
+          #  * dnsServerList <~Array> - Optional - Sets the nameservers in resolv - Example: ["10.0.0.2", "10.0.0.3"]
+          #  * gateway <~Array> - Optional - Sets the gateway for the interface - Example: ["10.0.0.1"]
+          #  * subnetMask <~String> - *REQUIRED* - Set the netmask of the interface - Example: "255.255.255.0"
+          #    For other ip settings options see http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.customization.IPSettings.html
+          if ( options.has_key?('customization_spec') )
+            cust_options = options['customization_spec']
+            if cust_options.has_key?("ipsettings")
+              raise ArgumentError, "ip and subnetMask is required for static ip" unless cust_options["ipsettings"].has_key?("ip") and
+                                                                                        cust_options["ipsettings"].has_key?("subnetMask")
+            end
+            raise ArgumentError, "domain is required" unless cust_options.has_key?("domain")
+            cust_domain = cust_options['domain']
+            cust_ip_settings = RbVmomi::VIM::CustomizationIPSettings.new(cust_options["ipsettings"]) if cust_options.has_key?("ipsettings")
+            cust_ip_settings.ip = RbVmomi::VIM::CustomizationFixedIp("ipAddress" => cust_options["ipsettings"]["ip"]) if cust_options.has_key?("ipsettings")
+            cust_ip_settings ||= RbVmomi::VIM::CustomizationIPSettings.new("ip" => RbVmomi::VIM::CustomizationDhcpIpGenerator.new())
+            cust_ip_settings.dnsDomain = cust_domain
+            cust_global_ip_settings = RbVmomi::VIM::CustomizationGlobalIPSettings.new
+            cust_global_ip_settings.dnsServerList = cust_ip_settings.dnsServerList
+            cust_global_ip_settings.dnsSuffixList = [cust_domain]
+            cust_hostname = RbVmomi::VIM::CustomizationFixedName.new(:name => cust_options['hostname']) if cust_options.has_key?('hostname')
+            cust_hostname ||= RbVmomi::VIM::CustomizationFixedName.new(:name => options['name'])
+            cust_hwclockutc = cust_options['hw_clock_utc']
+            cust_timezone = cust_options['time_zone']
+            # Start Building objects
+            # Build the CustomizationLinuxPrep Object
+            cust_prep = RbVmomi::VIM::CustomizationLinuxPrep.new(
+              :domain => cust_domain,
+              :hostName => cust_hostname,
+              :hwClockUTC => cust_hwclockutc,
+              :timeZone => cust_timezone)
+            # Build the Custom Adapter Mapping Supports only one eth right now
+            cust_adapter_mapping = [RbVmomi::VIM::CustomizationAdapterMapping.new("adapter" => cust_ip_settings)]
+            # Build the customization Spec
+            customization_spec = RbVmomi::VIM::CustomizationSpec.new(
+              :identity => cust_prep,
+              :globalIPSettings => cust_global_ip_settings,
+              :nicSettingMap => cust_adapter_mapping)
+          end
+          customization_spec ||= nil
           
           relocation_spec=nil
           if ( options['linked_clone'] )
@@ -139,17 +217,23 @@ module Fog
               vm_mob_ref.ReconfigVM_Task(:spec => disk_spec).wait_for_completion
             end
             # Next, create a Relocation Spec instance
-            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:datastore => datastore_obj,
+                                                                      :pool => resource_pool,
                                                                       :diskMoveType => :moveChildMostDiskBacking)
           else
-            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:datastore => datastore_obj, 
+                                                                      :pool => resource_pool,
                                                                       :transform => options['transform'] || 'sparse')
           end
           # And the clone specification
           clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => relocation_spec,
+                                                            :config => virtual_machine_config_spec,
+                                                            :customization => customization_spec,
                                                             :powerOn  => options.has_key?('power_on') ? options['power_on'] : true,
                                                             :template => false)
-          task = vm_mob_ref.CloneVM_Task(:folder => options.has_key?('dest_folder') ? options['dest_folder'] : vm_mob_ref.parent,
+          
+          # Perform the actual Clone Task
+          task = vm_mob_ref.CloneVM_Task(:folder => dest_folder,
                                          :name => options['name'],
                                          :spec => clone_spec)
           # Waiting for the VM to complete allows us to get the VirtulMachine
@@ -176,11 +260,11 @@ module Fog
               nil
             end
           end
-
+          
           # Return hash
           {
             'vm_ref'        => new_vm ? new_vm._ref : nil,
-            'vm_attributes' => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : {},
+            'new_vm'        => new_vm ? get_virtual_machine("#{options['dest_folder']}/#{options['name']}", options['datacenter']) : nil,
             'task_ref'      => task._ref
           }
         end
@@ -190,11 +274,11 @@ module Fog
       class Mock
         include Shared
         def vm_clone(options = {})
-          # Option handling
+          # Option handling TODO Needs better method of checking
           options = vm_clone_check_options(options)
           notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
           list_virtual_machines.find(notfound) do |vm|
-            vm[:name] == options['path'].split("/")[-1]
+            vm[:name] == options['template_path'].split("/")[-1]
           end
           {
             'vm_ref'   => 'vm-123',

data/lib/fog/xenserver.rb

@@ -14,11 +14,11 @@ module Fog
     
       def initialize(host)
         @factory = XMLRPC::Client.new(host, '/')
-        @factory.set_parser(XMLRPC::XMLParser::REXMLStreamParser.new)
+        @factory.set_parser(NokogiriStreamParser.new)
       end
     
       def authenticate( username, password )
-        response = @factory.call('session.login_with_password', username, password )
+        response = @factory.call('session.login_with_password', username.to_s, password.to_s)
         raise Fog::XenServer::InvalidLogin.new unless response["Status"] =~ /Success/
         @credentials = response["Value"]
       end
@@ -50,6 +50,30 @@ module Fog
       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