fog-hyperv 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 800c08e48379e123d5b8803ea3bda44f4eddbaa8
-  data.tar.gz: df40fef67b97eeed7469c51710b12bec6b455f39
+  metadata.gz: 7d1f016acb31e48e1b25113f74c059dcd1d76eb2
+  data.tar.gz: a9fa8894c68b1520b9e244c92dee0fc0e2e899cc
 SHA512:
-  metadata.gz: 0401b571330dad19781f5c35bfbc0cce18de2fdb02266583ba4ca2255b9c4a16e3c38b93303cfde9fa655ed0e73c0abf217dea43495a243460f2328ba42cbdac
-  data.tar.gz: 718b6a478f911d0070427d486951125a2ddb8407475cbc2540c962bb90f64a45a7af4cb982c9bfd0f9bc09afab2238d71a52dd0f622a7541d27b9afc65ebf2dc
+  metadata.gz: ed4973a3d9d1c34e0c5e5374f5048f7d6f9a9f41b16084e9799061cc25109458599a498b98b2e37e7070b2e9f496100bf052297c8c146dcbda361fd2ed0d14b5
+  data.tar.gz: 2ef22b03209489609a1ac1190e530c2b5dd9a88f8f7838617987a38fca2d1f365763ff3f9fa9443bc170ca6ce700f71d20cb0f33a88d3807834945da12298bc5

data/CHANGELOG.md

@@ -1,14 +1,22 @@
-## v0.0.3 2017-09-30
+## v0.0.4 2017-11-14
 
-- Fix handling of BIOS/Firmware
-- Skip unnecessary Hyper-V calls when checking dirty status
-- Add some possible interface improvements when dealing with clusters
+- Adds support for the Kerberos transport
+- Implements a first prototype for multi-hop when not using Kerberos/CredSSP
+- Fixes issues in the saving of a few models
+- Fixes a major issue when a VM ends up in a state with a large numerical value
+  - An issue in the enum code made input validity checking unable to differentiate between hashes and arrays
 
-## v0.0.2 2017-09-28
+## v0.0.3 2017-08-30
 
-- Reduced `fog-core` dependency to 1.42
-- Disabled `status` attribute for network adapters, due to Hyper-V 6.3 issues
+- Fixes handling of BIOS/Firmware
+- Skips unnecessary Hyper-V calls when checking dirty status
+- Adds some possible interface improvements when dealing with clusters
 
-## v0.0.1 2017-09-25
+## v0.0.2 2017-08-28
+
+- Reduces `fog-core` dependency to 1.42
+- Disables `status` attribute for network adapters, due to Hyper-V 6.3 issues
+
+## v0.0.1 2017-08-25
 
 - Initial release

data/lib/fog/collection.rb

@@ -15,13 +15,6 @@ module Fog
         requires.include? req
       end
 
-      def search_attributes
-        attributes.dup.merge(
-          _return_fields: model.attributes - model.lazy_attributes,
-          _json_depth: 1
-        )
-      end
-
       def all(filters = {})
         requires(*self.class.requires)
         data = service.send(method, search_attributes.merge(filters))
@@ -34,13 +27,13 @@ module Fog
         data = all(filters).first
         data if data
       rescue Fog::Hyperv::Errors::PSError => err
-        raise Fog::Errors::NotFound, err if err.message =~ /Hyper-V was unable to find|^No .* is found|/
+        raise Fog::Errors::NotFound, err if err.message =~ /Hyper-V was unable to find|^No .* is found/
         raise err
       end
 
       def new(options = {})
         requires(*self.class.requires)
-        super(search_attributes.merge(options))
+        super(creation_attributes.merge(options))
       end
 
       def create(attributes = {})
@@ -49,6 +42,19 @@ module Fog
         object
       end
 
+      protected
+
+      def search_attributes
+        attributes.dup.merge(
+          _return_fields: model.attributes - model.lazy_attributes,
+          _json_depth: 1
+        )
+      end
+
+      def creation_attributes
+        attributes.dup
+      end
+
       private
 
       def method
@@ -64,11 +70,20 @@ module Fog
       attr_accessor :cluster
       attr_accessor :computer
 
+      protected
+
+      def creation_attributes
+        to_add = {}
+        to_add[:cluster] = cluster if cluster
+        to_add[:computer] = computer if computer
+        super.merge(to_add)
+      end
+
       def search_attributes
         attrs = super
         attrs.delete :cluster
         attrs.delete :computer
