fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/lib/fog/vcloud_director/requests/compute/put_vapp_template_metadata_item_metadata.rb

@@ -0,0 +1,50 @@
+module Fog
+  module Compute
+    class VcloudDirector
+      class Real
+        # Set the value for the specified metadata key to the value provided,
+        # overwriting any existing value.
+        #
+        # @param [String] id Object identifier of the vApp template.
+        # @param [String] key Key of the metadata item.
+        # @param [Boolean,DateTime,Fixnum,String] value Value of the metadata
+        #   item.
+        # @return [Excon::Response]
+        #   * body<~Hash>:
+        #
+        # @see http://pubs.vmware.com/vcd-51/topic/com.vmware.vcloud.api.reference.doc_51/doc/operations/PUT-VAppTemplateMetadataItem-metadata.html
+        # @since vCloud API version 1.5
+        def put_vapp_template_metadata_item_metadata(id, key, value)
+          body = Nokogiri::XML::Builder.new do
+            attrs = {
+              :xmlns => 'http://www.vmware.com/vcloud/v1.5',
+              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
+            }
+            MetadataValue(attrs) {
+              if api_version.to_f < 5.1
+                Value value
+              else
+                type = case value
+                       when TrueClass, FalseClass then 'MetadataBooleanValue';
+                       when DateTime then 'MetadataDateTimeValue';
+                       when Fixnum then 'MetadataNumberValue';
+                       else 'MetadataStringValue'
+                       end
+                TypedValue('xsi:type' => type) { Value value }
+              end
+            }
+          end.to_xml
+
+          request(
+            :body    => body,
+            :expects => 202,
+            :headers => {'Content-Type' => 'application/vnd.vmware.vcloud.metadata.value+xml'},
+            :method  => 'PUT',
+            :parser  => Fog::ToHashDocument.new,
+            :path    => "vappTemplate/#{id}/metadata/#{URI.escape(key)}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/requests/compute/put_vm_capabilities.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class VcloudDirector
+      class Real
+        # Update VM's capabilities.
+        #
+        # @param [String] id Object identifier of the VM.
+        # @param [Hash] options
+        # @option options [Boolean] :MemoryHotAddEnabled True if the virtual
+        #   machine supports addition of memory while powered on.
+        # @option options [Boolean] :CpuHotAddEnabled True if the virtual
+        #   machine supports addition of virtual CPUs while powered on.
+        # @return [Excon::Response]
+        #   * body<~Hash>:
+        #
+        # @see http://pubs.vmware.com/vcd-51/topic/com.vmware.vcloud.api.reference.doc_51/doc/operations/PUT-VmCapabilities.html
+        def put_vm_capabilities(id, options={})
+          body = Nokogiri::XML::Builder.new do
+            attrs = {
+              :xmlns => 'http://www.vmware.com/vcloud/v1.5'
+            }
+            VmCapabilities(attrs) {
+              if options.key?(:MemoryHotAddEnabled)
+                MemoryHotAddEnabled options[:MemoryHotAddEnabled]
+              end
+              if options.key?(:CpuHotAddEnabled)
+                MemoryHotAddEnabled options[:CpuHotAddEnabled]
+              end
+            }
+          end.to_xml
+
+          request(
+            :body    => body,
+            :expects => 202,
+            :headers => {'Content-Type' => 'application/vnd.vmware.vcloud.vmCapabilitiesSection+xml'},
+            :method  => 'PUT',
+            :parser  => Fog::ToHashDocument.new,
+            :path    => "vApp/#{id}/vmCapabilities"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director.rb

@@ -2,10 +2,66 @@ require 'fog/core'
 
 module Fog
   module VcloudDirector
-
     extend Fog::Provider
 
-    service(:compute, 'vcloud_director/compute', 'Compute')
+    module Errors
+      class ServiceError < Fog::Errors::Error
+        attr_reader :minor_error_code
+        attr_reader :major_error_code
+        attr_reader :stack_trace
+        attr_reader :status_code
+        attr_reader :vendor_specific_error_code
+
+        def self.slurp(error, service=nil)
+          major_error_code = nil
+          message = nil
+          minor_error_code = nil
+          stack_trace = nil
+          status_code = nil
+          vendor_specific_error_code = nil
+
+          if error.response
+            status_code = error.response.status
+            unless error.response.body.empty?
+              _, media_type = error.response.headers.detect {|k,v| k.downcase == 'content-type'}
+              if media_type =~ /vnd\.vmware\.vcloud\.error\+xml/i
+                begin
+                  document = Fog::ToHashDocument.new
+                  Nokogiri::XML::SAX::Parser.new(document).parse_memory(error.response.body)
+                  major_error_code = document.body[:majorErrorCode]
+                  message = document.body[:message]
+                  minor_error_code = document.body[:minorErrorCode]
+                  stack_trace = document.body[:stackTrace]
+                  vendor_specific_error_code = document.body[:vendorSpecificErrorCode]
+                rescue => e
+                  Fog::Logger.warning("Received exception '#{e}' while decoding>> #{error.response.body}")
+                  message = error.response.body
+                end
+              else
+                message = CGI::unescapeHTML(error.response.body)
+              end
+            end
+          end
 
+          new_error = super(error, message)
+          new_error.instance_variable_set(:@major_error_code, major_error_code)
+          new_error.instance_variable_set(:@minor_error_code, minor_error_code)
+          new_error.instance_variable_set(:@stack_trace, stack_trace)
+          new_error.instance_variable_set(:@status_code, status_code)
+          new_error.instance_variable_set(:@vendor_specific_error_code, vendor_specific_error_code)
+          new_error
+        end
+      end
+
+      class BadRequest < ServiceError; end
+      class Unauthorized < ServiceError; end
+      class Forbidden < ServiceError; end
+      class Conflict < ServiceError; end
+
+      class DuplicateName < ServiceError; end
+      class TaskError < ServiceError; end
+    end
+
+    service(:compute, 'vcloud_director/compute', 'Compute')
   end
 end

data/lib/fog/version.rb

@@ -1,3 +1,3 @@
 module Fog
-  VERSION = '1.15.0'
+  VERSION = '1.18.0'
 end

data/lib/fog/vsphere/compute.rb

@@ -11,10 +11,14 @@ module Fog
       model_path 'fog/vsphere/models/compute'
       model :server
       collection :servers
+      model :servertype
+      collection :servertypes
       model :datacenter
       collection :datacenters
       model :interface
       collection :interfaces
+      model :interfacetype
+      collection :interfacetypes
       model :volume
       collection :volumes
       model :template
@@ -33,6 +37,7 @@ module Fog
       collection :customvalues
       model :customfield
       collection :customfields
+      model :scsicontroller
 
       request_path 'fog/vsphere/requests/compute'
       request :current_time
@@ -60,6 +65,7 @@ module Fog
       request :create_vm
       request :list_vm_interfaces
       request :modify_vm_interface
+      request :modify_vm_volume
       request :list_vm_volumes
       request :get_virtual_machine
       request :vm_reconfig_hardware
@@ -67,8 +73,13 @@ module Fog
       request :vm_reconfig_cpus
       request :vm_config_vnc
       request :create_folder
+      request :list_server_types
+      request :get_server_type
+      request :list_interface_types
+      request :get_interface_type
       request :list_vm_customvalues
       request :list_customfields
+      request :get_vm_first_scsi_controller
 
       module Shared
 
@@ -95,8 +106,9 @@ module Fog
           :tools_version => 'guest.toolsVersionStatus',
           :memory_mb => 'config.hardware.memoryMB',
           :cpus   => 'config.hardware.numCPU',
+          :corespersocket   => 'config.hardware.numCoresPerSocket',
           :overall_status => 'overallStatus',
-          :guest_id => 'summary.guest.guestId',
+          :guest_id => 'config.guestId',
         }
 
         def convert_vm_view_to_attr_hash(vms)
@@ -334,8 +346,35 @@ module Fog
           @vsphere_ssl      = options[:vsphere_ssl] || true
           @vsphere_expected_pubkey_hash = options[:vsphere_expected_pubkey_hash]
           @vsphere_must_reauthenticate = false
-
+          @vsphere_is_vcenter = nil
           @connection = nil
+          connect
+          negotiate_revision(options[:vsphere_rev])
+          authenticate
+        end
+
+        def reload
+          connect
+          # Check if the negotiation was ever run
+          if @vsphere_is_vcenter.nil?
+            negotiate
+          end
+          authenticate
+        end
+
+        private
+        def negotiate_revision(revision = nil)
+          # Negotiate the API revision
+          if not revision
+            rev = @connection.serviceContent.about.apiVersion
+            @connection.rev = [ rev, ENV['FOG_VSPHERE_REV'] || '4.1' ].min
+          end
+
+          @vsphere_is_vcenter = @connection.serviceContent.about.apiType == "VirtualCenter"
+          @vsphere_rev = @connection.rev
+        end
+
+        def connect
           # This is a state variable to allow digest validation of the SSL cert
           bad_cert = false
           loop do
@@ -357,21 +396,8 @@ module Fog
           if bad_cert then
             validate_ssl_connection
           end
-
-          # Negotiate the API revision
-          if not options[:vsphere_rev]
-            rev = @connection.serviceContent.about.apiVersion
-            @connection.rev = [ rev, ENV['FOG_VSPHERE_REV'] || '4.1' ].min
-          end
-
-          @vsphere_is_vcenter = @connection.serviceContent.about.apiType == "VirtualCenter"
-          @vsphere_rev = @connection.rev
-
-          authenticate
         end
 
-        private
-
         def authenticate
           begin
             @connection.serviceContent.sessionManager.Login :userName => @vsphere_username,

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

@@ -6,30 +6,35 @@ module Fog
 
         identity :id
         attribute :name
+        attribute :path
         attribute :status
 
         def clusters filters = { }
-          service.clusters({ :datacenter => name }.merge(filters))
+          service.clusters({ :datacenter => path.join("/") }.merge(filters))
         end
 
         def networks filters = { }
-          service.networks({ :datacenter => name }.merge(filters))
+          service.networks({ :datacenter => path.join("/") }.merge(filters))
         end
 
         def datastores filters = { }
-          service.datastores({ :datacenter => name }.merge(filters))
+          service.datastores({ :datacenter => path.join("/") }.merge(filters))
         end
 
         def vm_folders filters = { }
-          service.folders({ :datacenter => name, :type => :vm }.merge(filters))
+          service.folders({ :datacenter => path.join("/"), :type => :vm }.merge(filters))
         end
 
         def virtual_machines filters = {}
-          service.servers({ :datacenter => name }.merge(filters))
+          service.servers({ :datacenter => path.join("/") }.merge(filters))
         end
         
+        def servertypes filters={}
+          service.servertypes({:datacenter => name }.merge(filters))
+        end
+
         def customfields filters = {}
-          service.customfields({ :datacenter => name}.merge(filters))
+          service.customfields({ :datacenter => path.join("/")}.merge(filters))
         end
 
         def to_s

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

@@ -4,6 +4,8 @@ module Fog
 
       class Interface < Fog::Model
 
+        SAVE_MUTEX = Mutex.new
+
         identity :mac
         alias :id :mac
 
@@ -13,8 +15,19 @@ module Fog
         attribute :summary
         attribute :type
         attribute :key
+        attribute :virtualswitch
+        attribute :server_id
+
+        def initialize(attributes = {})
+          # Assign server first to prevent race condition with persisted?
+          self.server_id = attributes.delete(:server_id)
+
+          if attributes.has_key? :type and attributes[:type].is_a? String then
+            attributes[:type] = Fog.class_from_string(attributes[:type], "RbVmomi::VIM")
+          else
+            attributes[:type] = Fog.class_from_string("VirtualE1000", "RbVmomi::VIM")
+          end
 
-        def initialize(attributes={} )
           super defaults.merge(attributes)
         end
 
@@ -22,18 +35,57 @@ module Fog
           name
         end
 
+        def server
+          requires :server_id
+          service.servers.get(server_id)
+        end
+
+        def destroy
+          requires :server_id, :key, :type
+
+          service.destroy_vm_interface(server_id, :key => key, :type => type)
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :server_id, :type, :network
+
+          # Our approach of finding the newly created interface is rough.  We assume that the :key value always increments
+          # and thus the highest :key value must correspond to the created interface.  Since this has an inherent race
+          # condition we need to gate the saves.
+          SAVE_MUTEX.synchronize do
+            data = service.add_vm_interface(server_id, attributes)
+
+            if data['task_state'] == 'success'
+              # We have to query vSphere to get the interface attributes since the task handle doesn't include that info.
+              created = server.interfaces.all.sort_by(&:key).last
+
+              self.mac = created.mac
+              self.name = created.name
+              self.status = created.status
+              self.summary = created.summary
+              self.key = created.key
+              self.virtualswitch = created.virtualswitch
+
+              true
+            else
+              false
+            end
+          end
+        end
+
         private
 
         def defaults
+          default_type=Fog.credentials[:default_nic_type] || RbVmomi::VIM::VirtualE1000
           {
             :name=>"Network adapter",
             :network=>"VM Network",
             :summary=>"VM Network",
-            :type=> RbVmomi::VIM::VirtualE1000,
+            :type=> Fog.class_from_string(default_type, "RbVmomi::VIM"),
           }
         end
 
-
       end
 
     end

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

@@ -9,36 +9,51 @@ module Fog
 
         model Fog::Compute::Vsphere::Interface
 
-        attr_accessor :vm
+        attribute :server
 
         def all(filters = {})
-          requires :vm
-          case vm
+          requires :server
+
+          case server
             when Fog::Compute::Vsphere::Server
-              load service.list_vm_interfaces(vm.id)
+              load service.list_vm_interfaces(server.id)
             when Fog::Compute::Vsphere::Template
-              load service.list_template_interfaces(vm.id)
+              load service.list_template_interfaces(server.id)
             else
             raise 'interfaces should have vm or template'
           end
+
+          self.each { |interface| interface.server_id = server.id }
+          self
         end
 
         def get(id)
-          requires :vm
-          case vm
+          requires :server
+
+          case server
             when Fog::Compute::Vsphere::Server
-              interface=service.get_vm_interface(vm.id, :key => id, :mac=> id, :name => id)
+              interface = service.get_vm_interface(server.id, :key => id, :mac=> id, :name => id)
             when Fog::Compute::Vsphere::Template
-              interface=service.get_template_interfaces(vm.id, :key => id, :mac=> id, :name => id)
+              interface = service.get_template_interfaces(server.id, :key => id, :mac=> id, :name => id)
             else
+
             raise 'interfaces should have vm or template'
           end
+
           if interface 
-            Fog::Compute::Vsphere::Interface.new(interface) 
+            Fog::Compute::Vsphere::Interface.new(interface.merge(:server_id => server.id, :service => service))
           else
             nil         
           end
         end
+
+        def new(attributes = {})
+          if server
+            super({ :server_id => server.id  }.merge(attributes))
+          else
+            super
+          end
+        end
      end
     end
   end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class Interfacetype < Fog::Model
+
+        identity :id
+
+#        attribute :class
+        attribute :name
+        attribute :datacenter
+        attribute :servertype
+
+        def initialize(attributes={} )
+          super attributes
+        end
+
+        def to_s
+          name
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/vsphere/models/compute/interfacetype'
+
+module Fog
+  module Compute
+    class Vsphere
+
+      class Interfacetypes < Fog::Collection
+
+        model Fog::Compute::Vsphere::Interfacetype
+        attr_accessor :datacenter
+        attr_accessor :servertype
+
+        def all(filters = { })
+          requires :servertype
+          case servertype
+            when Fog::Compute::Vsphere::Servertype
+               load service.list_interface_types(filters.merge({
+                                                      :datacenter => datacenter,
+                                                      :servertype => servertype.id
+                                                 }))
+            else
+               raise 'interfacetypes should have a servertype'
+          end
+        end
+
+        def get(id)
+          requires :servertype
+          requires :datacenter
+          new service.get_interface_type id, servertype, datacenter
+        rescue Fog::Compute::Vsphere::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class SCSIController < Fog::Model
+
+        attribute :shared_bus
+        attribute :type
+        attribute :unit_number
+        attribute :key
+
+        def to_s
+          "#{type} ##{key}: shared: #{shared_bus}, unit_number: #{unit_number}"
+        end
+      end
+
+    end
+  end
+end