fog-hyperv 0.0.9 → 0.1.1

data/lib/fog/hyperv/compute.rb

@@ -1,425 +1,244 @@
-module Fog
-  module Compute
-    class Hyperv < Fog::Service
-      STATUS_ENUM_VALUES = [
-        Unknown: 0,
-        Other: 1,
-        Ok: 2,
-        Degraded: 3,
-        Stressed: 4,
-        PredictiveFailure: 5,
-        Error: 6,
-        NonRecoverableError: 7,
-        Starting: 8,
-        Stopping: 9,
-        Stopped: 0,
-        InService: 1,
-        NoContact: 2,
-        LostCommunication: 3,
-        Aborted: 4,
-        Dormant: 5,
-        SupportingEntity: 6,
-        Completed: 7,
-        PowerMode: 8,
-        ProtocolVersion: 32775,
-      ].freeze
-
-      requires :hyperv_username
-      recognizes :hyperv_endpoint, :hyperv_host,
-                 :hyperv_password,
-                 :hyperv_transport, :hyperv_realm,
-                 :hyperv_debug
-
-      secrets :hyperv_password, :connection
-
-      model_path 'fog/hyperv/models/compute'
-      model :bios
-      model :cluster
-      collection :clusters
-      model :com_port
-      model :dvd_drive
-      collection :dvd_drives
-      model :firmware
-      model :floppy_drive
-      collection :floppy_drives
-      model :hard_drive
-      collection :hard_drives
-      model :host
-      collection :hosts
-      model :network_adapter
-      collection :network_adapters
-      model :server
-      collection :servers
-      model :switch
-      collection :switches
-      model :vhd
-      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
-      request :disconnect_vm_network_adapter
-      request :get_cluster
-      request :get_cluster_node
-      request :get_vhd
-      request :get_vm
-      request :get_vm_bios
-      request :get_vm_dvd_drive
-      request :get_vm_firmware
-      request :get_vm_floppy_disk_drive
-      request :get_vm_group
-      request :get_vm_hard_disk_drive
-      request :get_vm_host
-      request :get_vm_host_cluster
-      request :get_vm_network_adapter
-      request :get_vm_switch
-      request :new_vhd
-      request :new_vm
-      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
-      request :set_vm
-      request :set_vm_bios
-      request :set_vm_dvd_drive
-      request :set_vm_hard_disk_drive
-      request :set_vm_firmware
-      request :set_vm_network_adapter
-      request :set_vm_network_adapter_vlan
-      request :set_vm_switch
-      request :start_vm
-      request :stop_vm
-
-      class Shared
-        def version
-          '0.0'
-        end
-
-        protected
-
-        def requires(opts, *args)
-          missing = args - opts.keys
-          return if missing.none?
-
-          method = caller[0][/`.*'/][1..-2]
-          if missing.length == 1
-            raise(ArgumentError, "#{missing.first} is required for #{method}")
-          elsif missing.any?
-            raise(ArgumentError, "#{missing[0...-1].join(', ')}, and #{missing[-1]} are required for #{method}")
-          end
-        end
-
-        def requires_one(opts, *args)
-          missing = args - opts.keys
-          return if missing.length < args.length
-
-          method = caller[0][/`.*'/][1..-2]
-          raise(ArgumentError, "#{missing[0...-1].join(', ')}, or #{missing[-1]} are required for #{method}")
-        end
+# frozen_string_literal: true
+
+module Fog::Hyperv
+  class Compute < Fog::Service
+    requires :hyperv_username
+    recognizes :hyperv_endpoint, :hyperv_host,
+               :hyperv_password,
+               :hyperv_transport, :hyperv_realm,
+               :hyperv_debug
+
+    secrets :hyperv_password, :connection
+
+    model_path 'fog/hyperv/compute/models'
+    model :bios
+    model :cluster
+    collection :clusters
+    model :com_port
+    collection :com_ports
+    model :dvd_drive
+    collection :dvd_drives
+    model :firmware
+    model :floppy_drive
+    collection :floppy_drives
+    model :hard_drive
+    collection :hard_drives
+    model :host
+    collection :hosts
+    model :network_adapter
+    model :network_adapter_vlan
+    collection :network_adapters
+    model :security
+    model :server
+    collection :servers
+    model :switch
+    collection :switches
+    model :vhd
+    collection :vhds
+
+    request_path 'fog/hyperv/compute/requests'
+    request :add_vm_dvd_drive
+    request :add_vm_hard_disk_drive
+    request :add_vm_network_adapter
+    request :connect_vm_network_adapter
+    request :disable_vm_tpm
+    request :disconnect_vm_network_adapter
+    request :enable_vm_tpm
+    request :get_cluster
+    request :get_cluster_node
+    request :get_vhd
+    request :get_vm
+    request :get_vm_bios
+    request :get_vm_com_port
+    request :get_vm_dvd_drive
+    request :get_vm_firmware
+    request :get_vm_floppy_disk_drive
+    request :get_vm_group
+    request :get_vm_hard_disk_drive
+    request :get_vm_host
+    request :get_vm_host_cluster
+    request :get_vm_host_sbt
+    request :get_vm_key_protector
+    request :get_vm_network_adapter
+    request :get_vm_network_adapter_vlan
+    request :get_vm_security
+    request :get_vm_switch
+    request :new_vhd
+    request :new_vm
+    request :new_vm_switch
+    request :optimize_vhd
+    request :remove_item
+    request :remove_vm
+    request :remove_vm_dvd_drive
+    request :remove_vm_hard_disk_drive
+    request :remove_vm_network_adapter
+    request :remove_vm_switch
+    request :rename_vm
+    request :rename_vm_network_adapter
+    request :rename_vm_switch
+    request :resize_vhd
+    request :restart_vm
+    request :resume_vm
+    request :save_vm
+    request :set_vm
+    request :set_vm_bios
+    request :set_vm_com_port
+    request :set_vm_dvd_drive
+    request :set_vm_firmware
+    request :set_vm_floppy_disk_drive
+    request :set_vm_hard_disk_drive
+    request :set_vm_key_protector
+    request :set_vm_network_adapter
+    request :set_vm_network_adapter_vlan
+    request :set_vm_security
+    request :set_vm_switch
+    request :start_vm
+    request :stop_vm
+    request :suspend_vm
+
+    class Shared
+      def version
+        '0.0'
+      end
 
-        def requires_version(required_version)
-          method = caller[0][/`.*'/][1..-2].split('_')
-          method = method[0].capitalize + "-" + Fog::Hyperv.camelize(method[1..-1].join('_'))
+      protected
 
-          raise Fog::Hyperv::Errors::VersionError.new(required_version, version, method) \
-            unless Gem::Version.new(version) >= Gem::Version.new(required_version)
-        end
+      def requires(opts, *args)
+        missing = args - opts.keys
+        return if missing.none?
 
+        method = caller[0][/`.*'/][1..-2]
+        raise(ArgumentError, "#{missing.first} is required for #{method}") if missing.length == 1
+        raise(ArgumentError, "#{missing[0...-1].join(', ')}, and #{missing[-1]} are required for #{method}") if missing.any?
       end
 
-      class Real < Shared
-        attr_reader :logger
-
-        attr_accessor :bake_optmap, :bake_json
-
-        def initialize(options = {})
-          # require 'ostruct'
-          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_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 
-            logger.add_appenders Logging.appenders.stdout
-          end
-
-          connect
-        end
+      def requires_one(opts, *args)
+        missing = args - opts.keys
+        return if missing.length < args.length
 
-        def local?
-          false # @hyperv_endpoint.nil?
-        end
+        method = caller[0][/`.*'/][1..-2]
+        raise(ArgumentError, "#{missing[0...-1].join(', ')}, or #{missing[-1]} is required for #{method}")
+      end
 
-        def valid?
-          if local?
-            run_shell('Get-VMHost', _return_fields: :name) && true
-          else
-            run_wql('SELECT Name FROM Msvm_ComputerSystem WHERE Caption = "Hosting Computer System"')[:xml_fragment] && true
-          end
-        rescue => e
-          logger.debug "Validation failed with #{e.class}; #{e.message}"
-          false
-        end
+      def requires_version(required_version)
+        method = caller[0][/`.*'/][1..-2].split('_')
+        method = "#{method[0].capitalize}-#{Fog::Hyperv.camelize(method[1..].join('_'))}"
 
-        def supports_multihop?
-          return [ :kerberos ].include? @hyperv_transport.to_s.downcase.to_sym
-        end
+        raise Fog::Hyperv::Errors::VersionError.new(required_version, version, method) \
+          unless Gem::Version.new(version) >= Gem::Version.new(required_version)
+      end
+    end
 
-        def supports_clusters?
-          run_wql('SELECT Name FROM MSCluster_ResourceGroup', _namespace: 'root/mscluster/*')[:xml_fragment] && true
-        rescue => e
-          logger.debug "Cluster support checking failed with #{e.class}: #{e.message}"
-          false
-        end
+    class Real < Shared
+      include Fog::Hyperv::Utils::Winrm
 
-        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
-        end
+      attr_reader :logger
 
-        def ps_version
-          @ps_version ||= run_shell('$PSVersionTable.PSVersion', _bake_optmap: false, _bake_json: false)
-        end
+      attr_accessor :bake_optmap, :bake_json
 
-        private
-
-        def hash_to_optmap(options = {})
-          bake_json = options.delete :_bake_json
-          if bake_json
-            if ps_version[:major] >= 6
-              "$Args = ConvertFrom-Json -AsHashtable '#{Fog::JSON.encode options}'"
-            else
-              <<-EOS
-              $JsonObject = '#{Fog::JSON.encode options}'
-              $JsonParameters = ConvertFrom-Json -InputObject $JsonObject
-              $Args = $JsonParameters.psobject.properties | foreach -begin {$h=@{}} -process {$h."$($_.Name)" = $_.Value} -end {$h}
-              EOS
-            end
-          else
-            args = options.reject { |k, v| v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') }.map do |k, v|
-              "'#{k}'=#{Fog::Hyperv.shell_quoted(v, true)}"
-            end
-
-            "$Args = @{#{args.join ';'}}"
-          end
-        end
+      def initialize(options = {}) # rubocop:disable Style/OptionHash, Lint/MissingSuper -- No super method
+        require 'fog/json'
+        require 'logging'
 
-        def run_shell_with_vm(command, vm_options, options = {})
-          # $VM = Get-VM @vm_options
-          # $Result = <command> @options
-          # $Result | select <return_fields> | ConvertTo-Json
-        end
+        # Transfer cmdlet parameters as JSON object
+        @bake_json = true
+        @bake_optmap = true
 
-        def run_wql(query, options = {})
-          skip_camelize = options.delete :_skip_camelize
-          namespace = options.delete(:_namespace) || 'root/virtualization/v2/*'
+        @connections = {}
+        @hyperv_endpoint = options[:hyperv_endpoint]
+        @hyperv_endpoint ||= "http://#{options[:hyperv_host]}:5985/wsman" if options[:hyperv_host]
+        @hyperv_username = options[:hyperv_username]
+        @hyperv_password = options[:hyperv_password]
+        @hyperv_realm = options[:hyperv_realm]
+        @hyperv_transport = options[:hyperv_transport] || (@hyperv_realm ? :kerberos : :negotiate)
 
-          options = Fog::Hyperv.camelize(options) unless skip_camelize
-          args = options.reject { |k, v| v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') }.map do |k, v|
-            "#{k} = #{(v.is_a?(String) || v.to_s =~ /\s/) && v.inspect || v}"
-          end
+        # Hide NEGOTIATE logging from WinRM to reduce log spam when debugging
+        Logging.logger['WinRM::HTTP::HttpNegotiate'].level = :error
 
-          query = "#{query}#{" WHERE #{args.join ' AND '}" unless args.none?}"
-          data = \
-            if local?
-              # TODO
-            else
-              logger.debug "WQL; #{namespace} >>> #{query}"
-              @connection.run_wql(query, namespace)
-            end
-
-          logger.debug "WQL; <<< #{data}"
-          data
+        @logger = Logging.logger[Fog::Hyperv]
+        if options[:hyperv_debug]
+          logger.level = :debug
+          logger.add_appenders Logging.appenders.stdout
         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
-          json_depth = options.delete :_json_depth
-          skip_json = options.delete :_skip_json
-          skip_camelize = options.delete :_skip_camelize
-          skip_uncamelize = options.delete :_skip_uncamelize
-          always_include = options.delete(:_always_include) {|_| []}
-          bake_optmap = options.delete(:_bake_optmap) {|_| @bake_optmap }
-          bake_json = options.delete(:_bake_json) {|_| @bake_json }
-          computer = options.delete(:_target_computer) || '.'
-          computers = [options.delete(:computer_name)].flatten.compact
-          options.delete_if { |o| o.to_s.start_with?('_') }
-
-          always_include = Fog::Hyperv.camelize(always_include) unless skip_camelize
-          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
-
-          args = options.reject { |k, v| !always_include.include?(k) && (v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') || (v.is_a?(String) && v.empty?)) }.map do |k, v|
-            "-#{k} #{Fog::Hyperv.shell_quoted v if !v.is_a?(TrueClass) || always_include.include?(k)}"
-          end
-
-          if bake_optmap
-            command_args = "#{hash_to_optmap options.merge(_bake_json: bake_json)}\n#{command} @Args"
-          else
-            command_args = "#{command} #{args.join ' ' unless args.empty?}"
-          end
-          commandline = "#{command_args} #{suffix} #{return_fields} #{"| ConvertTo-Json -Compress #{"-Depth #{json_depth}" if json_depth}" unless skip_json}"
-          logger.debug "PS; >>> #{commandline}"
-
-          out = nil
-          if local?
-            commanddata = [
-              'powershell',
-              '-NoLogo',
-              '-NoProfile',
-              '-NonInteractive',
-              commandline
-            ]
-            begin
-              out = OpenStruct.new stdout: '',
-                                   stderr: '',
-                                   exitcode: -1
-              out.stdout, out.stderr, out.exitcode = Open3.capture3(*commanddata)
-              out.exitcode = out.exitcode.exitstatus
-            rescue StandardError => ex
-              out.stderr = ex.inspect
-              out.exitcode = -1
-            end
-          else
-            connection(computer).shell(:powershell) do |shell|
-              # TODO: Reuse shell?
-              # XXX   Multiple commands in one invokation?
-              out = shell.run(commandline)
-            end
-          end
-
-          # TODO: Map error codes in some manner?
-          raise Fog::Hyperv::Errors::ServiceError, "Failed to execute #{commandline}" unless out
-          raise Fog::Hyperv::Errors::PSError.new(out, "When executing #{command_args}") unless out.exitcode.zero?
-
-          logger.debug "PS; <<< OUT=[#{out.stdout.inspect}] ERR=[#{out.stderr.inspect}] EXIT=[#{out.exitcode}]"
+        connect
+      end
 
-          if skip_json
-            out
-          else
-            return nil if out.stdout.empty?
-            json = Fog::JSON.decode(out.stdout)
-            json = Fog::Hyperv.uncamelize(json) unless skip_uncamelize
-            json
-          end
-        end
+      # Is the provider communicating with a Hyper-V install on the local machine
+      def local?
+        false # @hyperv_endpoint.nil?
+      end
 
-        def connect(endpoint = nil)
-          endpoint = @hyperv_endpoint unless endpoint
-          fqdn = URI.parse(endpoint).host
-
-          require 'winrm'
-          opts = {
-            endpoint:  endpoint,
-            transport: @hyperv_transport,
-            user:      @hyperv_username,
-            password:  @hyperv_password,
-            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
+      # Is the Hyper-V provider valid - i.e. can it communicate with a Hyper-V install
+      # @return [Boolean] is the endpoint running a working Hyper-V setup
+      def valid?
+        if local?
+          run_cmd('Get-VMHost', _return_fields: :name) && true
+        else
+          run_wql('SELECT Name FROM Msvm_ComputerSystem WHERE Caption = "Hosting Computer System"')[:xml_fragment] && true
+        end
+      rescue StandardError => e
+        logger.debug "Validation failed with #{e.class}; #{e.message}"
+        false
+      end
 
-        def connection(host)
-          c = @connections.find { |k,_v| k.downcase.start_with?(host.downcase) }
-          return c[1] if c
+      # Does the Hyper-V install support clusters - i.e. is the machine joined to a failover cluster
+      # @return [Boolean] is the Hyper-V setup possible to cluster
+      def supports_clusters?
+        run_wql('SELECT Name FROM MSCluster_ResourceGroup', _namespace: 'root/mscluster/*')[:xml_fragment] && true
+      rescue StandardError => e
+        logger.debug "Cluster support checking failed with #{e.class}: #{e.message}"
+        false
+      end
+    end
 
-          # TODO: Support non-standard endpoints for additional hosts
-          # TODO: Get Windows to provide FQDN for all other hosts
-          unless host.include? '.'
-            host = "#{host}.#{URI.parse(@hyperv_endpoint).host.split('.').drop(1).join('.')}"
-          end
-          endpoint = "http://#{host}:5985/wsman"
+    # Mocked version of the provider for use in testing
+    class Mock < Shared
+      def initialize(_options = {}) # rubocop:disable Lint/MissingSuper -- No super method
+        require 'fog/json'
+      end
 
-          connect(endpoint)
+      def method_missing(method, *args)
+        if requests.find { |_, k| k == method }
+          handle_mock_response((args.first || {}).merge(_method: method))
+        else
+          super
         end
       end
 
-      class Mock < Shared
-        def initialize(_options = {})
-          require 'fog/json'
-        end
+      def respond_to_missing?(method, include_private = false)
+        requests.find { |_, k| k == method } || super
+      end
 
-        def method_missing(method, *args)
-          if requests.find { |_, k| k == method }
-            handle_mock_response((args.first || {}).merge(_method: method))
-          else
-            super
-          end
-        end
+      def self.method_defined?(method)
+        Fog::Hyperv::Compute.requests.find { |_, k| k == method } || super
+      end
 
-        def respond_to_missing?(method, include_private = false)
-          requests.find { |_, k| k == method } || super
-        end
+      private
 
-        def self.method_defined?(method)
-          Fog::Compute::Hyperv.requests.find { |_, k| k == method } || super
+      def handle_mock_response(_method: nil, **args)
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('4.0')
+          _method ||= caller[0][/'.*'/][1..-2].split('#').last
+          _method ||= caller[1][/'.*'/][1..-2].split('#').last
+        else
+          _method ||= caller[0][/`.*'/][1..-2]
+          _method ||= caller[1][/`.*'/][1..-2]
         end
 
-        private
+        path = File.join File.dirname(__FILE__), 'compute', 'requests', 'mock_files', "#{_method}.json"
+        raise Fog::Errors::MockNotImplemented, "No mocked data for #{path}" unless File.exist? path
+        raise Fog::Errors::MockNotImplemented, 'Not implementing skipping of json' if args[:_skip_json]
+        raise Fog::Errors::MockNotImplemented, 'Not implementing skipping of uncamelize' if args[:_skip_uncamelize]
 
-        def handle_mock_response(args = {})
-          method =   args.delete :_method
-          method ||= caller[0][/`.*'/][1..-2]
-          method ||= caller[1][/`.*'/][1..-2]
-
-          path = File.join File.dirname(__FILE__), 'requests', 'compute', 'mock_files', "#{method}.json"
-          Fog::Mock.not_implemented unless File.exist? path
-          raise Fog::Errors::MockNotImplemented, 'Not implementing skipping of json' if args[:_skip_json]
-          raise Fog::Errors::MockNotImplemented, 'Not implementing skipping of uncamelize' if args[:_skip_uncamelize]
-
-          ret = Fog::JSON.decode(open(path).read)
-          ret = Fog::Hyperv.uncamelize(ret)
+        ret = Fog::JSON.decode(File.read(path))
+        ret = Fog::Hyperv.uncamelize(ret)
 
+        if args[:_return_fields]
           ret = ret.map do |obj|
-            obj.select { |k, _| args[:_return_fields].include? k }
-          end if args[:_return_fields]
-          ret
+            obj.slice(*args[:_return_fields])
+          end
         end
+        ret
       end
     end
   end

data/lib/fog/hyperv/constants.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Fog::Hyperv
+  # General GUID format matching the UUIDv4 specification
+  GUID = /[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}/i
+
+  # General enum for on/off toggles as used by Hyper-V
+  #
+  # @note Defined by Microsoft.HyperV.PowerShell.OnOffState
+  ON_OFF_STATE_ENUM_VALUES = %i[
+    On
+    Off
+  ].freeze
+
+  # Possible boot devices
+  #
+  # A few values - +:VHD+ and +:IDE+, +:NetworkAdapter+ and +:LegacyNetworkAdapter+ - refer to the same actual value,
+  # but will be used depending on the generation of the VM.
+  #
+  # @note Defined by Microsoft.HyperV.PowerShell.BootDevice
+  BOOT_DEVICE_ENUM_VALUES = %i[
+    Floppy CD IDE LegacyNetworkAdapter NetworkAdapter VHD
+  ].freeze
+end