-        attrs[:computer_name] ||= cluster.hosts.map { |n| n.name } if cluster
+        attrs[:computer_name] ||= cluster.hosts.map(&:name) if cluster
         attrs[:computer_name] ||= computer.name if computer
         attrs
       end
@@ -85,22 +100,11 @@ module Fog
 
       attr_accessor :vm
 
-      def search_attributes
-        attrs = super
-        attrs.delete :vm
-        if vm
-          attrs[:computer_name] ||= vm.computer_name
-          attrs[match] = vm.send(match)
-        end
-        attrs
-      end
-
-      def create(attributes = {})
-        object = new(attributes)
+      def new(attributes = {})
+        object = super
         # Ensure both ID and Name are populated, regardless of `match_on`
         object.vm_id ||= vm.id if vm && object.respond_to?(:vm_id)
         object.vm_name ||= vm.name if vm && object.respond_to?(:vm_name)
-        object.save
         object
       end
 
@@ -109,12 +113,27 @@ module Fog
         to_s
       end
 
-      private
+      protected
+
+      def creation_attributes
+        to_add = {}
+        to_add[:vm] = vm if vm
 
-      def logger
-        service.logger
+        super.merge to_add
       end
 
+      def search_attributes
+        attrs = super
+        attrs.delete :vm
+        if vm
+          attrs[:computer_name] ||= vm.computer_name
+          attrs[match] = vm.send(match)
+        end
+        attrs
+      end
+
+      private
+
       def match
         self.class.match_on || :vm_name
       end

data/lib/fog/hyperv/compute.rb

@@ -24,10 +24,12 @@ module Fog
         # :ProtocolVersion     # 32775
       ].freeze
 
-      requires :hyperv_username, :hyperv_password
+      requires :hyperv_username
       recognizes :hyperv_endpoint, :hyperv_host,
-                 :hyperv_transport,
+                 :hyperv_password,
+                 :hyperv_transport, :hyperv_realm,
                  :hyperv_debug
+
       secrets :hyperv_password, :connection
 
       model_path 'fog/hyperv/models/compute'
@@ -54,6 +56,7 @@ module Fog
       collection :vhds
 
       request_path 'fog/hyperv/requests/compute'
+      request :add_vm_dvd_drive
       request :add_vm_hard_disk_drive
       request :add_vm_network_adapter
       request :connect_vm_network_adapter
@@ -77,6 +80,7 @@ module Fog
       request :new_vm_switch
       request :remove_item
       request :remove_vm
+      request :remove_vm_dvd_drive
       request :remove_vm_hard_disk_drive
       request :remove_vm_network_adapter
       request :restart_vm
@@ -135,11 +139,15 @@ module Fog
           require 'fog/json'
           require 'logging'
 
+          @connections = {}
           @hyperv_endpoint  = options[:hyperv_endpoint]
           @hyperv_endpoint  = "http://#{options[:hyperv_host]}:5985/wsman" if !@hyperv_endpoint && options[:hyperv_host]
           @hyperv_username  = options[:hyperv_username]
           @hyperv_password  = options[:hyperv_password]
-          @hyperv_transport = options[:hyperv_transport] || :negotiate
+          @hyperv_realm     = options[:hyperv_realm]
+          @hyperv_transport = options[:hyperv_transport] || (@hyperv_realm ? :kerberos : :negotiate)
+
+          Logging.logger['WinRM::HTTP::HttpNegotiate'].level = :error
           @logger = Logging.logger['hyper-v']
           if options[:hyperv_debug]
             logger.level = :debug 
@@ -159,10 +167,15 @@ module Fog
           else
             run_wql('SELECT Name FROM Msvm_ComputerSystem WHERE Caption = "Hosting Computer System"') && true
           end
-        rescue Fog::Hyperv::Errors::ServiceError
+        rescue => e
+          logger.debug "Validation failed with #{e.class}; #{e.message}"
           false
         end
 
+        def supports_multihop?
+          return [ :kerberos ].include? @hyperv_transport.to_s.downcase.to_sym
+        end
+
         def version
           @version ||= run_wql('SELECT Version FROM Win32_OperatingSystem', _namespace: 'root/cimv2/*')[:xml_fragment].first[:version] rescue \
             run_shell("$VMMS = if ([environment]::Is64BitProcess) { \"$($env:SystemRoot)\\System32\\vmms.exe\" } else { \"$($env:SystemRoot)\\Sysnative\\vmms.exe\" }\n(Get-Item $VMMS).VersionInfo.ProductVersion", _skip_json: true).stdout.strip
