manageiq-smartstate 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd6c8e7fc62f55e3496569ccfb9b7154401a3f1c
-  data.tar.gz: aa6b6c308e48258d4ce2f4a502907d1747332980
+  metadata.gz: 62cf3e30f6bab25afc33edb03fe30b6849f3ae29
+  data.tar.gz: caec40acfd2c105763fa1144faaf3b4d4f7710f0
 SHA512:
-  metadata.gz: e1ef8e9e1f61e45418d4fef638e4b021a0e5e80b3e6701af800f46b6f695d316cfc23ea3bc10526c623b781961d22a44fe7a8691ff76e33cb833b8d8503176da
-  data.tar.gz: 242e3b1c155fca702a7fc3987c169299bcd240fb2012adc87f6ea778d340f257ba80eceebf37e8919235f6d48ad9bfd2011f07af5172e3ef606700e009450e4a
+  metadata.gz: c0a520cf41df5a29c3494630d2d35c15deb4d453ca7fef571c4195426f218eff702da0db4e4483444ccccbf712d7f89b5e02de96b6fb5bda816107f491253dd5
+  data.tar.gz: 2c011d60ca5e37f0b80a10cf039eec69940675409101429dec54af3373763247c6297dbd581c6e25d66a37ffd9df917e81554b23f4b473bbb97a99d0e2461bf6

data/lib/disk/modules/VhdxDisk.rb

@@ -519,6 +519,7 @@ module VhdxDisk
   def parent_disk(path)
     @parent_ostruct                   = OpenStruct.new
     @parent_ostruct.fileName          = path
+    @parent_ostruct.scvmm             = @scvmm
     @parent_ostruct.driveType         = @scvmm.get_drivetype(path)
     @parent_ostruct.hyperv_connection = @hyperv_connection if @hyperv_connection
     parent                            = MiqDisk.getDisk(@parent_ostruct)

data/lib/fs/MiqFS/modules/Ext3.rb

@@ -269,7 +269,7 @@ module Ext3
     names.shift
 
     dir = ifs_getDirR(names, miqfs)
-    raise "Directory '#{p}' not found" if dir.nil?
+    $log.info("Directory '#{p}' not found") if dir.nil?
     dir
   end
 

data/lib/fs/MiqFS/modules/ReiserFS.rb

@@ -280,7 +280,7 @@ module ReiserFS
     names.shift
 
     dir = ifs_getDirR(names, miqfs)
-    raise "Directory '#{p}' not found" if dir.nil?
+    $log.info("Directory '#{p}' not found") if dir.nil?
     dir
   end
 

data/lib/fs/MiqFS/modules/XFS.rb

@@ -264,7 +264,7 @@ module XFS
     names.shift
 
     dir = ifs_getDirR(names, miqfs)
-    raise "Directory '#{p}' not found" if dir.nil?
+    $log.info("Directory '#{p}' not found") if dir.nil?
     dir
   end
 

data/lib/fs/ext3/superblock.rb

@@ -147,7 +147,7 @@ module Ext3
 
     # /////////////////////////////////////////////////////////////////////////
     # // initialize
-    attr_reader :numGroups, :fsId, :stream, :numBlocks, :numInodes, :fsId, :volName
+    attr_reader :numGroups, :fsId, :stream, :numBlocks, :numInodes, :volName
     attr_reader :sectorSize, :blockSize
 
     @@track_inodes = false
@@ -169,11 +169,10 @@ module Ext3
 
       # Grab some quick facts & make sure there's nothing wrong. Tight qualification.
       raise "Ext3::Superblock.initialize: Invalid signature=[#{@sb['signature']}]" if @sb['signature'] != SUPERBLOCK_SIG
-      state = @sb['fs_state']
-      raise "Ext3::Superblock.initialize: Invalid file system state" if state > FSS_END
-      if state != FSS_CLEAN
-        $log.warn("Ext3 file system has errors")        if $log && gotBit?(state, FSS_ERR)
-        $log.warn("Ext3 orphan inodes being recovered") if $log && gotBit?(state, FSS_ORPHAN_REC)
+      raise "Ext3::Superblock.initialize: Invalid file system state" if @sb['fs_state'] > FSS_END
+      if @sb['fs_state'] != FSS_CLEAN
+        $log.warn("Ext3 file system has errors")        if $log && gotBit?(@sb['fs_state'], FSS_ERR)
+        $log.warn("Ext3 orphan inodes being recovered") if $log && gotBit?(@sb['fs_state'], FSS_ORPHAN_REC)
       end
       raise "Ext3::Superblock.initialize: Invalid error handling method=[#{@sb['err_method']}]" if @sb['err_method'] > EHM_PANIC
       raise "Ext3::Superblock.initialize: Filesystem has extents (ext4)"  if gotBit?(@sb['incompat_flags'], ICF_EXTENTS)
@@ -198,7 +197,6 @@ module Ext3
       @numGroups += 1 if @lastGroupBlocks > 0
       @fsId = UUIDTools::UUID.parse_raw(@sb['fs_id'])
       @volName = @sb['vol_name']
-      @jrnlId = UUIDTools::UUID.parse_raw(@sb['jrnl_id'])
     end
 
     # ////////////////////////////////////////////////////////////////////////////
@@ -295,8 +293,6 @@ module Ext3
         if block == 0
           @block_cache[block] = MemoryBuffer.create(@blockSize)
         else
-          group, offset = blockNumToGroupNum(block)
-          gde = gdt[group]
           # raise "Block #{block} is not allocated" if (not gde.blockAllocBmp[offset] and not ignore_alloc)
 
           address = blockToAddress(block)  # This function will read the block into our cache
@@ -308,99 +304,11 @@ module Ext3
       @block_cache[block]
     end
 
