fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

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

@@ -36,6 +36,7 @@ module Fog
         attribute :relative_path
         attribute :memory_mb
         attribute :cpus
+        attribute :corespersocket
         attribute :interfaces
         attribute :volumes
         attribute :customvalues
@@ -45,6 +46,7 @@ module Fog
         attribute :resource_pool
         attribute :instance_uuid # move this --> id
         attribute :guest_id
+        attribute :scsi_controller # this is the first scsi controller. Right now no more of them can be used.
 
         def initialize(attributes={} )
           super defaults.merge(attributes)
@@ -52,6 +54,7 @@ module Fog
           initialize_interfaces
           initialize_volumes
           initialize_customvalues
+          initialize_scsi_controller
         end
 
         # Lazy Loaded Attributes
@@ -66,12 +69,12 @@ module Fog
 
         def vm_reconfig_memory(options = {})
           requires :instance_uuid, :memory
-          service.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory)
+          service.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory_mb)
         end
 
         def vm_reconfig_cpus(options = {})
-          requires :instance_uuid, :cpus
-          service.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus)
+          requires :instance_uuid, :cpus, :corespersocket
+          service.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus, 'corespersocket' => corespersocket)
         end
 
         def vm_reconfig_hardware(hardware_spec, options = {})
@@ -85,7 +88,7 @@ module Fog
         end
 
         def stop(options = {})
-          options = { :force => !tools_installed? }.merge(options)
+          options = { :force => !tools_installed? || !tools_running? }.merge(options)
           requires :instance_uuid
           service.vm_power_off('instance_uuid' => instance_uuid, 'force' => options[:force])
         end
@@ -100,7 +103,7 @@ module Fog
           requires :instance_uuid
           if ready?
             # need to turn it off before destroying
-            stop
+            stop(options)
             wait_for { !ready? }
           end
           service.vm_destroy('instance_uuid' => instance_uuid)
@@ -121,19 +124,25 @@ module Fog
         #
         def clone(options = {})
           requires :name, :datacenter, :relative_path