@@ -206,6 +219,7 @@ module Fog
         end
 
         def run_shell(command, options = {})
+          orig_opts = options.dup
           return_fields = options.delete :_return_fields
           return_fields = "| select #{Fog::Hyperv.camelize([return_fields].flatten).join ','}" if return_fields
           suffix = options.delete :_suffix
@@ -213,8 +227,28 @@ module Fog
           skip_json = options.delete :_skip_json
           skip_camelize = options.delete :_skip_camelize
           skip_uncamelize = options.delete :_skip_uncamelize
+          computer = options.delete(:_target_computer) || '.'
+          computers = [options.delete(:computer_name)].flatten.compact
           options = Fog::Hyperv.camelize(options) unless skip_camelize
 
+          if supports_multihop?
+            options[:computer_name] = computers
+            computer = '.'
+          elsif computers.length > 1 || (computers.length == 1 && !['.','localhost'].include?(computers.first.downcase))
+            logger.debug "Executing multi-query for #{computers}"
+            ret = []
+            computers.each do |c|
+              out = run_shell(command, orig_opts.merge(computer_name: nil, _target_computer: c))
+              if out.is_a? Array
+                ret += out
+              else
+                ret << out
+              end
+            end
+            return ret.first if ret.length == 1
+            return ret
+          end
+
           # commandline = "$Args = #{hash_to_optmap options}\n$Ret = #{command} @Args#{"\n$Ret #{return_fields} | ConvertTo-Json -Compress #{"-Depth #{json_depth}" if json_depth}" unless skip_json}"
           # puts " > #{commandline.split("\n").join "\n > "}" if @hyperv_debug
           args = options.reject { |k, v| v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') || (v.is_a?(String) && v.empty?) }.map do |k, v|
@@ -244,7 +278,7 @@ module Fog
               out.exitcode = -1
             end
           else
-            @connection.shell(:powershell) do |shell|
+            connection(computer).shell(:powershell) do |shell|
               out = shell.run(commandline)
             end
           end
@@ -265,18 +299,43 @@ module Fog
           end
         end
 
-        def connect
-          # return require 'open3' if local?
+        def connect(endpoint = nil)
+          endpoint = @hyperv_endpoint unless endpoint
+          fqdn = URI.parse(endpoint).host
 
           require 'winrm'
-          @connection = WinRM::Connection.new(
-            endpoint:  @hyperv_endpoint,
+          opts = {
+            endpoint:  endpoint,
+            transport: @hyperv_transport,
             user:      @hyperv_username,
             password:  @hyperv_password,
-            transport: @hyperv_transport
-          )
-          Logging.logger['WinRM::HTTP::HttpNegotiate'].level = :error
-          @connection.logger.level = :error
+            realm:     @hyperv_realm
+          }
+
+          logger.debug "Creating WinRM connection with #{opts.merge password: '<REDACTED>'}"
+          connection = WinRM::Connection.new opts
+          connection.logger.level = :error
+          @connections[fqdn] = connection
+          
+          if endpoint == @hyperv_endpoint
+            @connection = connection
+            @connections['.'] = connection
+            @connections['localhost'] = connection
+          end
+          connection
+        end
+
+        def connection(host)
+          c = @connections.find { |k,_v| k.downcase.start_with?(host.downcase) }
+          return c[1] if c
+
+          # TODO: Support non-standard endpoints for additional hosts
+          unless host.include? '.'
+            host = "#{host}.#{URI.parse(@hyperv_endpoint).host.split('.').drop(1).join('.')}"
+          end
+          endpoint = "http://#{host}:5985/wsman"
+
+          connect(endpoint)
         end
       end
 

data/lib/fog/hyperv/fog_extensions/enum.rb

@@ -8,17 +8,37 @@ module Fog
         super
       end
 
+      def ensure_value_getter
+        return if model.methods.include?("#{name}_values".to_sym)
+        model.class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}_values
+              #{values}.freeze
+            end
+        EOS
+      end
+
       def create_setter
+        ensure_value_getter
         model.class_eval <<-EOS, __FILE__, __LINE__
             def #{name}=(new_#{name})
