fog-hyperv 0.0.9 → 0.1.0

data/lib/fog/hyperv/utils/winrm.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+
+# WinRM helper methods
+module Fog::Hyperv::Utils::Winrm
+  # Struct emulating a WinRM shell return
+  LocalExecOutput = Struct.new(:stdout, :stderr, :exitcode)
+
+  # Check if the PowerShell version is newer than the value specified
+  # @param version [String] a semver version to check if powershell matches
+  # @returns [Boolean] is the running PowerShell newer than the given version
+  def ps_version?(version)
+    Gem::Version(version) >= Gem::Version("#{ps_version[:major]}.#{ps_version[:minor]}")
+  end
+
+  # Run a command on the Hyper-V system
+  # @param cmd [String] the PowerShell command to execute
+  # @param _skip_json [Boolean] should the return data be returned as-is, instead of being sent as JSON
+  # @param _target_computer [String,nil] the computer to execute the command on, in case of clustering
+  # @param options [Hash] the options to call the command with
+  # @option options [Integer] _json_depth (1) the depth to limit the JSON object to on return
+  # @return [Hash] the returned object from PowerShell
+  def run_cmd(cmd, _skip_json: false, _target_computer: nil, **options)
+    _json_depth = options.delete(:_json_depth) { 1 }
+
+    run_cmdlist([[cmd, options.dup]], skip_json: _skip_json, json_depth: _json_depth, target_computer: _target_computer)
+  end
+
+  # Run a list of commands on the Hyper-V system
+  # @param commands [Array<Array(String,Hash)>] a list of commands with their arguments to run
+  # @param skip_json [Boolean] should the return value be given as-is, instead of being sent as JSON
+  # @param target_computer [String,nil] the computer to execute the command on, in case of clustering
+  # @param separate_calls [Boolean] should the commands be run separately
+  # @param options [Hash] additional options for the call
+  # @option options [Integer] json_depth (1) the depth to limit the JSON object to on return
+  def run_cmdlist(commands, skip_json: false, target_computer: nil, separate_calls: false, **options)
+    target_computer = [target_computer].flatten.compact
+    target_computer << '.' if target_computer.empty?
+
+    json_depth = options.delete(:json_depth) { 1 }
+
+    Fog::Logger.debug "run_cmdlist given unknown meta-arguments: #{options.keys.join ', '}" if options.any?
+
+    out = nil
+    target_computer.each do |computer|
+      connection(computer).shell(:powershell) do |shell|
+        # Avoid confirmation questions, abort early on errors
+        setup = [
+          "$ConfirmPreference = 'None'",
+          "$ErrorActionPreference = 'Stop'",
+          '$PSNativeCommandUseErrorActionPreference = $true'
+        ].join('; ')
+        shell.run setup
+
+        pscalls = commands.map.with_index do |(command, args), idx|
+          last = idx == commands.size - 1
+          build_pscall(command, _to_json: last && !skip_json, _json_depth: json_depth, **args)
+        end
+        pscalls = [pscalls.join("\n")] unless separate_calls
+
+        pscalls.each do |cmd|
+          Fog::Logger.debug "PS; >>> \"#{cmd.split("\n").join("\n\t")}\""
+          out = shell.run cmd
+          Fog::Logger.debug "PS; <<< OUT=[#{out.stdout.inspect}] ERR=[#{out.stderr.inspect}] EXIT=[#{out.exitcode}]"
+
+          is_success = true
+          is_success = shell.run('$?').stdout.strip.downcase == 'true' if out.stderr.include? 'FullyQualifiedErrorId'
+
+          raise Fog::Hyperv::Errors::PSError.new(out, "When executing #{cmd}") if
+            out.exitcode != 0 || !is_success
+        end
+      end
+    end
+
+    return out if skip_json
+    return nil if out.stdout.strip.empty?
+
+    json = Fog::JSON.decode(out.stdout)
+    Fog::Hyperv.uncamelize(json)
+  end
+
+  # Perform a WQL query against the Hyper-V system
+  # @param query [String] the query to perform
+  # @param _namespace [String] the namespace to perform the call in
+  # @param where [Hash] the WHERE arguments to add to the query
+  # @return [Hash] the return hash from the WQL query
+  def run_wql(query, _namespace: 'root/virtualization/v2', **where)
+    args = Fog::Hyperv.camelize(where).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
+
+    query = "#{query}#{" WHERE #{args.join ' AND '}" unless args.none?}"
+
+    Fog::Logger.debug "WQL; in #{_namespace} >>> #{query}"
+    data =
+      if local?
+        raise NotImplementedError, 'Not implemented for local connection'
+        # run_cmd('Get-WmiObject', query:, namespace:, _return_fields: options.keys)
+      else
+        @connection.run_wql(query, "#{_namespace}/*")[:xml_fragment].first
+      end
+    Fog::Logger.debug "WQL; <<< #{data}"
+
+    data
+  end
+
+  private
+
+  def version
+    @version ||= begin
+      run_wql('SELECT Version FROM Win32_OperatingSystem', _namespace: 'root/cimv2')[:version]
+    rescue StandardError
+      run_cmd(
+        <<~CMD,
+          $VMMS = if ([environment]::Is64BitProcess) {
+            "$($env:SystemRoot)\\System32\\vmms.exe"
+          } else {
+            "$($env:SystemRoot)\\Sysnative\\vmms.exe"
+          }
+          (Get-Item $VMMS).VersionInfo.ProductVersion"
+        CMD
+        _skip_json: true,
+        _ps_version: 1
+      ).stdout.strip
+    end
+  end
+
+  def ps_version
+    @ps_version ||= run_cmd('$PSVersionTable.PSVersion', _ps_version: 1)
+  end
+
+  def build_pscall(command, _by_id: nil, _return_fields: nil, _always_include: [], **options)
+    _ps_version = options.delete(:_ps_version) { ps_version[:major] }
+    _to_json = options.delete(:_to_json) { true }
+    _json_depth = options.delete(:_json_depth) { 1 }
+
+    pipeline = []
+    pipeline << "Where-Object {$_.id -eq '#{_by_id}'}" if _by_id
+    pipeline << "Select #{Fog::Hyperv.camelize([_return_fields].flatten).join ','}" if _return_fields
+    pipeline << "ConvertTo-Json -Compress#{" -Depth #{_json_depth}" if _json_depth}" if _to_json
+
+    invalid_opts = options.select { |k, _| k.to_s.start_with? '_' }
+    Fog::Logger.debug "build_pscall given unexpected meta-arguments: #{invalid_opts.keys.join ', '}" if invalid_opts.any?
+
+    options.reject! { |k, _| k.to_s.start_with?('_') }
+    options.reject! do |k, v|
+      !_always_include.include?(k) && (v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') || (v.is_a?(String) && v.empty?))
+    end
+    options = Fog::Hyperv.camelize(options.compact)
+
+    command += ' @Args' unless command.include? '@Args'
+    pipeline = [command] + pipeline
+    Fog::Hyperv::Utils::Powershell.build_call(pipeline.join(' | '), options, _ps_version:)
+  end
+
+  def connection(host)
+    existing = @connections.find do |c_host, c_connection|
+      c_host.downcase.start_with?(host.downcase) ||
+        URI(c_connection.instance_variable_get(:@connection_opts)[:endpoint]).host.downcase.start_with?(host.downcase)
+    end
+
+    if existing
+      @connections[host] = existing unless @connections.key? host
+      return existing.last
+    end
+
+    if %w[. localhost].include? host
+      endpoint = @hyperv_endpoint
+    else
+      # TODO: Support non-standard endpoints for additional hosts
+      unless host.include? '.'
+        host = run_cmd("[System.Net.Dns]::GetHostByName(#{host.inspect})", _return_fields: :host_name, _ps_version: 1)[:host_name]
+      end
+      endpoint = "http://#{host}:5985/wsman"
+    end
+
+    existing = @connections.find do |_, c_connection|
+      c_connection.instance_variable_get(:@connection_opts)[:endpoint] == endpoint
+    end
+
+    if existing
+      @connections[host] = existing unless @connections.key? host
+      return existing.last
+    end
+
+    connect(endpoint)
+  end
+
+  def connect(endpoint = nil)
+    endpoint ||= @hyperv_endpoint
+    fqdn = URI.parse(endpoint).host
+
+    require 'winrm'
+
+    opts = {
+      endpoint: endpoint,
+      transport: @hyperv_transport,
+      user: @hyperv_username,
+      password: @hyperv_password,
+      realm: @hyperv_realm,
+      no_ssl_peer_verification: true
+    }
+
+    Fog::Logger.debug "Creating WinRM connection with #{opts.merge password: '<REDACTED>'}"
+    connection = WinRM::Connection.new opts
+    connection.logger.level = :error
+    @connections[fqdn] = connection
+
+    # Add the local host's names to the connection
+    begin
+      hostname = run_cmd('$env:computerName', _target_computer: fqdn, _skip_json: true, _ps_version: 1).stdout.downcase.strip
+      @connections[hostname] ||= connection
+      fqdn = run_cmd(
+        '[System.Net.Dns]::GetHostByName(($env:computerName)).Hostname',
+        _target_computer: fqdn,
+        _skip_json: true,
+        _ps_version: 1
+      ).stdout.downcase.strip
+      @connections[fqdn] ||= connection
+    end
+
+    if endpoint == @hyperv_endpoint
+      @connection = connection
+      @connections['.'] = connection
+      @connections['localhost'] = connection
+      @local_hostname = hostname
+    end
+
+    connection
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/lib/fog/hyperv/version.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Fog
   module Hyperv
-    VERSION = '0.0.9'.freeze
+    # The Fog Hyper-V version
+    VERSION = '0.1.0'
   end
 end

data/lib/fog/hyperv.rb

@@ -1,19 +1,27 @@
+# frozen_string_literal: true
+
 require 'fog/core'
 
 module Fog
   module Attributes
-    autoload :Enum, File.expand_path('../hyperv/fog_extensions/enum.rb', __FILE__)
-  end
-
-  module Compute
-    autoload :Hyperv, File.expand_path('../hyperv/compute', __FILE__)
+    autoload :Hypervdatetime, File.expand_path('hyperv/fog_extensions/attributes/datetime.rb', __dir__)
+    autoload :Hypervenum, File.expand_path('hyperv/fog_extensions/attributes/enum.rb', __dir__)
+    autoload :Hypervenumarray, File.expand_path('hyperv/fog_extensions/attributes/enumarray.rb', __dir__)
+    autoload :Hypervtimespan, File.expand_path('hyperv/fog_extensions/attributes/timespan.rb', __dir__)
   end
 
   module Hyperv
+    require 'fog/hyperv/constants'
+
     extend Fog::Provider
 
+    autoload :Compute, File.expand_path('hyperv/compute', __dir__)
+
     module Errors
+      # A general service error occurred
       class ServiceError < Fog::Errors::Error; end
+
+      # A version constrain was not matched
       class VersionError < ServiceError
         attr_reader :version, :required_version, :function
 
@@ -22,10 +30,11 @@ module Fog
           @required_version = required_version
           @version = version
 
-          super "#{function} requires at least Hyper-V v#{required_version}, you have v#{version}"
+          super("#{function} requires at least Hyper-V v#{required_version}, you have v#{version}")
         end
       end
 
+      # A powershell call failed
       class PSError < ServiceError
         attr_reader :stdout, :stderr, :exitcode, :info, :message
 
@@ -34,51 +43,48 @@ module Fog
           @stderr = output.stderr
           @exitcode = output.exitcode
           @info = info
-          @message = @stderr.split("\n").first
-          super @message
-        end
+          extract_message
 
-        def to_s
-          ret = [super]
-          ret << info unless info.nil? || info.empty?
-          ret.join "\n"
+          super(@message)
         end
-      end
-    end
 
-    autoload :Collection, File.expand_path('../collection', __FILE__)
-    autoload :Model, File.expand_path('../model', __FILE__)
-    autoload :ModelExtends, File.expand_path('../model', __FILE__)
-    autoload :ModelIncludes, File.expand_path('../model', __FILE__)
-    autoload :VMCollection, File.expand_path('../collection', __FILE__)
+        # def to_s
+        #   ret = [super]
+        #   ret << info unless info.nil? || info.empty?
+        #   ret.join "\n"
+        # end
 
-    service(:compute, 'Compute')
+        private
 
-    def self.shell_quoted(data, always = false)
-      case data
-      when String
-        if !data.start_with?('$') && (data =~ /(^$)|\s/ || always)
-          data.gsub(/`/, '``')
-              .gsub(/\0/, '`0')
-              .gsub(/\n/, '`n') 
-              .gsub(/\r/, '`r') 
-              .inspect
-              .gsub(/\\"/, '`"')
-              .gsub(/\\\\/, '\\')
-        else
-          data
+        def extract_message
+          stderr = @stderr.split("\n").map(&:strip)
+
+          # Find a line ending in an error ID
+          @message = stderr.find { |line| line =~ /\(0x[0-9a-f]+\)\.?$/}
+          # Find the last line that isn't include error class information
+          @message ||= stderr.take_while { |line| !line.start_with? '+' }.last
         end
-      when Array
-        '@(' + data.map { |e| shell_quoted(e, true) }.join(', ') + ')'
-      when FalseClass
-        '$false'
-      when TrueClass
-        '$true'
-      else
-        shell_quoted data.to_s
       end
     end
 
+    module Associations
+      autoload :Collection, File.expand_path('hyperv/fog_extensions/associations/collection', __dir__)
+    end
+
+    module Utils
+      autoload :Powershell, File.expand_path('hyperv/utils/powershell', __dir__)
+      autoload :Winrm, File.expand_path('hyperv/utils/winrm', __dir__)
+    end
+
+    autoload :Collection, File.expand_path('hyperv/collection', __dir__)
+    autoload :Model, File.expand_path('hyperv/model', __dir__)
+    autoload :ModelExtends, File.expand_path('hyperv/model', __dir__)
+    autoload :ModelIncludes, File.expand_path('hyperv/model', __dir__)
+    autoload :VMCollection, File.expand_path('hyperv/collection', __dir__)
+
+    service(:compute, 'Compute')
+
+    # Convert a piece of data from being snake_case to being CamelCase
     def self.camelize(data)
       case data
       when Array
@@ -86,7 +92,7 @@ module Fog
       when Hash
         data.each_with_object({}) do |(k, v), hash|
           value = v
-          value = camelize(v) if v.is_a?(Hash) || (v.is_a?(Array) && v.all? { |h| h.is_a?(Hash) })
+          value = camelize(v) if v.is_a?(Hash) || (v.is_a?(Array) && v.all?(Hash))
           hash[camelize(k)] = value
         end
       when Symbol
@@ -98,6 +104,7 @@ module Fog
       end
     end
 
+    # Convert a piece of data from being CamelCase to being snake_case
     def self.uncamelize(data)
       case data
       when Array
@@ -105,7 +112,7 @@ module Fog
       when Hash
         data.each_with_object({}) do |(k, v), hash|
           value = v
-          value = uncamelize(v) if v.is_a?(Hash) || (v.is_a?(Array) && v.all? { |h| h.is_a?(Hash) })
+          value = uncamelize(v) if v.is_a?(Hash) || (v.is_a?(Array) && v.all?(Hash))
           hash[uncamelize(k)] = value
         end
       when Symbol