-    def getFeatureStrings
-      out = "Compatible Feature Flags:\n"
-      cff = @sb['compat_flags']
-      out << "  CFF_PREALLOC_DIR_BLKS\n"  if gotBit?(cff, CFF_PREALLOC_DIR_BLKS)
-      out << "  CFF_AFS_SERVER_INODE\n"   if gotBit?(cff, CFF_AFS_SERVER_INODES)
-      out << "  CFF_JOURNAL\n"            if gotBit?(cff, CFF_JOURNAL)
-      out << "  CFF_EXTENDED_ATTRIBS\n"   if gotBit?(cff, CFF_EXTENDED_ATTRIBS)
-      out << "  CFF_BIG_PART\n"           if gotBit?(cff, CFF_BIG_PART)
-      out << "  CFF_HASH_INDEX\n"         if gotBit?(cff, CFF_HASH_INDEX)
-      extra = cff - (cff & CFF_FLAGS)
-      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
-      out << "Incompatible Feature Flags:\n"
-      icf = @sb['incompat_flags']
-      out << "  ICF_COMPRESSION\n"        if gotBit?(icf, ICF_COMPRESSION)
-      out << "  ICF_FILE_TYPE\n"          if gotBit?(icf, ICF_FILE_TYPE)
-      out << "  ICF_RECOVER_FS\n"         if gotBit?(icf, ICF_RECOVER_FS)
-      out << "  ICF_JOURNAL\n"            if gotBit?(icf, ICF_JOURNAL)
-      out << "  ICF_META_BG\n"            if gotBit?(icf, ICF_META_BG)
-      out << "  ICF_EXTENTS\n"            if gotBit?(icf, ICF_EXTENTS)
-      out << "  ICF_64BIT\n"              if gotBit?(icf, ICF_64BIT)
-      out << "  ICF_MMP\n"                if gotBit?(icf, ICF_MMP)
-      out << "  ICF_FLEX_BG\n"            if gotBit?(icf, ICF_FLEX_BG)
-      out << "  ICF_EA_INODE\n"           if gotBit?(icf, ICF_EA_INODE)
-      out << "  ICF_DIRDATA\n"            if gotBit?(icf, ICF_DIRDATA)
-      extra = icf - (icf & ICF_FLAGS)
-      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
-      out << "Read Only Feature Flags:\n"
-      rof = @sb['ro_flags']
-      out << "  ROF_SPARSE\n"             if gotBit?(rof, ROF_SPARSE)
-      out << "  ROF_LARGE_FILES\n"        if gotBit?(rof, ROF_LARGE_FILES)
-      out << "  ROF_BTREES\n"             if gotBit?(rof, ROF_BTREES)
-      extra = rof - (rof & ROF_FLAGS)
-      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
-      out
-    end
-
     # ////////////////////////////////////////////////////////////////////////////
     # // Utility functions.
 
     def gotBit?(field, bit)
       field & bit == bit
     end
-
-    # Dump object.
-    def dump
-      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
-      out << "Number of inodes      : #{@sb['num_inodes']}\n"
-      out << "Number of blocks      : #{@sb['num_blocks']}\n"
-      out << "Reserved blocks       : #{@sb['reserved_blocks']}\n"
-      out << "Unallocated blocks    : #{@sb['unallocated_blocks']}\n"
-      out << "Unallocated inodes    : #{@sb['unallocated_inodes']}\n"
-      out << "Block group 0         : #{@sb['block_group_zero']}\n"
-      out << "Block size            : #{@sb['block_size']} (#{@blockSize} bytes)\n"
-      out << "Fragment size         : #{@sb['fragment_size']} (#{fragmentSize} bytes)\n"
-      out << "Blocks per group      : #{@sb['blocks_in_group']} (#{blocksPerGroup} blocks per group)\n"
-      out << "Fragments per group   : #{@sb['fragments_in_group']} (#{fragmentsPerGroup} fragments per group)\n"
-      out << "Inodes per group      : #{@sb['inodes_in_group']} (#{inodesPerGroup} inodes per group)\n"
-      out << "Last mount time       : #{Time.at(@sb['last_mount_time'])}\n"
-      out << "Last write time       : #{Time.at(@sb['last_write_time'])}\n"
-      out << "Current mount count   : #{@sb['mount_count']}\n"
-      out << "Maximum mount count   : #{@sb['max_mount_count']}\n"
-      out << "Signature             : #{@sb['signature']}\n"
-      out << "File system state     : #{@sb['fs_state']}\n"
-      out << "Error hndling methd   : #{@sb['err_method']}\n"
-      out << "Minor version         : #{@sb['ver_minor']}\n"
-      out << "Last consistency check: #{Time.at(@sb['last_check_time'])}\n"
-      out << "Forced check interval : #{@sb['forced_check_int']} sec\n"
-      out << "Creator OS            : #{@sb['creator_os']}\n"
-      out << "Major version         : #{@sb['ver_major']}\n"
-      out << "UID can use res blocks: #{@sb['uid_res_blocks']}\n"
-      out << "GID can use res blocks: #{@sb['gid_res_blocks']}\n"
-      if isDynamic?
-        out << "First non-res inode   : #{@sb['first_inode']}\n"
-        out << "Size of inode         : #{@sb['inode_size']}\n"
-        out << "Block group of this SB: #{@sb['block_group']}\n"
-        out << "Compatible features   : 0x#{'%08x' % @sb['compat_flags']}\n"
-        out << "Incompatible features : 0x#{'%08x' % @sb['incompat_flags']}\n"
-        out << "Read Only features    : 0x#{'%08x' % @sb['ro_flags']}\n"
-        out << "File system id        : #{@fsId}\n"
-        out << "Volume name           : #{@sb['vol_name']}\n"
-        out << "Last mount path       : #{@sb['last_mnt_path']}\n"
-        out << "Algorithm usage bitmap: 0x#{'%08x' % @sb['algo_use_bmp']}\n"
-        out << "Blocks prealloc files : #{@sb['file_prealloc_blks']}\n"
-        out << "Blocks prealloc dirs  : #{@sb['dir_prealloc_blks']}\n"
-        out << "Journal id            : #{@jrnlId}\n"
-        out << "Journal inode         : #{@sb['jrnl_inode']}\n"
-        out << "Journal device        : #{@sb['jrnl_device']}\n"
-        out << "Orphan inode head     : #{@sb['orphan_head']}\n"
-      end
-      out << "Number of groups      : #{numGroups}\n"
-      out << "Free bytes            : #{freeBytes}\n"
-      out << getFeatureStrings
-      out
-    end
   end
 end # moule Ext3

data/lib/fs/ext4/superblock.rb

@@ -142,14 +142,13 @@ module Ext4
 
     # /////////////////////////////////////////////////////////////////////////
     # // initialize
-    attr_reader :numGroups, :fsId, :stream, :numBlocks, :numInodes, :fsId, :volName
-    attr_reader :sectorSize, :blockSize, :groupDescriptorSize
+    attr_reader :numGroups, :fsId, :stream, :numBlocks, :numInodes, :volName
+    attr_reader :sectorSize, :blockSize
 
     @@track_inodes = false
 
     def initialize(stream)
-      raise "Ext4::Superblock.initialize: Nil stream" if stream.nil?
-      @stream = stream
+      raise "Ext4::Superblock.initialize: Nil stream" if (@stream = stream).nil?
 
       # Seek, read & decode the superblock structure
       @stream.seek(SUPERBLOCK_OFFSET)