+              _values = #{name}_values
+              # FIXME: Prepare a key comparison array in advance
               if new_#{name}.is_a?(Fixnum)
-                raise Fog::Hyperv::Errors::ServiceError, "\#{new_#{name}} is not in the range (0..#{values.length - 1})" unless new_#{name} >= 0 && new_#{name} < #{values.length}
-                attributes[:#{name}] = #{values}[new_#{name}]
+                if _values.class.to_s == 'Array' # TODO: Better way to do class comparison in generated code
+                  puts "\#{_values} (\#{_values.class}) Is array"
+                  raise Fog::Hyperv::Errors::ServiceError, "\#{new_#{name}} is not in the range (0..\#{_values.length - 1})" unless new_#{name} >= 0 && new_#{name} < _values.length
+                else
+                  puts "\#{_values} (\#{_values.class}) Is not array"
+                  raise Fog::Hyperv::Errors::ServiceError, "\#{new_#{name}} is not one of \#{_values.is_a?(Hash) ? _values.keys : _values})" unless (_values.is_a?(Hash) ? _values.keys : _values).include? new_#{name}
+                end
+
+                attributes[:#{name}] = _values[new_#{name}]
               elsif new_#{name}.nil?
                 attributes[:#{name}] = nil
               else
+                puts "Is string"
                 new_#{name} = new_#{name}.to_s.to_sym unless new_#{name}.is_a? String
-                raise Fog::Hyperv::Errors::ServiceError, "\#{new_#{name}} is not one of #{values.is_a?(Hash) ? values.values : values})" unless #{(values.is_a?(Hash) ? values.values : values)}.include? new_#{name}
+                raise Fog::Hyperv::Errors::ServiceError, "\#{new_#{name}} is not one of \#{_values.is_a?(Hash) ? _values.keys : _values})" unless (_values.is_a?(Hash) ? _values.keys : _values).include? new_#{name}
                 attributes[:#{name}] = new_#{name}
               end
             end
@@ -26,23 +46,21 @@ module Fog
       end
 
       def create_getter
+        ensure_value_getter
         model.class_eval <<-EOS, __FILE__, __LINE__
             def #{name}_num
+              _values = #{name}_values
               return nil if self.#{name}.nil?
               if self.#{name}.is_a?(Fixnum)
                 self.#{name}
               else
-                if #{values}.is_a?(Hash)
-                  #{values}.key(self.#{name})
+                if _values.is_a?(Hash)
+                  _values.key(self.#{name})
                 else
-                  #{values}.index(self.#{name})
+                  _values.index(self.#{name})
                 end
               end
             end
-
-            def #{name}_values
-              #{values}.freeze
-            end
         EOS
         super
       end

data/lib/fog/hyperv/models/compute/bios.rb

@@ -10,6 +10,14 @@ module Fog
         # TODO? Enum values; :CD, :IDE, :LegacyNetworkAdapter, :Floppy (, :VHD, :NetworkAdapter)
         attribute :startup_order, type: :array
         attribute :vm_name, type: :string
+        
+        attr_reader :computer, :vm
+
+        def initialize(args = {})
+          super
+          @computer = args.delete :computer
+          @vm = args.delete :vm
+        end
 
         def save
           requires :computer_name, :vm_name

data/lib/fog/hyperv/models/compute/cluster.rb

@@ -8,16 +8,19 @@ module Fog
         attribute :domain, type: :string
         attribute :name, type: :string
 
+        def initialize(attrs = {})
+          super
+
+          @collections = {}
+          self.class.ensure_collections!
+        end
+
         def nodes
           @nodes ||= [service.get_cluster_node(cluster: name, _return_fields: [:description, :name, :node_name])].flatten
         end
 
         def hosts
-          @hosts ||= service.hosts computer_name: nodes.map { |n| n[:name] }
-        end
-
-        def servers
-          @servers ||= service.servers cluster: self
+          @hosts ||= nodes.map { |n| service.hosts.get(n[:name]) }
         end
 
         def reload
@@ -33,6 +36,23 @@ module Fog
           merge_attributes(data.attributes)
           self
         end
+
+        def self.ensure_collections!
+          return if @collections
+          @collections = true
+
+          Fog::Compute::Hyperv.collections.each do |coll|
+            # Don't recurse on hosts
+            next if coll == :hosts
+            coll_name = coll.to_s.split('_').map(&:capitalize).join
+            klass = Fog::Compute::Hyperv.const_get(coll_name)
+            next if klass.requires?(:vm)
+
+            define_method coll do
+              @collections[coll] ||= service.send(coll, cluster: self)
+            end
+          end
+        end
       end
     end
   end

data/lib/fog/hyperv/models/compute/clusters.rb

@@ -5,6 +5,10 @@ module Fog
         model Fog::Compute::Hyperv::Cluster
 
         get_method :get_cluster
+
+        def get(name, filters = {})
+          super(filters.merge(name: name))
+        end
       end
     end
   end

data/lib/fog/hyperv/models/compute/com_port.rb

@@ -5,10 +5,10 @@ module Fog
         identity :id
 
         attribute :computer_name
-        attribute :debugger_mode, type: :enum, values: [ :On, :Off ]
+        attribute :debugger_mode, type: :enum, values: %i[On Off]
         attribute :name
         attribute :path
-        
+
         def save
           raise Fog::Errors::NotImplemented
         end

data/lib/fog/hyperv/models/compute/dvd_drive.rb

@@ -11,36 +11,65 @@ module Fog
         attribute :pool_name
         attribute :controller_location
         attribute :controller_number
-        attribute :controller_type, type: :enum, values: [ :IDE, :SCSI ]
-        attribute :dvd_media_type, type: :enum, values: [ :None, :ISO, :Passthrough ]
+        attribute :controller_type, type: :enum, values: %i[IDE SCSI]
+        attribute :dvd_media_type, type: :enum, values: %i[None ISO Passthrough]
         attribute :vm_id
         attribute :vm_name
         # TODO? VM Snapshots?
         #
-        attr_accessor :to_controller_number, :to_controller_location
 
         def save
           requires :computer_name, :vm_name
 
-          data = service.set_vm_dvd_drive(
-            computer_name: computer_name,
-            vm_name: vm_name,
-            passthru: true,
+          data = \
+            if persisted?
+              service.set_vm_dvd_drive(
+                computer_name: old.computer_name,
+                vm_name: old.vm_name,
+                controller_number: old.controller_number,
+                controller_location: old.controller_location,
+                passthru: true,
 
-            controller_number: controller_number,
-            controller_location: controller_location,
-            resource_pool_name: pool_name,
-            path: path || '$null',
-            to_controller_number: to_controller_number,
-            to_controller_location: to_controller_location,
+                resource_pool_name: changed!(:pool_name),
+                path: changed?(:path) && (path || '$null'),
+                to_controller_number: changed!(:controller_number),
+                to_controller_location: changed!(:controller_location),
+
+                _return_fields: self.class.attributes,
+                _json_depth: 1
+              )
+            else
+              service.add_vm_dvd_drive(
+                computer_name: computer_name,
+                vm_name: vm_name,
+                passthru: true,
+
+                controller_number: controller_number,
+                controller_location: controller_location,
+                path: path,
+                resource_pool_name: pool_name,
+
+                _return_fields: self.class.attributes,
+                _json_depth: 1
+              )
+            end
 
-            _return_fields: self.class.attributes,
-            _json_depth: 1
-          )
           merge_attributes(data)
+          @old = dup
           self
         end
 
+        def destroy
+          requires :computer_name, :vm_name, :controller_number, :controller_location
+
+          service.remove_vm_dvd_drive(
+            computer_name: computer_name,
+            vm_name: vm_name,
+            controller_number: controller_number,
+            controller_location: controller_location
+          )
+        end
+
         def reload
           requires :computer_name, :vm_name
 
@@ -54,6 +83,7 @@ module Fog
             _json_depth: 1
           )
           merge_attributes(data.attributes)
+          @old = data
           self
         end
       end

data/lib/fog/hyperv/models/compute/firmware.rb

@@ -44,6 +44,7 @@ module Fog
             _return_fields: self.class.attributes
           )
           merge_attributes(data)
+          @old = data
           self
         end
       end

data/lib/fog/hyperv/models/compute/floppy_drive.rb

@@ -6,7 +6,7 @@ module Fog
 
         attribute :computer_name
         attribute :disk
-        attribute :is_deleted
+        # attribute :is_deleted
         attribute :name
         attribute :path
         attribute :pool_name
@@ -16,21 +16,25 @@ module Fog
         #
 
         def save
+          raise Fog::Hyperv::Errors::ServiceError, "Can't create new floppy drives" unless persisted?
+
           requires :computer_name, :vm_name
 
-          data = service.set_vm_floppy_disk_drive(
-            computer_name: computer_name,
-            vm_name: vm_name,
-            passthru: true,
+          data = \
+            service.set_vm_floppy_disk_drive(
+              computer_name: old.computer_name,
+              vm_name: old.vm_name,
+              passthru: true,
 
-            resource_pool_name: pool_name,
-            path: path,
+              resource_pool_name: changed!(:pool_name),
+              path: changed?(:path) && (path || '$null'),
 
-            _return_fields: self.class.attributes,
-            _json_depth: 1
-          )
+              _return_fields: self.class.attributes,
+              _json_depth: 1
+            )
 
           merge_attributes(data)
+          @old = dup
           self
         end
 
@@ -40,6 +44,7 @@ module Fog
             vm_name: vm_name
           )
           merge_attributes(data.attributes)
+          @old = data
           self
         end
       end

data/lib/fog/hyperv/models/compute/hard_drive.rb

@@ -6,12 +6,12 @@ module Fog
 
         attribute :computer_name
         attribute :controller_location
-        attribute :controller_number
-        attribute :controller_type, type: :enum, values: [ :IDE, :SCSI ]
+        attribute :controller_number, type: :integer
+        attribute :controller_type, type: :enum, values: %i[IDE SCSI]
         attribute :disk
         # attribute :is_deleted
-        attribute :maximum_iops
-        attribute :minimum_iops
+        attribute :maximum_iops, type: :integer
+        attribute :minimum_iops, type: :integer
         attribute :name
         attribute :path
         attribute :pool_name
@@ -22,7 +22,7 @@ module Fog
 
         def vhd
           return nil unless path && computer_name
-          @vhd ||= Fog::Compute::Hyperv::Vhd.new(service.get_vhd(computer_name: computer_name, path: path).merge(service: service))
+          @vhd ||= service.vhds.get(path, computer_name: computer_name)
         end
 
         def size_bytes
@@ -43,24 +43,24 @@ module Fog
               controller_location: old.controller_location,
               controller_number: old.controller_number,
               controller_type: old.controller_type,
+              passthru: true,
 
               disk_number: changed?(:disk) && disk && disk.number,
-              maximum_iops: changed?(:maximum_iops) && maximum_iops,
-              minimum_iops: changed?(:minimum_iops) && minimum_iops,
-              path: changed?(:path) && path,
-              resource_pool_name: changed?(:pool_name) && pool_name,
-              support_persistent_reservations: changed?(:support_persistent_reservations) && support_persistent_reservations,
-              to_controller_location: changed?(:controller_location) && controller_location,
-              to_controller_number: changed?(:controller_number) && controller_number,
-              to_controller_type: changed?(:controller_type) && controller_type,
+              maximum_iops: changed!(:maximum_iops),
+              minimum_iops: changed!(:minimum_iops),
+              path: changed!(:path),
+              resource_pool_name: changed!(:pool_name),
+              support_persistent_reservations: changed!(:support_persistent_reservations),
+              to_controller_location: changed!(:controller_location),
+              to_controller_number: changed!(:controller_number),
+              to_controller_type: changed!(:controller_type),
 
-              passthru: true,
               _return_fields: self.class.attributes,
               _json_depth: 1
             )
             @vhd = nil if changed?(:path)
           else
-            possible = %i(computer_name controller_location controller_number controller_type path vm_name).freeze
+            possible = %i[computer_name controller_location controller_number controller_type path vm_name].freeze
             data = service.add_vm_hard_disk_drive(
               attributes.select { |k, _v| possible.include? k }.merge(
                 disk_number: disk && disk.number,

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

@@ -29,7 +29,7 @@ module Fog
           Fog::Compute::Hyperv.collections.each do |coll|
             coll_name = coll.to_s.split('_').map(&:capitalize).join
             klass = Fog::Compute::Hyperv.const_get(coll_name)
-            next if klass.requires? :vm
+            next if klass.requires?(:vm)
 
             define_method coll do
               @collections[coll] ||= service.send(coll, computer: self)

data/lib/fog/hyperv/models/compute/network_adapter.rb

@@ -83,7 +83,7 @@ module Fog
                 passthru: true,
 
                 dynamic_mac_address: changed?(:dynamic_mac_address_enabled) && dynamic_mac_address_enabled, 
-                static_mac_address: (changed?(:mac_address) || changed?(:dynamic_mac_address_enabled)) && !dynamic_mac_address_enabled && mac_address,
+                static_mac_address: changed!(:mac_address) || ((changed!(:dynamic_mac_address_enabled) == false) && mac_address),
 
                 _return_fields: self.class.attributes,
                 _json_depth: 1
@@ -134,6 +134,7 @@ module Fog
             vm_name: vm_name
           )
           merge_attributes(data.attributes)
+          @old = data
           self
         end
       end

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

@@ -45,6 +45,7 @@ module Fog
         attribute :com_port2
         attribute :dynamic_memory_enabled, type: :boolean, default: false
         attribute :generation, type: :integer, default: 1 # 1 => bios, 2 => uefi
+        attribute :is_clustered, type: :boolean, default: false
         attribute :state, type: :enum, values: VM_STATUS_ENUM_VALUES
         attribute :status, type: :string
         attribute :memory_assigned, type: :integer
@@ -59,6 +60,8 @@ module Fog
                         :hard_drives,
                         :floppy_drive
 
+        attr_accessor :cluster_name
+
         %i(network_adapters dvd_drives floppy_drives hard_drives vhds).each do |attr|
           define_method attr do
             if persisted?
@@ -75,6 +78,13 @@ module Fog
           end
         end
 
+        def initialize(attrs = {})
+          super
+
+          @cluster = attrs.delete :cluster
+          @computer = attrs.delete :computer
+        end
+
         def bios
           @bios ||= begin
             if generation == 1

data/lib/fog/hyperv/models/compute/switch.rb

@@ -11,36 +11,42 @@ module Fog
         attribute :name
         attribute :net_adapter_interface_description
         attribute :notes
-        attribute :switch_type, type: :enum, values: [ :Private, :Internal, :External ]
+        attribute :switch_type, type: :enum, values: %i[Private Internal External]
 
         def save
           requires :name
 
-          data = if persisted?
-                   service.set_vm_switch(
-                     computer_name: computer_name,
-                     default_flow_minimum_bandwidth_absolute: default_flow_minimum_bandwidth_absolute,
-                     default_flow_minimum_bandwidth_weight: default_flow_minimum_bandwidth_weight,
-                     name: name,
-                     net_adapter_interface_description: net_adapter_interface_description,
-                     notes: notes,
-                     switch_type: !net_adapter_interface_description && switch_type,
-                     passthru: true,
-                     _return_fields: self.class.attributes,
-                     _json_depth: 1
-                   )
-                 else
-                   service.new_vm_switch(
-                     computer_name: computer_name,
-                     name: name,
-                     net_adapter_interface_description: net_adapter_interface_description,
-                     notes: notes,
-                     switch_type: !net_adapter_interface_description && switch_type,
-                     _return_fields: self.class.attributes,
-                     _json_depth: 1
-                   )
-                 end
+          data = \
+            if persisted?
+              service.set_vm_switch(
+                computer_name: old.computer_name,
+                name: old.name,
+                net_adapter_interface_description: old.net_adapter_interface_description,
+                switch_type: !old.net_adapter_interface_description && old.switch_type,
+                passthru: true,
+
+                default_flow_minimum_bandwidth_absolute: changed!(default_flow_minimum_bandwidth_absolute),
+                default_flow_minimum_bandwidth_weight: changed!(default_flow_minimum_bandwidth_weight),
+                notes: changed!(notes),
+
+                _return_fields: self.class.attributes,
+                _json_depth: 1
+              )
+            else
+              service.new_vm_switch(
+                computer_name: computer_name,
+                name: name,
+                net_adapter_interface_description: net_adapter_interface_description,
+                notes: notes,
+                switch_type: !net_adapter_interface_description && switch_type,
+
+                _return_fields: self.class.attributes,
+                _json_depth: 1
+              )
+            end
+
           merge_attributes(data)
+          @old = dup
           self
         end
 
@@ -50,6 +56,7 @@ module Fog
             computer_name: computer_name
           )
           merge_attributes(data.attributes)
+          @old = data
           self
         end
       end

data/lib/fog/hyperv/models/compute/vhd.rb

@@ -14,8 +14,8 @@ module Fog
         attribute :path, type: :string, default: 'New Disk'
         attribute :pool_name
         attribute :size, type: :integer, default: 343_597_383_68
-        attribute :vhd_format, type: :enum, values: [ :Unknown, nil, :VHD, :VHDX, :VHDSet ]
-        attribute :vhd_type, type: :enum, values: [ :Unknown, nil, :Fixed, :Dynamic, :Differencing ]
+        attribute :vhd_format, type: :enum, values: [:Unknown, nil, :VHD, :VHDX, :VHDSet]
+        attribute :vhd_type, type: :enum, values: [:Unknown, nil, :Fixed, :Dynamic, :Differencing]
         # TODO? VM Snapshots?
         #
 
@@ -35,7 +35,7 @@ module Fog
         end
 
         def unc_path
-          "\\\\#{computer_name || '.'}\\#{real_path.gsub ':', '$'}"
+          "\\\\#{computer_name || '.'}\\#{real_path.tr ':', '$'}"
         end
 
         def host
@@ -84,6 +84,7 @@ module Fog
             disk_number: disk
           )
           merge_attributes(data.attributes)
+          @old = data
           self
         end
 
@@ -92,7 +93,7 @@ module Fog
 
           service.remove_item(
             path: unc_path
-          ) if path
+          )
         end
       end
     end