+
           # Convert symbols to strings
           req_options = options.inject({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
+
           # Give our path to the request
           req_options['template_path'] ="#{relative_path}/#{name}"
           req_options['datacenter'] = "#{datacenter}"
+
           # Perform the actual clone
           clone_results = service.vm_clone(req_options)
+
+          # We need to assign the service, otherwise we can't reload the model
           # Create the new VM model. TODO This only works when "wait=true"
-          new_vm = self.class.new(clone_results['new_vm'])
-          # We need to assign the collection and the connection otherwise we
+          new_vm = self.class.new(clone_results['new_vm'].merge(:service => self.service))
+
+          # We need to assign the collection otherwise we
           # cannot reload the model.
           new_vm.collection = self.collection
-          new_vm.service = service
+
           # Return the new VM model.
           new_vm
         end
@@ -146,6 +155,10 @@ module Fog
           tools_state != "toolsNotInstalled"
         end
 
+        def tools_running?
+          tools_state == "toolsOk"
+        end
+
         # defines VNC attributes on the hypervisor
         def config_vnc(options = {})
           requires :instance_uuid
@@ -162,12 +175,16 @@ module Fog
           memory_mb * 1024 * 1024
         end
 
+        def sockets
+          cpus / corespersocket
+        end
+        
         def mac
           interfaces.first.mac unless interfaces.empty?
         end
 
         def interfaces
-          attributes[:interfaces] ||= id.nil? ? [] : service.interfaces( :vm => self )
+          attributes[:interfaces] ||= id.nil? ? [] : service.interfaces( :server => self )
         end
         
         def interface_ready? attrs
@@ -175,8 +192,9 @@ module Fog
         end
 
         def add_interface attrs
-          wait_for { not ready? } if interface_ready? attrs
-          service.add_vm_interface(id, attrs)
+          Fog::Logger.deprecation("<server>.add_interface is deprecated. Call <server>.interfaces.create instead.")
+
+          interfaces.create(attrs)
         end
 
         def update_interface attrs
@@ -185,18 +203,23 @@ module Fog
         end
 
         def destroy_interface attrs
-          wait_for { not ready? } if interface_ready? attrs
-          service.destroy_vm_interface(id, attrs)
+          Fog::Logger.deprecation("<server>.destroy_vm_interface is deprecated. Call <server>.interfaces.get(:key => <nic_key>).destroy instead.")
+
+          interfaces.get(attrs[:key] || attrs['key']).destroy
         end
 
         def volumes
-          attributes[:volumes] ||= id.nil? ? [] : service.volumes( :vm => self )
+          attributes[:volumes] ||= id.nil? ? [] : service.volumes(:server => self)
         end
-        
+
         def customvalues
           attributes[:customvalues] ||= id.nil? ? [] : service.customvalues( :vm => self )
         end
 
+        def scsi_controller
+          self.attributes[:scsi_controller] ||= service.get_vm_first_scsi_controller(id)
+        end
+
         def folder
           return nil unless datacenter and path
           attributes[:folder] ||= service.folders(:datacenter => datacenter, :type => :vm).get(path)
@@ -230,8 +253,9 @@ module Fog
         def defaults
           {
             :cpus      => 1,
+#            :corespersocket => 1,
             :memory_mb => 512,
-            :guest_id  => 'otherGuest',
+#            :guest_id  => 'otherGuest',
             :path      => '/'
           }
         end
@@ -253,6 +277,13 @@ module Fog
             self.attributes[:customvalues].map { |cfield| cfield.is_a?(Hash) ? service.customvalue.new(cfield) : cfield}
           end
         end
+
+        def initialize_scsi_controller
+          if attributes[:scsi_controller] and attributes[:scsi_controller].is_a?(Hash)
+            Fog::Compute::Vsphere::SCSIController.new(self.attributes[:scsi_controller])
+          end
+        end
+
       end
 
     end

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

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class Servertype < Fog::Model
+
+        identity :id
+
+        attribute :family
+        attribute :fullname
+        attribute :datacenter
+        attribute :interfacetypes
+
+        def initialize(attributes={} )
+          super defaults.merge(attributes)
+        end
+
+        def to_s
+          id
+        end
+
+        def interfacetypes filters={}
+          attributes[:interfacetypes] ||= service.interfacetypes({ :datacenter => datacenter, :servertype => self }.merge(filters))
+        end
+
+        private
+
+        def defaults
+          {
+            :id=>"otherGuest64",
+            :family=>"otherGuestFamily",
+            :interfacetypes => nil,
+          }
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/vsphere/models/compute/servertype'
+
+module Fog
+  module Compute
+    class Vsphere
+
+      class Servertypes < Fog::Collection
+
+        model Fog::Compute::Vsphere::Servertype
+        attr_accessor :datacenter, :id, :fullname
+
+        def all(filters = { })
+          load service.list_server_types(filters.merge({:datacenter => datacenter}))
+        end
+
+        def get(id)
+          requires :datacenter
+          new service.get_server_type(id, datacenter)
+        rescue Fog::Compute::Vsphere::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end
+

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

@@ -10,11 +10,18 @@ module Fog
         attribute :mode
         attribute :size
         attribute :thin
+        attribute :eager_zero
         attribute :name
         attribute :filename
         attribute :size_gb
+        attribute :key
+        attribute :unit_number
+        attribute :server_id
 
         def initialize(attributes={} )
+          # Assign server first to prevent race condition with persisted?
+          self.server_id = attributes.delete(:server_id)
+
           super defaults.merge(attributes)
         end
 
@@ -30,13 +37,61 @@ module Fog
           name
         end
 
-         private
+        def destroy
+          requires :server_id, :key, :unit_number
+
+          service.destroy_vm_volume(self)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :server_id, :size, :datastore
+
+          if unit_number.nil?
+            used_unit_numbers = server.volumes.collect { |volume| volume.unit_number }
+            max_unit_number = used_unit_numbers.max
+
+            if max_unit_number > server.volumes.size
+              # If the max ID exceeds the number of volumes, there must be a hole in the range. Find a hole and use it.
+              self.unit_number = max_unit_number.times.to_a.find { |i| used_unit_numbers.exclude?(i) }
+            else
+              self.unit_number = max_unit_number + 1
+            end
+          else
+            if server.volumes.any? { |volume| volume.unit_number == self.unit_number && volume.id != self.id }
+              raise "A volume already exists with that unit_number, so we can't save the new volume"
+            end
+          end
+
+          data = service.add_vm_volume(self)
+
+          if data['task_state'] == 'success'
+            # We have to query vSphere to get the volume attributes since the task handle doesn't include that info.
+            created = server.volumes.all.find { |volume| volume.unit_number == self.unit_number }
+
+            self.id = created.id
+            self.key = created.key
+            self.filename = created.filename
+
+            true
+          else
+            false
+          end
+        end
+
+        def server
+          requires :server_id
+          service.servers.get(server_id)
+        end
+
+        private
 
         def defaults
           {
-            :thin=>true,
-            :name=>"Hard disk",
-            :mode=>"persistent"
+            :thin => true,
+            :name => "Hard disk",
+            :mode => "persistent"
           }
         end
       end

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

@@ -7,26 +7,41 @@ module Fog
 
       class Volumes < Fog::Collection
 
-        model Fog::Compute::Vsphere::Volume
+        attribute :server
 
-        attr_accessor :vm
+        model Fog::Compute::Vsphere::Volume
 
         def all(filters = {})
-          requires :vm
-          case vm
+          requires :server
+
+          case server
             when Fog::Compute::Vsphere::Server
-              load service.list_vm_volumes(vm.id)
+              load service.list_vm_volumes(server.id)
             when Fog::Compute::Vsphere::Template
-              load service.list_template_volumes(vm.id)
+              load service.list_template_volumes(server.id)
             else
               raise 'volumes should have vm or template'
-          end
+            end
+
+          self.each { |volume| volume.server_id = server.id }
+          self
         end
 
         def get(id)
           new service.get_volume(id)
         end
 
+        def new(attributes = {})
+          if server
+            # Default to the root volume datastore if one is not configured.
+            datastore = ! attributes.has_key?(:datastore) && self.any? ? self.first.datastore : nil
+
+            super({ :server_id => server.id, :datastore => datastore }.merge!(attributes))
+          else
+            super
+          end
+        end
+
      end
     end
   end

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

@@ -10,6 +10,7 @@ module Fog
             :guestId      => attributes[:guest_id],
             :files        => { :vmPathName => vm_path_name(attributes) },
             :numCPUs      => attributes[:cpus],
+            :numCoresPerSocket => attributes[:corespersocket],
             :memoryMB     => attributes[:memory_mb],
             :deviceChange => device_change(attributes),
             :extraConfig  => extra_config(attributes),
@@ -43,14 +44,14 @@ module Fog
           end
 
           if (disks = attributes[:volumes])
-            devices << create_controller
+            devices << create_controller(attributes[:scsi_controller]||attributes["scsi_controller"]||{})
             devices << disks.map { |disk| create_disk(disk, disks.index(disk)) }
           end
           devices.flatten
         end
 
         def create_nic_backing nic, attributes
-          raw_network = get_raw_network(nic.network, attributes[:datacenter])
+          raw_network = get_raw_network(nic.network, attributes[:datacenter], if nic.virtualswitch then nic.virtualswitch end)
 
           if raw_network.kind_of? RbVmomi::VIM::DistributedVirtualPortgroup
             RbVmomi::VIM.VirtualEthernetCardDistributedVirtualPortBackingInfo(
@@ -79,23 +80,49 @@ module Fog
           }
         end
 
-        def create_controller operation = :add, controller_key = 1000, bus_id = 0
+        def create_controller options=nil
+          options=if options
+                    controller_default_options.merge(Hash[options.map{|k,v| [k.to_sym,v] }])
+                  else 
+                    controller_default_options 
+                  end
+          controller_class=if options[:type].is_a? String then 
+                             Fog::class_from_string options[:type], "RbVmomi::VIM"
+                           else 
+                             options[:type] 
+                           end
           {
-            :operation => operation,
-            :device    => RbVmomi::VIM.VirtualLsiLogicController(
-              :key       => controller_key,
-              :busNumber => bus_id,
-              :sharedBus => :noSharing
-            )
+            :operation => options[:operation],
+            :device    => controller_class.new({
+              :key       => options[:key],
+              :busNumber => options[:bus_id],
+              :sharedBus => controller_get_shared_from_options(options),
+            })
           }
         end
 
+        def controller_default_options
+          {:operation => "add", :type => RbVmomi::VIM.VirtualLsiLogicController.class, :key => 1000, :bus_id => 0, :shared => false }
+        end
+
+        def controller_get_shared_from_options options
+          if (options.has_key? :shared and options[:shared]==false) or not options.has_key? :shared then
+            :noSharing
+          elsif options[:shared]==true then
+            :virtualSharing
+          elsif options[:shared].is_a? String
+            options[:shared]
+          else
+            :noSharing
+          end
+        end
+
         def create_disk disk, index = 0, operation = :add, controller_key = 1000
-          {
+          payload = {
             :operation     => operation,
-            :fileOperation => :create,
+            :fileOperation => operation == :add ? :create : :destroy,
             :device        => RbVmomi::VIM.VirtualDisk(
-              :key           => index,
+              :key           => disk.key || index,
               :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
                 :fileName        => "[#{disk.datastore}]",
                 :diskMode        => disk.mode.to_sym,
@@ -106,6 +133,12 @@ module Fog
               :capacityInKB  => disk.size
             )
           }
+
+          if operation == :add && disk.thin == false && disk.eager_zero
+            payload[:device][:backing][:eagerlyScrub] = disk.eager_zero
+          end
+
+          payload
         end
 
         def extra_config attributes
@@ -126,4 +159,4 @@ module Fog
       end
     end
   end
-end
+end

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

@@ -5,7 +5,7 @@ module Fog
         def get_datacenter name
           dc = find_raw_datacenter(name)
           raise(Fog::Compute::Vsphere::NotFound) unless dc
-          {:name => dc.name, :status => dc.overallStatus}
+          {:name => dc.name, :status => dc.overallStatus, :path => raw_getpathmo(dc) }
         end
 
         protected

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

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_interface_type(id, servertype, datacenter, filter={})
+           interfacetype=list_interface_types(filters={:id => id,
+             :datacenter => datacenter,
+             :servertype => servertype.id }).first
+           raise(Fog::Compute::Vsphere::NotFound) unless interfacetype
+           interfacetype
+        end
+      end
+    end
+  end
+end

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

@@ -10,14 +10,14 @@ module Fog
 
         protected
 
-        def get_raw_network(name, datacenter_name)
+        def get_raw_network(name, datacenter_name, distributedswitch_name=nil)
           dc = find_raw_datacenter(datacenter_name)
 
           @connection.serviceContent.viewManager.CreateContainerView({
             :container  => dc.networkFolder,
             :type       =>  ["Network"],
             :recursive  => true
-          }).view.select{|n| n.name == name}.first
+          }).view.select { |n| n.name == name and (not distributedswitch_name or n.config.distributedVirtualSwitch.name == distributedswitch_name)}.first
         end
       end
 

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

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_server_type(id, datacenter, filter={})
+          server_type=get_raw_server_type(id, datacenter)
+          raise(Fog::Compute::Vsphere::NotFound) unless server_type
+          server_type_attributes(server_type, datacenter)           
+        end
+
+        protected
+        
+        def get_raw_server_type(id, datacenter, filter={})
+           types=raw_server_types(datacenter)
+           raise(Fog::Compute::Vsphere::NotFound) unless types
+           types=types.select{ | servertype | servertype.id == id }.first
+           raise(Fog::Compute::Vsphere::NotFound) unless types
+           types
+        end
+      end
+      class Mock
+        def get_server_type(id)
+          {:id=>"rhel6Guest", 
+            :name=>"rhel6Guest", 
+            :family=>"linuxGuest", 
+            :fullname=>"Red Hat Enterprise Linux 6 (32-Bit)", 
+            :datacenter=>"Solutions"}          
+        end
+      end      
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_vm_first_scsi_controller(vm_id)
+          Fog::Compute::Vsphere::SCSIController.new(get_vm_first_scsi_controller_raw(vm_id))
+        end
+        def get_vm_first_scsi_controller_raw(vm_id)
+          ctrl=get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualSCSIController).select{ | ctrl | ctrl.key == 1000 }.first
+          {
+            :type    => ctrl.class.to_s,
+            :shared_bus  => ctrl.sharedBus.to_s,
+            :unit_number => ctrl.scsiCtlrUnitNumber,
+            :key => ctrl.key,
+          } 
+        end
+
+      end
+      class Mock
+        def get_vm_first_scsi_controller(vm_id)
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,7 @@ module Fog
             {
               :id => managed_obj_id(dc),
               :name => dc.name,
+              :path => raw_getpathmo(dc),
               :status => dc.overallStatus
             }
           end