@@ -157,9 +156,8 @@ module Ext4
 
       # Grab some quick facts & make sure there's nothing wrong. Tight qualification.
       raise "Ext4::Superblock.initialize: Invalid signature=[#{@sb['signature']}]" if @sb['signature'] != SUPERBLOCK_SIG
-      state = @sb['fs_state']
-      raise "Ext4::Superblock.initialize: Invalid file system state" if state > FSS_END
-      if state != FSS_CLEAN
+      raise "Ext4::Superblock.initialize: Invalid file system state" if @sb['fs_state'] > FSS_END
+      if (state = @sb['fs_state']) != FSS_CLEAN
         $log.warn("Ext4 file system has errors")        if $log && gotBit?(state, FSS_ERR)
         $log.warn("Ext4 orphan inodes being recovered") if $log && gotBit?(state, FSS_ORPHAN_REC)
       end
@@ -185,7 +183,6 @@ module Ext4
       @numGroups += 1 if @lastGroupBlocks > 0
       @fsId = UUIDTools::UUID.parse_raw(@sb['fs_id'])
       @volName = @sb['vol_name']
-      @jrnlId = UUIDTools::UUID.parse_raw(@sb['jrnl_id'])
     end
 
     # ////////////////////////////////////////////////////////////////////////////
@@ -293,8 +290,6 @@ module Ext4
         if block == 0
           @block_cache[block] = MemoryBuffer.create(@blockSize)
         else
-          group, offset = blockNumToGroupNum(block)
-          gde = gdt[group]
           # raise "Block #{block} is not allocated" if (not gde.blockAllocBmp[offset] and not ignore_alloc)
 
           address = blockToAddress(block)  # This function will read the block into our cache
@@ -306,49 +301,6 @@ module Ext4
       @block_cache[block]
     end
 
-    def getFeatureStrings
-      out = "Compatible Feature Flags:\n"
-      cff = @sb['compat_flags']
-      out << "  CFF_PREALLOC_DIR_BLKS\n"  if gotBit?(cff, CFF_PREALLOC_DIR_BLKS)
-      out << "  CFF_AFS_SERVER_INODE\n"   if gotBit?(cff, CFF_AFS_SERVER_INODES)
-      out << "  CFF_JOURNAL\n"            if gotBit?(cff, CFF_JOURNAL)
-      out << "  CFF_EXTENDED_ATTRIBS\n"   if gotBit?(cff, CFF_EXTENDED_ATTRIBS)
-      out << "  CFF_BIG_PART\n"           if gotBit?(cff, CFF_BIG_PART)
-      out << "  CFF_HASH_INDEX\n"         if gotBit?(cff, CFF_HASH_INDEX)
-      extra = cff - (cff & CFF_FLAGS)
-      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
-
-      out << "Incompatible Feature Flags:\n"
-      icf = @sb['incompat_flags']
-      out << "  ICF_COMPRESSION\n"        if gotBit?(icf, ICF_COMPRESSION)
-      out << "  ICF_FILE_TYPE\n"          if gotBit?(icf, ICF_FILE_TYPE)
-      out << "  ICF_RECOVER_FS\n"         if gotBit?(icf, ICF_RECOVER_FS)
-      out << "  ICF_JOURNAL\n"            if gotBit?(icf, ICF_JOURNAL)
-      out << "  ICF_META_BG\n"            if gotBit?(icf, ICF_META_BG)
-      out << "  ICF_EXTENTS\n"            if gotBit?(icf, ICF_EXTENTS)
-      out << "  ICF_64BIT\n"              if gotBit?(icf, ICF_64BIT)
-      out << "  ICF_MMP\n"                if gotBit?(icf, ICF_MMP)
-      out << "  ICF_FLEX_BG\n"            if gotBit?(icf, ICF_FLEX_BG)
-      out << "  ICF_EA_INODE\n"           if gotBit?(icf, ICF_EA_INODE)
-      out << "  ICF_DIRDATA\n"            if gotBit?(icf, ICF_DIRDATA)
-      extra = icf - (icf & ICF_FLAGS)
-      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
-
-      out << "Read Only Feature Flags:\n"
-      rof = @sb['ro_flags']
-      out << "  ROF_SPARSE\n"             if gotBit?(rof, ROF_SPARSE)
-      out << "  ROF_LARGE_FILES\n"        if gotBit?(rof, ROF_LARGE_FILES)
-      out << "  ROF_BTREES\n"             if gotBit?(rof, ROF_BTREES)
-      out << "  ROF_HUGE_FILE\n"          if gotBit?(rof, ROF_HUGE_FILE)
-      out << "  ROF_GDT_CSUM\n"           if gotBit?(rof, ROF_GDT_CSUM)
-      out << "  ROF_DIR_NLINK\n"          if gotBit?(rof, ROF_DIR_NLINK)
-      out << "  ROF_EXTRA_ISIZE\n"        if gotBit?(rof, ROF_EXTRA_ISIZE)
-      extra = rof - (rof & ROF_FLAGS)
-      out << "  Extra Flags: 0x%08X\n" % extra if extra != 0
-
-      out
-    end
-
     # ////////////////////////////////////////////////////////////////////////////
     # // Utility functions.
 
@@ -357,56 +309,5 @@ module Ext4
     end
 
     # Dump object.