data/lib/fog/hyperv/requests/compute/add_vm_dvd_drive.rb

@@ -0,0 +1,12 @@
+module Fog
+  module Compute
+    class Hyperv
+      class Real
+        def add_vm_dvd_disk_drive(options = {})
+          requires options, :vm_name
+          run_shell('Add-VMDvdDrive', options)
+        end
+      end
+    end
+  end
+end

data/lib/fog/hyperv/requests/compute/remove_vm_dvd_drive.rb

@@ -0,0 +1,12 @@
+module Fog
+  module Compute
+    class Hyperv
+      class Real
+        def remove_vm_dvd_drive(options = {})
+          requires options, :vm_name, :controller_number, :controller_location
+          run_shell('Remove-VMDvdDrive', options.merge(_skip_json: true)).exitcode.zero?
+        end
+      end
+    end
+  end
+end

data/lib/fog/hyperv/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Hyperv
-    VERSION = '0.0.3'.freeze
+    VERSION = '0.0.4'.freeze
   end
 end

data/lib/fog/model.rb

@@ -19,6 +19,9 @@ module Fog
       end
 
       def parent
+        return @vm if @vm
+        return @computer if @computer
+        return @cluster if @cluster
         return nil unless collection
         return collection.vm if collection.attributes.include? :vm
         return collection.computer if collection.attributes.include? :computer
