manageiq-smartstate 0.8.1 → 0.9.0

data/lib/Scvmm/miq_hyperv_disk.rb

@@ -1,274 +0,0 @@
-# encoding: US-ASCII
-
-require 'util/miq_winrm'
-require 'util/miq-exception'
-require 'Scvmm/miq_scvmm_parse_powershell'
-require 'base64'
-require 'securerandom'
-require 'memory_buffer'
-
-require 'rufus/lru'
-
-class MiqHyperVDisk
-  MIN_SECTORS_TO_CACHE = 64
-  DEF_BLOCK_CACHE_SIZE = 1200
-  DEBUG_CACHE_STATS    = false
-  BREAD_RETRIES        = 3
-  OPEN_ERRORS          = %w( Exception\ calling At\ line: ).freeze
-
-  attr_reader :hostname, :virtual_disk, :file_offset, :file_size, :parser, :vm_name, :temp_snapshot_name
-
-  def initialize(hyperv_host, user, pass, port = nil, network = false)
-    @hostname  = hyperv_host
-    @winrm     = MiqWinRM.new
-    port ||= 5985
-    @winrm.connect(:port => port, :user => user, :password => pass, :hostname => @hostname)
-    @parser       = MiqScvmmParsePowershell.new
-    @block_size   = 4096
-    @file_size    = 0
-    @block_cache  = LruHash.new(DEF_BLOCK_CACHE_SIZE)
-    @cache_hits   = Hash.new(0)
-    @cache_misses = Hash.new(0)
-    @network      = network
-    @total_read_execution_time = @total_copy_from_remote_time = 0
-  end
-
-  def open(vm_disk)
-    @virtual_disk  = vm_disk
-    @file_offset   = 0
-
-    unless @network
-      open_script = <<-OPEN_EOL
-$file_stream   = [System.IO.File]::Open("#{@virtual_disk}", "Open", "Read", "Read")
-$file_stream.seek(0, 0)
-OPEN_EOL
-      @winrm.run_powershell_script(open_script)
-    end
-
-    stat_script = <<-STAT_EOL
-(Get-Item "#{@virtual_disk}").length
-STAT_EOL
-    file_size, stderr = @parser.parse_single_powershell_value(run_correct_powershell(stat_script))
-
-    if @network && stderr.include?("RegisterTaskDefinition")
-      raise MiqException::MiqInvalidCredentialsError, "Unable to obtain virtual disk size for #{vm_disk}. Check Hyper-V Host Domain Credentials."
-    end
-    OPEN_ERRORS.each { |error| raise "Unable to obtain virtual disk size for #{vm_disk}" if stderr.include?(error) }
-    @file_size           = file_size.to_i
-    @end_byte_addr       = @file_size - 1
-    @size_in_blocks, rem = @file_size.divmod(@block_size)
-    @size_in_blocks += 1 if rem > 0
-    @lba_end = @size_in_blocks - 1
-  end
-
-  def size
-    @file_size
-  end
-
-  def close
-    hit_or_miss if DEBUG_CACHE_STATS
-    @file_offset = 0
-    unless @network
-      close_script = <<-CLOSE_EOL
-$file_stream.Close()
-CLOSE_EOL
-      run_correct_powershell(close_script)
-    end
-    @winrm.close
-    @winrm = nil
-  end
-
-  def hit_or_miss
-    $log.debug "\nmiq_hyperv_disk cache hits:"
-    @cache_hits.keys.sort.each do |block|
-      $log.debug "block #{block} - #{@cache_hits[block]}"
-    end
-    $log.debug "\nmiq_hyperv_disk cache misses:"
-    @cache_misses.keys.sort.each do |block|
-      $log.debug "block #{block} - #{@cache_misses[block]}"
-    end
-    $log.debug "Total time spent copying reads from remote system is #{@total_copy_from_remote_time}"
-    $log.debug "Total time spent transferring and decoding reads on local system is #{@total_read_execution_time - @total_copy_from_remote_time}"
-    $log.debug "Total time spent processing remote reads is #{@total_read_execution_time}"
-  end
-
-  def seek(offset, whence = IO::SEEK_SET)
-    $log.debug "miq_hyperv_disk.seek(#{offset})"
-    case whence
-    when IO::SEEK_CUR
-      @file_offset += offset
-    when IO::SEEK_END
-      @file_offset = @end_byte_addr + offset
-    when IO::SEEK_SET
-      @file_offset = offset
-    end
-    @file_offset
-  end
-
-  def read(size)
-    $log.debug "miq_hyperv_disk.read(#{size})"
-    return nil if @file_offset >= @file_size
-    size = @file_size - @file_offset if (@file_offset + size) > @file_size
-
-    start_sector, start_offset = @file_offset.divmod(@block_size)
-    end_sector                 = (@file_offset + size - 1) / @block_size
-    number_sectors             = end_sector - start_sector + 1
-
-    @file_offset += size
-    bread_cached(start_sector, number_sectors)[start_offset, size]
-  end
-
-  def bread_cached(start_sector, number_sectors)
-    $log.debug "miq_hyperv_disk.bread_cached(#{start_sector}, #{number_sectors})"
-    @block_cache.keys.each do |block_range|
-      sector_offset = start_sector - block_range.first
-      buffer_offset = sector_offset * @block_size
-      if block_range.include?(start_sector) && block_range.include?(start_sector + number_sectors - 1)
-        length = number_sectors * @block_size
-        @cache_hits[start_sector] += 1
-        return @block_cache[block_range][buffer_offset, length]
-      elsif block_range.include?(start_sector)
-        # This range overlaps the start of our requested read, but more data is required at the end of the request
-        sectors_in_range = block_range.last - start_sector
-        length           = sectors_in_range * @block_size
-        remaining_blocks = number_sectors - sectors_in_range
-        @cache_hits[start_sector] += 1
-        # The "+" operator is required rather than "<<" so as not to modify the @block_cache object.
-        return @block_cache[block_range][buffer_offset, length] + bread_cached(block_range.last + 1, remaining_blocks)
-      elsif block_range.include?(start_sector + number_sectors - 1)
-        # This range overlaps the end of our requested read, but more data is required at the start of the request
-        sectors_in_range = (start_sector + number_sectors) - block_range.first
-        length           = sectors_in_range * @block_size
-        remaining_blocks = number_sectors - sectors_in_range
-        @cache_hits[start_sector] += 1
-        # The  "<<" operator is valid and more efficient here
-        return bread_cached(start_sector, remaining_blocks) << @block_cache[block_range][0, length]
-      elsif block_range.first > start_sector && block_range.last < start_sector + number_sectors
-        # This range overlaps our requested read but more data is required both before and after the range
-        sectors_in_range   = block_range.last - block_range.first + 1
-        sectors_pre_range  = block_range.first - start_sector
-        sectors_post_range = number_sectors - sectors_in_range - sectors_pre_range
-        # Note the mixed use of operators below.
-        # The first "<<" operator is valid and more efficient while the second "+" operator 
-        # is required instead so as not to modify the in-place @block_cache object.
-        return bread_cached(start_sector, sectors_pre_range) <<
-               @block_cache[block_range] +
-               bread_cached(block_range.last + 1, sectors_post_range)
-      end
-    end
-    block_range               = entry_range(start_sector, number_sectors)
-    @block_cache[block_range] = bread(block_range.first, block_range.last - block_range.first + 1)
-    @cache_misses[start_sector] += 1
-
-    sector_offset             = start_sector - block_range.first
-    buffer_offset             = sector_offset * @block_size
-    length                    = number_sectors * @block_size
-
-    @block_cache[block_range][buffer_offset, length]
-  end
-
-  def bread(start_sector, number_sectors)
-    log_header = "MIQ(#{self.class.name}.#{__method__}:"
-    $log.debug "#{log_header} (#{start_sector}, #{number_sectors})"
-    return nil if start_sector > @lba_end
-    number_sectors = @size_in_blocks - start_sector if (start_sector + number_sectors) > @size_in_blocks
-    expected_bytes = number_sectors * @block_size
-    read_script    = if @network
-
-                       <<-READ_NETWORK_EOL
-$file_stream   = [System.IO.File]::Open("#{@virtual_disk}", "Open", "Read", "Read")
-$bufsize       = #{number_sectors * @block_size}
-$buffer        = New-Object System.Byte[] $bufsize
-$encodedbuflen = $bufsize * 4 / 3
-if (($encodedbuflen % 4) -ne 0)
-{
-$encodedbuflen += 4 - ($encodedbuflen % 4)
-}
-$encodedarray = New-Object Char[] $encodedbuflen
-$file_stream.seek(#{start_sector * @block_size}, 0)
-$file_stream.read($buffer, 0, #{expected_bytes})
-[System.Convert]::ToBase64CharArray($buffer, 0, $bufsize, $encodedarray, 0)
-[string]::join("", $encodedarray)
-$file_stream.Close()
-READ_NETWORK_EOL
-                     else
-
-                       <<-READ_EOL
-if ($bufsize -ne #{number_sectors * @block_size})
-{
-  $bufsize       = #{number_sectors * @block_size}
-  $buffer        = New-Object System.Byte[] $bufsize
-  $encodedbuflen = $bufsize * 4 / 3
-  if (($encodedbuflen % 4) -ne 0)
-  {
-    $encodedbuflen += 4 - ($encodedbuflen % 4)
-  }
-  $encodedarray = New-Object Char[] $encodedbuflen
-}
-$file_stream.seek(#{start_sector * @block_size}, 0)
-$file_stream.read($buffer, 0, #{expected_bytes})
-[System.Convert]::ToBase64CharArray($buffer, 0, $bufsize, $encodedarray, 0)
-[string]::join("", $encodedarray)
-READ_EOL
-                     end
-
-    i = 0
-    (0...BREAD_RETRIES).each do
-      t1           = Time.now.getlocal
-      encoded_data = @parser.output_to_attribute(run_correct_powershell(read_script))
-      if encoded_data.empty?
-        $log.debug "#{log_header} no encoded data returned on attempt #{i}"
-        i += 1
-        continue
-      end
-      t2           = Time.now.getlocal
-      decoded_data = Base64.decode64(encoded_data)
-      @total_copy_from_remote_time += t2 - t1
-      @total_read_execution_time += Time.now.getlocal - t1
-      decoded_size = decoded_data.size
-      return decoded_data if expected_bytes == decoded_size
-      $log.debug "#{log_header} expected #{expected_bytes} bytes - got #{decoded_size} on attempt #{i}"
-      i += 1
-    end
-    raise "#{log_header} expected #{expected_bytes} bytes - got #{decoded_size}"
-  end
-
-  def snap(vm_name)
-    @vm_name = vm_name
-    @temp_snapshot_name = vm_name + SecureRandom.hex
-    snap_script = <<-SNAP_EOL
-Checkpoint-VM -Name #{@vm_name} -SnapshotName #{@temp_snapshot_name}
-SNAP_EOL
-    @vm_name = vm_name
-    @temp_snapshot_name = vm_name + SecureRandom.hex
-    @winrm.run_powershell_script(snap_script)
-  end
-
-  def delete_snap
-    delete_snap_script = <<-DELETE_SNAP_EOL
-Remove-VMSnapShot -VMName #{@vm_name} -Name #{@temp_snapshot_name}
-DELETE_SNAP_EOL
-    @winrm.run_powershell_script(delete_snap_script)
-  end
-
-  private
-
-  def run_correct_powershell(script)
-    return @winrm.run_elevated_powershell_script(script) if @network
-    @winrm.run_powershell_script(script)
-  end
-
-  def entry_range(start_sector, number_sectors)
-    # Cache entries are *multiples* of MIN_SECTORS_TO_CACHE * @blocksize  in length,
-    # aligned to MIN_SECTORS_TO_CACHE * @blocksize byte boundaries.
-    # real_start_block is the aligned cache block based on the start_sector, and
-    # real_start_sector is the disk sector for that cache block.
-    real_start_block    = start_sector / MIN_SECTORS_TO_CACHE
-    real_end_block      = (start_sector + number_sectors) / MIN_SECTORS_TO_CACHE
-    number_cache_blocks = real_end_block - real_start_block + 1
-    sectors_to_read     = number_cache_blocks * MIN_SECTORS_TO_CACHE
-    real_start_sector   = real_start_block * MIN_SECTORS_TO_CACHE
-    end_sector          = real_start_sector + sectors_to_read - 1
-    Range.new(real_start_sector, end_sector)
-  end
-end

data/lib/Scvmm/miq_scvmm_parse_powershell.rb

@@ -1,75 +0,0 @@
-class MiqScvmmParsePowershell
-  def output_to_attribute(winrm_output)
-    attribute, stderr = stdout_stderr(winrm_output)
-    if stderr =~ /Exception/ || stderr =~ /At line:/
-      raise "Error running PowerShell command.\n #{stderr}"
-    end
-    $log.debug "MiqScvmmParsePowershell: STDERR is \"#{stderr}\"" unless stderr.nil? || $log.nil?
-    attribute.split("\r\n").last
-  end
-
-  #
-  # This method handles one or more lines of exactly one attribute.
-  #
-  def parse_single_attribute_values(output)
-    parse_attribute_values(output)
-  end
-
-  def parse_multiple_attribute_values(output)
-    parse_attribute_values(output, true)
-  end
-
-  #
-  # This method handles one or more lines of one or more attributes.
-  #
-  def parse_attribute_values(output, multiple = nil)
-    stdout, stderr  = parse_powershell_value(output)
-    lines           = stdout.split("\r\n")
-    dashes          = nil
-    attributes      = []
-    attribute_names = []
-    lines.each do |line|
-      next if line.nil? || line == ""
-      if line =~ /^-+/
-        dashes = true
-        next
-      end
-      if dashes.nil?
-        attribute_names = line.split(" ")
-        next
-      end
-      line_parts = multiple.nil? ? [line.rstrip] : line.split(" ")
-      raise "Incorrect number of PowerShell Output Attributes Found" if line_parts.size != attribute_names.size
-      i = 0
-      line_hash = {}
-      attribute_names.each do |attribute|
-        line_hash[attribute] = line_parts[i]
-        i += 1
-      end
-      attributes << line_hash
-    end
-    return attributes, stderr
-  end
-
-  def parse_single_powershell_value(output)
-    stdout, stderr = parse_powershell_value(output)
-    return stdout.split("\r\n").first, stderr
-  end
-
-  def parse_powershell_value(output)
-    stdout, stderr = stdout_stderr(output)
-    $log.debug "MiqScvmmParsePowershell: STDOUT is \"#{stdout}\"" unless stdout.nil? || $log.nil?
-    $log.debug "MiqScvmmParsePowershell: STDERR is \"#{stderr}\"" unless stderr.nil? || $log.nil?
-    return stdout, stderr
-  end
-
-  private
-
-  def stdout_stderr(output)
-    stdout = ""
-    stderr = ""
-    stdout << output.stdout unless output.stdout.nil?
-    stderr << output.stderr unless output.stderr.nil?
-    return stdout, stderr
-  end
-end

data/lib/Scvmm/miq_scvmm_vm_ssa_info.rb

@@ -1,135 +0,0 @@
-# encoding: US-ASCII
-
-require 'util/miq_winrm'
-require 'Scvmm/miq_scvmm_parse_powershell'
-
-class MiqScvmmVmSSAInfo
-  attr_reader :vhds, :hostname, :checkpoints, :vhd_type
-  def initialize(provider, user, pass, port = nil)
-    @checkpoints = []
-    @vhds        = []
-    @hostname    = nil
-    @vhd_type    = nil
-    @winrm       = MiqWinRM.new
-    winrmport    = port.nil? ? 5985 : port
-    options      = {:port => winrmport, :user => user, :password => pass, :hostname => provider}
-    @elevated    = nil
-
-    @winrm.connect(options)
-    @parser = MiqScvmmParsePowershell.new
-  end
-
-  def close
-    @winrm.close
-  end
-
-  # Note the following method returns *all* hard disks and some common attributes from the Hyper-V host
-  def vm_all_harddisks(vm_name, snapshot = nil, check_snapshot = TRUE)
-    vhds       = vm_get_disks(vm_name, snapshot, check_snapshot)
-    properties = vm_get_properties(vm_name)
-    raise "Error getting VHD(s) and Attributes for #{vm_name}" if vhds.size != properties.size
-    raise "No Virtual Hard Disk found for VM #{vm_name}" unless vhds.any?
-
-    i = 0
-    new_vhds = []
-    $log.debug "vm_all_harddisks: #{vhds.size} vhds found:\n"
-    vhds.each do |vhd|
-      vhd.merge!(properties[i])
-      new_vhds << vhd
-      i += 1
-    end
-    new_vhds
-  end
-
-  def vm_get_checkpoint(vm_name, snapshot)
-    get_checkpoint_script = <<-GETCHECKPOINT_EOL
-Get-VMSnapShot -ComputerName localhost -VMName "#{vm_name}" -Name "#{snapshot}"| \
-  Select-Object -ExpandProperty Name
-GETCHECKPOINT_EOL
-
-    checkpoint, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(get_checkpoint_script))
-    if stderr =~ /Unable to find a snapshot/
-      return nil
-    else
-      raise "Error finding Snapshot for #{vm_name}: #{stderr}" unless stderr.empty?
-    end
-    checkpoint
-  end
-
-  def vm_create_evm_checkpoint(vm_name, snapshot = nil)
-    snapshot = vm_name + "__EVM_SNAPSHOT" if snapshot.nil?
-    raise "Checkpoint for VM #{vm_name} Already Exists" unless vm_get_checkpoint(vm_name, snapshot).nil?
-
-    checkpoint_script = <<-CHECKPOINT_EOL
-Checkpoint-VM -ComputerName localhost -Name "#{vm_name}" -SnapshotName "#{snapshot}"
-CHECKPOINT_EOL
-
-    _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(checkpoint_script))
-    unless stderr.empty?
-      @elevated = true
-      _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_elevated_powershell_script(checkpoint_script))
-    end
-    raise "Unable to create Snapshot for #{vm_name}: #{stderr}" unless stderr.empty?
-    snapshot
-  end
-
-  def vm_remove_evm_checkpoint(vm_name, snapshot = nil)
-    snapshot = vm_name + "__EVM_SNAPSHOT" if snapshot.nil?
-    rm_checkpt_script = <<-RM_CHECKPOINT_EOL
-Remove-VMSnapshot -ComputerName localhost -VMName "#{vm_name}" -Name "#{snapshot}"
-RM_CHECKPOINT_EOL
-
-    if @elevated
-      _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_elevated_powershell_script(rm_checkpt_script))
-    else
-      _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(rm_checkpt_script))
-    end
-    raise "Unable to remove Snapshot for #{vm_name}: #{stderr}" unless stderr.empty?
-  end
-
-  def get_drivetype(vhd_path)
-    return "Network" if vhd_path[0, 2] == '\\\\'
-    raise "Invalid Drive Letter for Hard Drive #{vhd_path}" unless vhd_path[1, 1] == ":"
-    drive_letter = vhd_path[0, 1]
-
-    drivetype_script = <<-DRIVETYPE_EOL
-([System.IO.DriveInfo]("#{drive_letter}")).DriveType
-DRIVETYPE_EOL
-    drive_type, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(drivetype_script))
-    raise "Unable to get drive letter for disk #{vhd_path}: #{stderr}" unless stderr.empty? || drive_type.nil?
-    drive_type
-  end
-
-  private
-
-  def vm_get_properties(vm_name)
-    properties_script = <<-PROPERTIES_EOL
-Get-VMHardDiskDrive -VMName "#{vm_name}" | \
-  Format-Table -Property ControllerType,ControllerNumber,ControllerLocation -Autosize
-PROPERTIES_EOL
-
-    properties, stderr = @parser.parse_multiple_attribute_values(@winrm.run_powershell_script(properties_script))
-    raise "Error getting VHD(s) and Attributes for #{vm_name}: #{stderr}" unless stderr.empty?
-    properties
-  end
-
-  def vm_get_disks(vm_name, snapshot, check_snapshot)
-    if check_snapshot.nil?
-      vhd_script = <<-VHD_EOL
-Get-VMHardDiskDrive -VMName "#{vm_name}" | \
-  Format-Table -Property Path | out-string -Width 200
-VHD_EOL
-    else
-      snapshot = vm_name + "__EVM_SNAPSHOT" if snapshot.nil?
-      raise "Checkpoint #{snapshot} for VM #{vm_name} missing" if vm_get_checkpoint(vm_name, snapshot).nil?
-      vhd_script = <<-SNAP_EOL
-Get-VMSnapShot -VMName "#{vm_name}" -Name "#{snapshot}" |  Get-VMHardDiskDrive | \
-  Format-Table -Property Path | out-string -Width 200
-SNAP_EOL
-    end
-
-    vhds, stderr = @parser.parse_single_attribute_values(@winrm.run_powershell_script(vhd_script))
-    raise "Unable to obtain VHD Name(s) for #{vm_name}: #{stderr}" unless stderr.empty?
-    vhds
-  end
-end