-    def dump
-      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
-      out << "Number of inodes      : #{@sb['num_inodes']}\n"
-      out << "Number of blocks      : #{@sb['num_blocks']}\n"
-      out << "Reserved blocks       : #{@sb['reserved_blocks']}\n"
-      out << "Unallocated blocks    : #{@sb['unallocated_blocks']}\n"
-      out << "Unallocated inodes    : #{@sb['unallocated_inodes']}\n"
-      out << "Block group 0         : #{@sb['block_group_zero']}\n"
-      out << "Block size            : #{@sb['block_size']} (#{@blockSize} bytes)\n"
-      out << "Fragment size         : #{@sb['fragment_size']} (#{fragmentSize} bytes)\n"
-      out << "Blocks per group      : #{@sb['blocks_in_group']} (#{blocksPerGroup} blocks per group)\n"
-      out << "Fragments per group   : #{@sb['fragments_in_group']} (#{fragmentsPerGroup} fragments per group)\n"
-      out << "Inodes per group      : #{@sb['inodes_in_group']} (#{inodesPerGroup} inodes per group)\n"
-      out << "Last mount time       : #{Time.at(@sb['last_mount_time'])}\n"
-      out << "Last write time       : #{Time.at(@sb['last_write_time'])}\n"
-      out << "Current mount count   : #{@sb['mount_count']}\n"
-      out << "Maximum mount count   : #{@sb['max_mount_count']}\n"
-      out << "Signature             : #{@sb['signature']}\n"
-      out << "File system state     : #{@sb['fs_state']}\n"
-      out << "Error hndling methd   : #{@sb['err_method']}\n"
-      out << "Minor version         : #{@sb['ver_minor']}\n"
-      out << "Last consistency check: #{Time.at(@sb['last_check_time'])}\n"
-      out << "Forced check interval : #{@sb['forced_check_int']} sec\n"
-      out << "Creator OS            : #{@sb['creator_os']}\n"
-      out << "Major version         : #{@sb['ver_major']}\n"
-      out << "UID can use res blocks: #{@sb['uid_res_blocks']}\n"
-      out << "GID can use res blocks: #{@sb['gid_res_blocks']}\n"
-      out << "Group descriptor size : #{@sb['group_desc_size']}\n"
-      if isDynamic?
-        out << "First non-res inode   : #{@sb['first_inode']}\n"
-        out << "Size of inode         : #{@sb['inode_size']}\n"
-        out << "Block group of this SB: #{@sb['block_group']}\n"
-        out << "Compatible features   : 0x#{'%08x' % @sb['compat_flags']}\n"
-        out << "Incompatible features : 0x#{'%08x' % @sb['incompat_flags']}\n"
-        out << "Read Only features    : 0x#{'%08x' % @sb['ro_flags']}\n"
-        out << "File system id        : #{@fsId}\n"
-        out << "Volume name           : #{@sb['vol_name']}\n"
-        out << "Last mount path       : #{@sb['last_mnt_path']}\n"
-        out << "Algorithm usage bitmap: 0x#{'%08x' % @sb['algo_use_bmp']}\n"
-        out << "Blocks prealloc files : #{@sb['file_prealloc_blks']}\n"
-        out << "Blocks prealloc dirs  : #{@sb['dir_prealloc_blks']}\n"
-        out << "Journal id            : #{@jrnlId}\n"
-        out << "Journal inode         : #{@sb['jrnl_inode']}\n"
-        out << "Journal device        : #{@sb['jrnl_device']}\n"
-        out << "Orphan inode head     : #{@sb['orphan_head']}\n"
-      end
-      out << "Number of groups      : #{numGroups}\n"
-      out << "Free bytes            : #{freeBytes}\n"
-      out << getFeatureStrings
-      out
-    end
   end
 end # moule Ext4

data/lib/fs/modules/LinuxMount.rb

@@ -9,84 +9,165 @@ module LinuxMount
     @rootFS = MiqFS.getFS(@rootVolume)
     raise "LinuxMount: could not mount root volume" unless @rootFS
 
+    assign_device_letters
+    fs_spec_hash = build_fstab_spec
+    build_os_names
+    build_mount_point_tree(fs_spec_hash)
+  end
+
+  #
+  # Given a path to a file, return true if it's a symbolic link.
+  # Otherwise, return false.
+  #
+  def fileSymLink?(p)
+    #
+    # We can't just expand the links in the whole path,
+    # because then, the target file will no longer be a link.
+    # So, we expand the path to the target file, then open
+    # the target file through that path to obtain the link data.
+    #
+    np = normalizePath(p)
+    d = File.dirname(np)
+    f = File.basename(np)
+
+    # Expand the path to the target file.
+    exp_dir = expandLinks(d)
+
+    # Get the file system where the target file resides, and it's local path.
+    fs, lp = getFsPathBase(File.join(exp_dir, f))
+    fs.fileSymLink?(lp)
+  end
+
+  #
+  # Given a path to a symbolic link, return the full
+  # path to where the link points.
+  #
+  def getLinkPath(p)
+    #
+    # We can't just expand the links in the whole path,
+    # because then, the target file will no longer be a link.
+    # So, we expand the path to the target file, then open
+    # the target file through that path to obtain the link data.
+    #
+    np = normalizePath(p)
+    d = File.dirname(np)
+    f = File.basename(np)
+
+    # Expand the path to the target file.
+    exp_dir = expandLinks(d)
+
+    # Get the file system where the target file resides, and it's local path.
+    fs, lp = getFsPathBase(File.join(exp_dir, f))
+    # Read the link data from the file, through its file system.
+    sp = getSymLink(fs, lp)
+    # Construct and return the full path to the link target.
+    return(sp) if sp[0, 1] == '/'
+    normalizePath(File.join(exp_dir, sp))
+  end
+
+  private
+
+  def assign_device_letters
     #
     # Assign device letters to all ide and scsi devices,
     # even if they're not visible volumes. We need to do
     # this to assign the proper device names to visible
     # devices.
     #
-    sdLetter  = 'a'
-    ideMap    = {"ide0:0" => "a", "ide0:1" => "b", "ide1:0" => "c", "ide1:1" => "d"}
+    sdLetter = 'a'
+    ideMap   = {"ide0:0" => "a", "ide0:1" => "b", "ide1:0" => "c", "ide1:1" => "d"}
     @devHash = {}
     @vmConfig.getAllDiskKeys.each do |dk|
       if dk =~ /^ide.*$/
         @devHash[dk] = "/dev/hd" + ideMap[dk]
-        $log.debug "LinuxMount: devHash[#{dk}] = /dev/hd#{ideMap[dk]}" if $log.debug?
       elsif dk =~ /^scsi.*$/
         @devHash[dk] = "/dev/sd" + sdLetter
-        $log.debug "LinuxMount: devHash[#{dk}] = /dev/sd#{sdLetter}" if $log.debug?
         sdLetter.succ!
       end
+      $log.debug("LinuxMount: devHash[#{dk}] = #{devHash[dk]}") if $log.debug
     end
+  end
 
+  def build_fstab_spec
     #
     # Build hash for fstab fs_spec look up.
     #
-    fsSpecHash = {}
+    fs_spec_hash = {}
     @volumes.each do |v|
-      $log.debug "LinuxMount: Volume = #{v.dInfo.localDev} (#{v.dInfo.hardwareId}, partition = #{v.partNum})" if $log.debug?
+      $log.debug("LinuxMount: Volume = #{v.dInfo.localDev} (#{v.dInfo.hardwareId}, partition = #{v.partNum})") if $log.debug
       if v == @rootVolume
         fs = @rootFS