@@ -15,9 +16,27 @@ module Fog
 
         protected
 
-        # RbVmomi::VIM::Datacenter Array
-        def raw_datacenters
-          @raw_datacenters ||= @connection.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter)
+        def raw_getpathmo mo 
+          if mo.parent == nil or mo.parent.name == @connection.rootFolder.name then
+            [ mo.name ]
+          else
+            [ raw_getpathmo(mo.parent), mo.name ].flatten 
+          end
+        end
+
+        def raw_datacenters folder=nil
+          folder ||= @connection.rootFolder
+          @raw_datacenters ||= get_raw_datacenters_from_folder folder
+        end
+
+        def get_raw_datacenters_from_folder folder=nil 
+          folder.childEntity.map do | childE |
+            if childE.is_a? RbVmomi::VIM::Datacenter
+               childE
+            elsif childE.is_a? RbVmomi::VIM::Folder
+               get_raw_datacenters_from_folder childE
+            end 
+          end.flatten
         end
 
         def find_datacenters name=nil

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

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_interface_types(filters={})
+          datacenter_name = filters[:datacenter]
+          servertype_name = filters[:servertype]
+          get_raw_server_type(servertype_name, datacenter_name)[:supportedEthernetCard].map do | nictype |
+            next if filters.has_key?(:id) and filters[:id] != nictype
+            interface_type_attributes(nictype, servertype_name, datacenter_name)
+          end.compact
+        end 
+        def interface_type_attributes(nic, servertype, datacenter)
+          {
+            :id => nic,
+            :name => nic,
+            :datacenter => datacenter,
+            :servertype => servertype,
+#            :class => Fog.class_from_string(nic)
+          }
+        end
+      end
+    end
+  end
+end