@@ -29,6 +32,24 @@ module Fog
         end
       end
 
+      def vm
+        if respond_to?(:vm_name) && vm_name
+          @vm ||= service.servers.get vm_name
+        end
+      end
+
+      def computer
+        if respond_to?(:computer_name) && computer_name
+          @computer ||= service.hosts.get computer_name
+        end
+      end
+
+      def cluster
+        if respond_to?(:cluster_name) && cluster_name
+          @cluster ||= service.clusters.get cluster_name
+        end
+      end
+
       private
 
       def logger

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fog-hyperv
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Alexander Olofsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-30 00:00:00.000000000 Z
+date: 2017-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog-core
@@ -120,6 +120,7 @@ files:
 - lib/fog/hyperv/models/compute/switches.rb
 - lib/fog/hyperv/models/compute/vhd.rb
 - lib/fog/hyperv/models/compute/vhds.rb
+- lib/fog/hyperv/requests/compute/add_vm_dvd_drive.rb
 - lib/fog/hyperv/requests/compute/add_vm_hard_disk_drive.rb
 - lib/fog/hyperv/requests/compute/add_vm_network_adapter.rb
 - lib/fog/hyperv/requests/compute/connect_vm_network_adapter.rb
@@ -155,6 +156,7 @@ files:
 - lib/fog/hyperv/requests/compute/new_vm_switch.rb
 - lib/fog/hyperv/requests/compute/remove_item.rb
 - lib/fog/hyperv/requests/compute/remove_vm.rb
+- lib/fog/hyperv/requests/compute/remove_vm_dvd_drive.rb
 - lib/fog/hyperv/requests/compute/remove_vm_hard_disk_drive.rb
 - lib/fog/hyperv/requests/compute/remove_vm_network_adapter.rb
 - lib/fog/hyperv/requests/compute/restart_vm.rb
@@ -191,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Module for the `fog` gem to support Microsoft Hyper-V.