-      else
-        unless (fs = MiqFS.getFS(v))
-          $log.debug "LinuxMount: No filesystem on Volume: #{v.dInfo.localDev}, partition = #{v.partNum}" if $log.debug?
-          next
-        end
+      else 
+        (fs = MiqFS.getFS(v)) || next
       end
       @allFileSystems << fs
 
-      #
-      # Specific file systems can be identified by fs UUID
-      # or file system volume label.
-      #
-      unless fs.volName.empty?
-        $log.debug "LinuxMount: adding \"LABEL=#{fs.volName}\" to fsSpecHash" if $log.debug?
-        fsSpecHash["LABEL=#{fs.volName}"]  = fs
-        $log.debug "LinuxMount: adding \"LABEL=/#{fs.volName}\" to fsSpecHash" if $log.debug?
-        fsSpecHash["LABEL=/#{fs.volName}"] = fs
-      end
-      unless fs.fsId.empty?
-        $log.debug "LinuxMount: adding \"UUID=#{fs.fsId}\" to fsSpecHash" if $log.debug?
-        fsSpecHash["UUID=#{fs.fsId}"] = fs
-      end
+      fs_spec_hash.merge!(add_fstab_entries(fs, v))
+    end
+    fs_spec_hash
+  end
 
-      #
-      # Logical volumes can be identified by their lv specific
-      # entries under /dev.
-      #
-      if v.dInfo.lvObj
-        lvName = v.dInfo.lvObj.lvName
-        vgName = v.dInfo.lvObj.vgObj.vgName
-        fsSpecHash["/dev/#{vgName}/#{lvName}"] = fs
-        fsSpecHash["/dev/mapper/#{vgName.gsub('-','--')}-#{lvName.gsub('-','--')}"] = fs
-        fsSpecHash["UUID=#{v.dInfo.lvObj.lvId}"] = fs
-        $log.debug "LinuxMount: Volume = #{v.dInfo.localDev}, partition = #{v.partNum} is a logical volume" if $log.debug?
-        next
-      end
+  def add_fstab_entries(fs, v)
+    fs_spec_hash = add_fstab_fs_entries(fs)
 
-      #
-      # Physical volumes are identified by entries under
-      # /dev based on OS hardware scan.
-      # TODO: support physical volume UUIDs
-      #
-      $log.debug "LinuxMount: v.dInfo.hardwareId = #{v.dInfo.hardwareId}" if $log.debug?
-      if v.partNum == 0
-        fsSpecHash[@devHash[v.dInfo.hardwareId]] = fs
-      else
-        fsSpecHash[@devHash[v.dInfo.hardwareId] + v.partNum.to_s] = fs
-      end
+    if v.dInfo.lvObj
+      fs_spec_hash.merge!(add_fstab_logical_entries(fs, v))
+    else
+      fs_spec_hash.merge!(add_fstab_physical_entry(fs, v))
+    end
+    fs_spec_hash
+  end
+
+  def add_fstab_fs_entries(fs)
+    #
+    # Specific file systems can be identified by fs UUID
+    # or file system volume label.
+    #
+    fs_spec_fs_hash = {}
+    unless fs.volName.empty?
+      $log.debug("LinuxMount: adding \"LABEL=#{fs.volName}\" & \"LABEL=/#{fs.volName}\" to hash") if $log.debug
+      fs_spec_fs_hash["LABEL=#{fs.volName}"]  = fs
+      fs_spec_fs_hash["LABEL=/#{fs.volName}"] = fs
+    end
+    unless fs.fsId.empty?
+      $log.debug("LinuxMount: adding \"UUID=#{fs.fsId}\" to fs_spec_hash") if $log.debug
+      fs_spec_fs_hash["UUID=#{fs.fsId}"] = fs
+    end
+    fs_spec_fs_hash
+  end
+
+  def add_fstab_logical_entries(fs, v)
+    #
+    # Logical volumes can be identified by their lv specific
+    # entries under /dev.
+    #
+    lv_name = v.dInfo.lvObj.lvName
+    vg_name = v.dInfo.lvObj.vgObj.vgName
+    fs_spec_logical_hash = {}
+    fs_spec_logical_hash["/dev/#{vg_name}/#{lv_name}"] = fs
+    fs_spec_logical_hash["/dev/mapper/#{vg_name.gsub('-', '--')}-#{lv_name.gsub('-', '--')}"] = fs
+    fs_spec_logical_hash["UUID=#{v.dInfo.lvObj.lvId}"] = fs
+    $log.debug("LinuxMount: Volume = #{v.dInfo.localDev}, partition = #{v.partNum} is a logical volume") if $log.debug
+    fs_spec_logical_hash
+  end
+
+  def add_fstab_physical_entry(fs, v)
+    #
+    # Physical volumes are identified by entries under
+    # /dev based on OS hardware scan.
+    # TODO: support physical volume UUIDs
+    #
+    fs_spec_physical_hash = {}
+    $log.debug("LinuxMount: v.dInfo.hardwareId = #{v.dInfo.hardwareId}") if $log.debug
+    if v.partNum.zero?
+      fs_spec_physical_hash[@devHash[v.dInfo.hardwareId]] = fs
+    else
+      fs_spec_physical_hash[@devHash[v.dInfo.hardwareId] + v.partNum.to_s] = fs
     end
+    fs_spec_physical_hash
+  end
 
+  def build_os_names
     #
     # Assign OS-specific names to all physical volumes.
     #
@@ -99,79 +180,32 @@ module LinuxMount
       end
       @osNames[v.dInfo.hardwareId + ':' + v.partNum.to_s] = @devHash[v.dInfo.hardwareId] + v.partNum.to_s
     end
+  end
 
+  def build_mount_point_tree(fs_spec_hash)
     #
     # Build a tree of file systems and their associated mont points.
     #
     root_added = false
     @mountPoints = {}
-    $log.debug "LinuxMount: processing #{FSTAB_FILE_NAME}" if $log.debug?
+    $log.debug("LinuxMount: processing #{FSTAB_FILE_NAME}") if $log.debug
     @rootFS.fileOpen(FSTAB_FILE_NAME, &:read).each_line do |fstl|
-      $log.debug "LinuxMount: fstab line: #{fstl}" if $log.debug?
-      next if fstl =~ /^#.*$/ || fstl =~ /^\s*$/
-      fsSpec, mtPoint = fstl.split(/\s+/)
-      $log.debug "LinuxMount: fsSpec: #{fsSpec}, mtPoint: #{mtPoint}" if $log.debug?
-      next if fsSpec == "none" || mtPoint == "swap"
-      next unless (fs = fsSpecHash[fsSpec])
-      $log.debug "LinuxMount: Adding fsSpec: #{fsSpec}, mtPoint: #{mtPoint}" if $log.debug?
-      addMountPoint(mtPoint, fs, fsSpec)
-      root_added = true if mtPoint == '/'
+      $log.debug("LinuxMount: fstab line: #{fstl}") if $log.debug
+      root_added = true if do_fstab_line(fstl, fs_spec_hash) == '/'
     end
     saveFs(@rootFS, "/", "ROOT") unless root_added
-  end # def fs_init
-
-  #
-  # Given a path to a file, return true if it's a symbolic link.
-  # Otherwise, return false.
-  #
-  def fileSymLink?(p)
-    #
-    # We can't just expand the links in the whole path,
-    # because then, the target file will no longer be a link.
-    # So, we expand the path to the target file, then open
-    # the target file through that path to obtain the link data.
-    #
-    np = normalizePath(p)
-    d = File.dirname(np)
-    f = File.basename(np)
-
-    # Expand the path to the target file.
-    exp_dir = expandLinks(d)
-
-    # Get the file system where the target file resides, and it's local path.
-    fs, lp = getFsPathBase(File.join(exp_dir, f))
-    (fs.fileSymLink?(lp))
   end
 
-  #
-  # Given a path to a symbolic link, return the full
-  # path to where the link points.
-  #
-  def getLinkPath(p)
-    #
-    # We can't just expand the links in the whole path,
-    # because then, the target file will no longer be a link.
-    # So, we expand the path to the target file, then open
-    # the target file through that path to obtain the link data.
-    #
-    np = normalizePath(p)
-    d = File.dirname(np)
-    f = File.basename(np)
-
-    # Expand the path to the target file.
-    exp_dir = expandLinks(d)
-
-    # Get the file system where the target file resides, and it's local path.
-    fs, lp = getFsPathBase(File.join(exp_dir, f))
-    # Read the link data from the file, through its file system.
-    sp = getSymLink(fs, lp)
-    # Construct and return the full path to the link target.
-    return(sp) if sp[0, 1] == '/'
-    (normalizePath(File.join(exp_dir, sp)))
+  def do_fstab_line(fstab_line, fs_spec_hash)
+    return if fstab_line =~ /^#.*$/ || fstab_line =~ /^\s*$/
+    fs_spec, mt_point = fstab_line.strip.split(/\s+/)
+    return if fs_spec == "none" || mt_point == "swap"
+    return unless (fs = fs_spec_hash[fs_spec])
+    $log.debug("LinuxMount: Adding fs_spec: #{fs_spec}, mt_point: #{mt_point}") if $log.debug
+    addMountPoint(mt_point, fs, fs_spec)
+    mt_point
   end
 
-  private
-
   def normalizePath(p)
     # When running on windows, File.expand_path will add a drive letter.
     # Remove it if it's there.
@@ -221,7 +255,7 @@ module LinuxMount
       localPath = normalizePath(path)
     end
 
-    p = getFsPathBase(expandLinks(localPath))
+    getFsPathBase(expandLinks(localPath))
     # getFsPathBase(path)
   end
 

data/lib/manageiq/smartstate/version.rb

@@ -1,5 +1,5 @@
 module ManageIQ
   module Smartstate
-    VERSION = "0.2.10".freeze
+    VERSION = "0.2.11".freeze
   end
 end

data/lib/metadata/linux/LinuxSystemd.rb

@@ -55,6 +55,11 @@ module MiqLinux
     def parse_service(file)
       debug "Parsing service unit: #{file}"
 
+      if duplicated_link?(file)
+        debug("#{file} is a soft link, skip to parse.")
+        return nil
+      end
+
       unit        = @fs.fileBasename(file)
       name        = unit.gsub(".service", "")
       inif        = ini(file)
@@ -92,6 +97,11 @@ module MiqLinux
     def parse_target(file)
       debug "Parsing target unit: #{file}"
 
+      if duplicated_link?(file)
+        debug("#{file} is a soft link, skip to parse.")
+        return nil
+      end
+
       unit = @fs.fileBasename(file)
       name = unit.gsub(".target", "")
       inif = ini(file)
@@ -119,6 +129,10 @@ module MiqLinux
       end
     end
 
+    def duplicated_link?(file)
+      existing_dirs.any? { |dir| @fs.getLinkPath(file).start_with?("#{dir}/") } if @fs.fileSymLink?(file)
+    end
+
     def debug(msg)
       $log.debug msg if $log
     end

data/lib/metadata/util/win32/Win32Software.rb

@@ -6,12 +6,6 @@ module MiqWin32
   class Software
     attr_reader :applications, :patches, :product_keys
 
-    PRODUCT_KEY_MAPPING = [
-      'DigitalProductId', :product_key,
-      'ProductName', :name,
-      #     'ProductId', 'version',
-    ]
-
     PRODUCTS_MAPPING = [
       'DisplayName', :name,
       'Publisher', :vendor,
@@ -58,11 +52,30 @@ module MiqWin32
     ]
 
     def initialize(_c, fs)
-      @applications = []
-      @patches = []
-      @product_keys = {}
-      @patch_install_dates = {}
+      @patches = @applications = []
+      @patch_install_dates = @product_keys = {}
+
+      reg_doc = initialize_registry_doc(fs)
+
+      registry_applications(reg_doc)
+      registry_patches(reg_doc)
+    end
+
+    #     # Process application images
+    #     e.find_each("./descendant::image") { |i| nh[:image_md5] = i.attributes['md5']; validate_image(i, nh)}
+    #
+    #     def self.validate_image(imageNode, nh)
+    #       #logger.warn("MIQ(applications-add_elements): Checking application image [#{nh.inspect}] -- [#{imageNode.to_s}]")
+    #       x = ApplicationImage.find_by_md5(imageNode.attributes['md5'])
+    #       if x
+    #         #logger.warn("MIQ(applications-add_elements): Application image     found [#{imageNode.attributes['md5']}]")
+    #       else
+    #         #logger.warn("MIQ(applications-add_elements): Application image NOT found [#{imageNode.attributes['md5']}]")
+    #         ApplicationImage.create({:md5=>imageNode.attributes['md5'], :name=>nh['name'], :vendor=>nh['vendor'], :version=>nh['version']})
+    #       end
+    #     end
 
+    def initialize_registry_doc(fs)
       regHnd = RemoteRegistry.new(fs, true)
       #     reg_doc = regHnd.loadHive("software", ["Microsoft"])
       reg_doc = regHnd.loadHive('software',
@@ -80,160 +93,144 @@ module MiqWin32
       regHnd.close
 
       @product_keys = collectProductKeys(@digital_product_keys)
+      reg_doc
+    end
 
+    def registry_applications(registry_doc)
       # Get the applications
-      reg_node = MIQRexml.findRegElement("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData", reg_doc.root)
-      if reg_node
-        reg_node.each_element_with_attribute(:keyname) do |users|
-          users.each_element_with_attribute(:keyname) do |components|
-            if components.attributes[:keyname].downcase == "products"
-              components.each_element_with_attribute(:keyname) do |products|
-                attrs = XmlFind.decode(products, PRODUCTS_MAPPING)
-                attrs.merge!(:typename => "win32_product", :product_key => @product_keys[attrs[:name]])
-                clean_up_path(attrs)
-                @applications << attrs
-              end
-            end
-          end
-        end
-      end
-
+      reg_node = MIQRexml.findRegElement("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData", registry_doc.root)
+      registry_applications_user_data(reg_node) if reg_node
       ["HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\App Paths",
        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths"].each do |reg_path|
-        reg_node = MIQRexml.findRegElement(reg_path, reg_doc.root)
-        if reg_node
-          postProcessApps(reg_node, fs)
-          reg_node.each_element_with_attribute(:keyname) do |e|
-            attrs = XmlFind.decode(e, APP_PATHS_MAPPING)
-            next if attrs[:name].nil?
-            attrs.merge!(:typename => "app_path", :product_key => @product_keys[attrs[:name]])
-            clean_up_path(attrs)
-            @applications << attrs unless isDupApp?(attrs)
-          end
-        end
+        registry_applications_app_paths(registry_doc, reg_path)
       end
-
       ["HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall",
        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall"].each do |reg_path|
-        reg_node = MIQRexml.findRegElement(reg_path, reg_doc.root)
-        if reg_node
-          reg_node.each_element_with_attribute(:keyname) do |e|
-            attrs = XmlFind.decode(e, UNINSTALL_MAPPING)
-            next if attrs[:name].nil?
-            if ["security update", "update"].include?(attrs.delete(:release_type).to_s.downcase)
-              @patch_install_dates[e.attributes[:keyname]] = Time.parse(attrs[:installed_on]) unless attrs[:installed_on].nil?
-              next
-            else
-              attrs.delete(:installed_on)
-            end
-            attrs.merge!(:typename => "uninstall", :product_key => @product_keys[attrs[:name]])
-            @applications << attrs unless isDupApp?(attrs)
+        reg_node = MIQRexml.findRegElement(reg_path, registry_doc.root)
+        reg_node&.each_element_with_attribute(:keyname) do |e|
+          registry_applications_uninstall(e)
+        end
+      end
+    end
+
+    def registry_applications_user_data(reg_node)
+      reg_node.each_element_with_attribute(:keyname) do |users|
+        users.each_element_with_attribute(:keyname) do |components|
+          next unless components.attributes[:keyname].downcase == "products"
+          components.each_element_with_attribute(:keyname) do |products|
+            add_applications(PRODUCTS_MAPPING, "win32_product", products)
           end
         end
       end
+    end
 
-      # Get the patches (Win2000, Win2003, WinXP)
-      reg_node = MIQRexml.findRegElement("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix", reg_doc.root)
-      reg_node&.each_element_with_attribute(:keyname) do |e|
-        attrs = XmlFind.decode(e, HOTFIX_MAPPING)
+    def registry_applications_app_paths(registry_doc, registry_path)
+      return unless (reg_node = MIQRexml.findRegElement(registry_path, registry_doc.root))
+      postProcessApps(reg_node, fs)
+      reg_node.each_element_with_attribute(:keyname) do |e|
+        add_applications(APP_PATHS_MAPPING, "app_path", e)
+      end
+    end
 
-        # Check both descriptions and take the first one with a value
-        attrs.delete(:description2) if attrs[:description] || attrs[:description2].blank?
-        attrs[:description] = attrs.delete(:description2) if attrs[:description2]
+    def add_applications(mapping, type_name, element)
+      return if (attrs = XmlFind.decode(element, mapping))[:name].nil?
+      attrs[:typename] = type_name; attrs[:product_key] = @product_keys[attrs[:name]]
+      clean_up_path(attrs)
+      @applications << attrs unless isDupApp?(attrs)
+    end
 
-        attrs.merge!(:name => e.attributes[:keyname], :vendor => "Microsoft Corporation", :installed_on => @patch_install_dates[e.attributes[:keyname]]) unless e.attributes.nil? || e.attributes[:keyname].nil?
-        @patches << attrs
+    def registry_applications_uninstall(element)
+      return if (attrs = XmlFind.decode(element, UNINSTALL_MAPPING))[:name].nil?
+      if ["security update", "update"].include?(attrs.delete(:release_type).to_s.downcase)
+        @patch_install_dates[e.attributes[:keyname]] = Time.parse.getlocal(attrs[:installed_on]) unless attrs[:installed_on].nil?
+        return
+      else
+        attrs.delete(:installed_on)
       end
+      attrs[:typename] = "uninstall"; attrs[:product_key] = @product_keys[attrs[:name]]
+      @applications << attrs unless isDupApp?(attrs)
+    end
 
+    def registry_patches(registry_doc)
+      # Get the patches (Win2000, Win2003, WinXP)
+      reg_node = MIQRexml.findRegElement("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix", registry_doc.root)
+      reg_node&.each_element_with_attribute(:keyname) do |e|
+        registry_patches_hotfixes(e)
+      end
       # Get the patches (Vista, Win2008, Windows 7)
-      reg_node = MIQRexml.findRegElement("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Component Based Servicing\\Packages", reg_doc.root)
-      if reg_node
-        hotfix = {}
-        reg_node.each_element do |e|
-          next if e.attributes.nil? || e.attributes[:keyname].nil?
-          if e.attributes[:keyname][0, 8] == 'Package_'
-            # Expected pattern: Package_for_KBxxx_RTM~xxxx
-            
-            # Get the hotfix id (KB #) out of the keyname
-            package = e.attributes[:keyname].split("_")
-            
-            # If the package identifier starts with KB, use this
-            # otherwise grab the ID from the end of the string (if it's long enough)
-            hotfix_id = nil
-            if (package[2][0, 2] == 'KB')
-              hotfix_id = package[2]
-            elsif package.size >= 4
-              hotfix_id = package[3]
-            else
-              # Unknown package ID pattern, print this out
-              str = ''
-              e.write(str)
-              $log.warn "Win32Software::initialize - Can't determine patch element's hotfix id: #{str}"
-            end
-            # don't add this package if the ID is nil
-            next if hotfix_id.nil?
-            
-            hotfix_id = hotfix_id.split('~')[0]
-
-            unless hotfix.key?(hotfix_id)
-              attrs = XmlFind.decode(e, HOTFIX_MAPPING_VISTA)
-              install_time = wtime2time(attrs[:install_time_high], attrs[:install_time_low])
-              @patches << {:name => hotfix_id, :vendor => "Microsoft Corporation", :installed_on => install_time, :installed => 1}
-              hotfix[hotfix_id] = true
-            end
-          end
-        end
+      reg_node = MIQRexml.findRegElement("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Component Based Servicing\\Packages", registry_doc.root)
+      hotfix = {}
+      reg_node&.each_element do |e|
+        registry_patches_packages(hotfix, e)
       end
     end
 
-    #     # Process application images
-    #     e.find_each("./descendant::image") { |i| nh[:image_md5] = i.attributes['md5']; validate_image(i, nh)}
-    #
-    #     def self.validate_image(imageNode, nh)
-    #       #logger.warn("MIQ(applications-add_elements): Checking application image [#{nh.inspect}] -- [#{imageNode.to_s}]")
-    #       x = ApplicationImage.find_by_md5(imageNode.attributes['md5'])
-    #       if x
-    #         #logger.warn("MIQ(applications-add_elements): Application image     found [#{imageNode.attributes['md5']}]")
-    #       else
-    #         #logger.warn("MIQ(applications-add_elements): Application image NOT found [#{imageNode.attributes['md5']}]")
-    #         ApplicationImage.create({:md5=>imageNode.attributes['md5'], :name=>nh['name'], :vendor=>nh['vendor'], :version=>nh['version']})
-    #       end
-    #     end
+    def registry_patches_hotfixes(element)
+      attrs = XmlFind.decode(element, HOTFIX_MAPPING)
+      # Check both descriptions and take the first one with a value
+      attrs.delete(:description2) if attrs[:description] || attrs[:description2].blank?
+      attrs[:description] = attrs.delete(:description2) if attrs[:description2]
 
-    def to_xml(doc = nil)
-      doc = MiqXml.createDoc(nil) unless doc
-      applicationsToXml(doc)
-      patchesToXml(doc)
-      doc
+      attrs.merge!(:name => element.attributes[:keyname], :vendor => "Microsoft Corporation", :installed_on => @patch_install_dates[element.attributes[:keyname]]) unless element.attributes.nil? || element.attributes[:keyname].nil?
+      @patches << attrs
     end
 
-    def applicationsToXml(doc = nil)
-      doc = MiqXml.createDoc(nil) unless doc
-      unless @applications.empty?
-        node = doc.add_element("applications")
-        @applications.each { |a| node.add_element("application", XmlHelpers.stringify_keys(a)) }
+    def registry_patches_packages(hotfix, element)
+      return if element.attributes.nil? || element.attributes[:keyname].nil?
+      if element.attributes[:keyname][0, 8] == 'Package_'
+        # don't add this package if the ID is nil
+        return if (hotfix_id = hotfix_id(e)).nil?
+
+        hotfix[hotfix_id] ||=
+          begin
+            attrs = XmlFind.decode(element, HOTFIX_MAPPING_VISTA)
+            install_time = wtime2time(attrs[:install_time_high], attrs[:install_time_low])
+            @patches << {:name => hotfix_id, :vendor => "Microsoft Corporation", :installed_on => install_time, :installed => 1}
+            true
+          end
       end
-      doc
     end
 
-    def patchesToXml(doc = nil)
-      doc = MiqXml.createDoc(nil) unless doc
-      unless @patches.empty?
-        node = doc.add_element("patches")
-        @patches.each { |p| node.add_element("patch", XmlHelpers.stringify_keys(p)) }
+    def hotfix_id(element)
+      # Expected pattern: Package_for_KBxxx_RTM~xxxx
+      # Get the hotfix id (KB #) out of the keyname
+      package = element.attributes[:keyname].split("_")
+      # If the package identifier starts with KB, use this
+      # otherwise grab the ID from the end of the string (if it's long enough)
+      if package[2][0, 2] == 'KB'
+        hotfix_id = package[2]
+      elsif package.size >= 4
+        hotfix_id = package[3]
+      else
+        # Unknown package ID pattern, print this out
+        str = ''
+        element.write(str)
+        $log.warn("Win32Software::initialize - Can't determine patch element's hotfix id: #{str}")
       end
+      hotfix_id.split('~')[0] unless hotfix_id.nil?
+    end
+
+    def to_xml(doc = nil)
+      doc ||= MiqXml.createDoc(nil)
+      element_to_xml(doc, @applications, "applications", "application")
+      element_to_xml(doc, @patches, "patches", "patch")
       doc
     end
 
-    def isDupApp?(attrs)
-      findDupApp(attrs) ? true : false
+    def element_to_xml(doc = nil, software_type, doc_element, node_element)
+      doc ||= MiqXml.createDoc(nil)
+      return doc if software_type.empty?
+      node = doc.add_element(doc_element)
+      software_type.each { |a| node.add_element(node_element, XmlHelpers.stringify_keys(a)) }
+      doc
     end
 
-    def findDupApp(attrs)
+    def isDupApp?(attrs)
+      clean_up_path(attrs)
       @applications.each do |app|
-        return app if app[:name] == attrs[:name]
+        return true if app[:name] == attrs[:name]
       end
-      nil
+      false
     end
 
     def clean_up_path(attrs)
@@ -264,7 +261,6 @@ module MiqWin32
             next if appNode.text.nil?
             # st = Time.now
 
-            fh = nil
             fileName = appNode.text
             fileName.tr!("\\", "/")
             fileName = fileName[1..-2] if fileName[0, 1] == "\"" && fileName[-1, 1] == "\""
@@ -316,8 +312,7 @@ module MiqWin32
     def wtime2time(high_time, low_time)
       th = [high_time.to_i].pack('L').unpack('L')[0] << 32
       tl = [low_time.to_i].pack('L').unpack('L')[0]
-      time_int = ((th + tl) - 116444736000000000) / 10000000
-      return nil if time_int < 0
+      return nil if (time_int = ((th + tl) - 116444736000000000) / 10000000) < 0
       Time.at(time_int).getutc rescue nil
     end
   end # Class Software

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: manageiq-smartstate
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
 platform: ruby
 authors:
 - ManageIQ Developers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-02 00:00:00.000000000 Z
+date: 2018-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: azure-armrest