manageiq-smartstate 0.1.0

data/lib/metadata/linux/LinuxSystemd.rb

@@ -0,0 +1,130 @@
+require 'util/miq-xml'
+
+# iniparse needed to handle duplicate options (inifile will overwrite)
+require 'iniparse'
+
+module MiqLinux
+  class Systemd
+    SYSTEM_DIRS = ['/etc/systemd/system', '/usr/lib/systemd/system']
+    USER_DIRS   = ['/etc/systemd/user',   '/usr/lib/systemd/user']
+    ALL_DIRS    = SYSTEM_DIRS + USER_DIRS
+
+    def self.detected?(fs)
+      ALL_DIRS.any? { |dir| fs.fileExists?(dir) }
+    end
+
+    def initialize(fs)
+      @fs = fs
+      parse_systemd
+    end
+
+    def toXml(doc)
+      @services.each do |service|
+        doc.add_element("service", service_xml(service))
+        # service_targets_xml(service).each { |tx| node.add_element("target", tx) }
+      end
+    end
+
+    private
+
+    def parse_systemd
+      @services = files('.service').collect { |sf| parse_service(sf) }.compact
+      @targets  = files('.target').collect  { |tf| parse_target(tf)  }.compact
+    end
+
+    def files(unit_extension)
+      existing_dirs.flat_map do |dir|
+        dir_files = []
+        @fs.dirForeach(dir) do |unit|
+          dir_files << File.join(dir, unit) if @fs.fileExtname(unit) == unit_extension
+        end
+        dir_files
+      end
+    end
+
+    def existing_dirs
+      ALL_DIRS.select { |dir| @fs.fileExists?(dir) }
+    end
+
+    def ini(file)
+      fdata = nil
+      @fs.fileOpen(file) { |fo| fdata = fo.read }
+      IniParse.parse(fdata)
+    end
+
+    def parse_service(file)
+      debug "Parsing service unit: #{file}"
+
+      unit        = @fs.fileBasename(file)
+      name        = unit.gsub(".service", "")
+      inif        = ini(file)
+      desc        = parse_description(inif)
+      wanted_by   = parse_wanted(inif)
+      required_by = parse_required(inif)
+
+      {:unit        => unit,
+       :name        => name,
+       :path        => file,
+       :description => desc,
+       :wanted_by   => wanted_by,
+       :required_by => required_by}
+
+    rescue
+      warn "Error parsing: #{file}"
+      nil	      # make sure no intermediate result is returned!
+    end
+
+    def parse_description(inif)
+      return nil unless inif.has_section?('Unit') && inif['Unit'].has_option?('Description')
+      inif['Unit']['Description']
+    end
+
+    def parse_wanted(inif)
+      return [] unless inif.has_section?('Install') && inif['Install'].has_option?('WantedBy')
+      [inif['Install']['WantedBy']].flatten.collect(&:split).flatten
+    end
+
+    def parse_required(inif)
+      return [] unless inif.has_section?('Install') && inif['Install'].has_option?('RequiredBy')
+      [inif['Install']['RequiredBy']].flatten.collect(&:split).flatten
+    end
+
+    def parse_target(file)
+      debug "Parsing target unit: #{file}"
+
+      unit = @fs.fileBasename(file)
+      name = unit.gsub(".target", "")
+      inif = ini(file)
+      desc = parse_description(inif)
+
+      {:unit        => unit,
+       :name        => name,
+       :path        => file,
+       :description => desc}
+    rescue
+      warn "Error parsing: #{file}"
+      nil	      # make sure no intermediate result is returned!
+    end
+
+    def service_xml(service)
+      {"name"        => service[:name],
+       "image_path"  => service[:path],
+       "description" => service[:description],
+       "typename"    => "linux_systemd"}
+    end
+
+    def service_targets_xml(service)
+      (service[:required_by] + service[:wanted_by]).collect do |tgt|
+        {"value" => tgt.gsub(".target", "")}
+      end
+    end
+
+    def debug(msg)
+      $log.debug msg if $log
+    end
+
+    def warn(msg)
+      $log.warn msg if $log
+    end
+  end # class Systemd
+end # module MiqLinux

data/lib/metadata/linux/LinuxUsers.rb

@@ -0,0 +1,289 @@
+require 'binary_struct'
+require 'util/miq-hash_struct'
+require 'util/miq-xml'
+
+module MiqLinux
+  class Users
+    attr_reader :userHash, :groups
+
+    def initialize(fs)
+      @userHash = {}
+      @usersByGid = Hash.new { |h, k| h[k] = [] }
+      @groups = []
+
+      wtmp = FileWTMP.new(fs)
+
+      fname = "/etc/passwd"
+      if fs.fileExists?(fname)
+        pfes = nil
+        fs.fileOpen(fname) { |fo| pfes = fo.read }
+        unless pfes.nil?
+          pfes.each_line do |pfe|
+            next if pfe =~ /^#/
+            fields = pfe.chop.split(':')
+            u = MiqHashStruct.new
+            u.name       = fields[0]
+            u.uid        = fields[2]
+            u.gid        = fields[3]
+            u.gecos      = fields[4]
+            u.dir        = fields[5]
+            u.shell      = fields[6] || "NONE"
+            u.last_logon = wtmp.last_logon(u.name) unless wtmp.nil?
+            u.groups     = []
+            @userHash[u.name] = u
+            @usersByGid[u.gid] << u
+          end
+        end
+      end
+
+      fname = "/etc/group"
+      if fs.fileExists?(fname)
+        pfes = nil
+        fs.fileOpen(fname) { |fo| pfes = fo.read }
+        unless pfes.nil?
+          pfes.each_line do |pfe|
+            next if pfe =~ /^#/
+            fields = pfe.chop.split(':')
+            g = MiqHashStruct.new
+            g.name  = fields[0]
+            g.gid   = fields[2]
+            g.ulist = fields[3].split(',') if fields[3]
+            g.ulist = [] unless g.ulist
+            @usersByGid[g.gid].each { |u| g.ulist << u.name }
+            g.ulist.uniq!
+            g.ulist.each { |un| @userHash[un].groups << g.name if @userHash[un] }
+            @groups << g
+          end
+        end
+      end
+      @userHash.each_value { |u| u.groups.uniq! }
+    end
+
+    def to_s
+      str = ''
+
+      @userHash.each_value do |u|
+        str += "Login: " + u.name
+        str += "\n\tUid: " + u.uid.to_s
+        str += "\n\tGid: " + u.gid.to_s
+        str += "\n\tHome: " + u.dir
+        str += "\n\tShell: " + u.shell
+        str += "\n\tGECOS: " + u.gecos
+        str += "\n\tGroups: "
+        u.groups.each { |gn| str += "\n\t\t#{gn}" }
+        str += "\n"
+      end
+
+      @groups.each do |g|
+        str += "Group Name: " + g.name
+        str += "\n\tGid: " + g.gid
+        str += "\n\tUsers:"
+        g.ulist.each { |un| str += "\n\t\t#{un}" }
+        str += "\n"
+      end
+      (str)
+    end
+
+    def to_xml(doc = nil)
+      doc = MiqXml.createDoc(nil) unless doc
+      usersToXml(doc)
+      groupsToXml(doc)
+      doc
+    end
+
+    def usersToXml(doc = nil)
+      doc = MiqXml.createDoc(nil) unless doc
+
+      users = doc.add_element('users')
+      @userHash.each_value do |u|
+        user = users.add_element('user', {'name' => u.name, 'userid' => u.uid, 'homedir' => u.dir})
+        user.add_attribute('comment', u.gecos) unless u.gecos.blank?
+        user.add_attribute('last_logon', u.last_logon) unless u.last_logon.nil? || u.last_logon.blank?
+
+        u.groups.each do |gn|
+          user.add_element('member_of_group', {'name' => gn})
+        end
+      end
+      doc
+    end
+
+    def groupsToXml(doc = nil)
+      doc = MiqXml.createDoc(nil) unless doc
+
+      groups = doc.add_element('groups')
+      @groups.each do |g|
+        group = groups.add_element('group', {'name' => g.name, 'groupid' => g.gid})
+
+        g.ulist.each do |un|
+          group.add_element('member_users', {'name' => un})
+        end
+      end
+      doc
+    end
+  end # class Users
+
+  class FileWTMP
+    # From http://www.hcidata.info/wtmp.htm
+    #
+    # The wtmp log file is usually found in /var/log/wtmp and contains the following information:
+    #
+    #         * Activity code (e.g. login, logout, boot)
+    #         * PID
+    #         * Date and time of last login
+    #         * Terminal line name
+    #         * Host user came from
+    #
+    #     The following one line PERL program will format and print /var/log/wtmp but it may need modification to work on your site.
+    #
+    #     perl -we '@type=("Empty","Run Lvl","Boot","New Time","Old Time","Init","Login","Normal","Term","Account");$recs = ""; while (<>) {$recs .= $_};foreach (split(/(.{384})/s,$recs)) {next if length($_) == 0;my ($type,$pid,$line,$inittab,$user,$host,$t1,$t2,$t3,$t4,$t5) = $_ =~/(.{4})(.{4})(.{32})(.{4})(.{32})(.{256})(.{4})(.{4})(.{4})(.{4})(.{4})/s;if (defined $line && $line =~ /\w/) {$line =~ s/\x00+//g;$host =~ s/\x00+//g;$user =~ s/\x00+//g;printf("%s %-8s %-12s %10s %-45s \n",scalar(gmtime(unpack("I4",$t3))),$type[unpack("I4",$type)],$user,$line,$host)}}print"\n"' < /var/log/wtmp
+    #
+    #     The items that may need modification in order to format and print your lastlog file are:
+    #
+    #         * 384 - this should be changed to the length of each record on /var/log/wtmp.
+    #         * 32 - this should be changed to the value of UT_LINESIZE (probably 32) in /usr/include/bits/utmp.h
+    #         * 32 - this should be changed to the value of UT_NAMESIZE](probably 32) in /usr/include/bits/utmp.h
+    #         * 256 - this should be changed to the value of UT_HOSTSIZE (probably 256) in /usr/include/bits/utmp.h
+    #         * /var/log/wtmp - this should be the name of the lastlog file on your system - probably /var/log/wtmp
+    #
+
+    WTMP_RECORD = BinaryStruct.new([
+      'V',        'type',          # type of login
+      'V',        'pid',           # PID of login process
+      'a32',      'line',          # device name of tty - "/dev/"
+      'V',        'inittab',       # init id or abbrev. ttyname
+      'a32',      'user',          # user name
+      'a256',     'host',          # hostname for remote login
+      'v',        'e_termination', # process termination status
+      'v',        'e_exit',        # process exit status
+      'V',        'session',       # Session ID, used for windowing
+      'V',        'seconds',       # Time, in seconds
+      'V',        'useconds',      #     microseconds
+      'V4',       'addr_v6',       # * Internet address of remote host; IPv4 address uses just ut_addr_v6[0] */
+      'a20',      'extra'
+    ])
+    WTMP_RECORD_LEN = WTMP_RECORD.size
+
+    # WTMP Account Types
+    WTMP_TYPE_UT_UNKNOWN    = 0
+    WTMP_TYPE_RUN_LVL       = 1
+    WTMP_TYPE_BOOT_TIME     = 2
+    WTMP_TYPE_NEW_TIME      = 3
+    WTMP_TYPE_OLD_TIME      = 4
+    WTMP_TYPE_INIT_PROCESS  = 5
+    WTMP_TYPE_LOGIN_PROCESS = 6
+    WTMP_TYPE_USER_PROCESS  = 7
+    WTMP_TYPE_DEAD_PROCESS  = 8
+    WTMP_TYPE_ACCOUNTING    = 9
+
+    WTMP_TYPES = {
+      WTMP_TYPE_UT_UNKNOWN    => "Unknown",
+      WTMP_TYPE_RUN_LVL       => "Run Level",
+      WTMP_TYPE_BOOT_TIME     => "Boot Time",
+      WTMP_TYPE_NEW_TIME      => "New Time",
+      WTMP_TYPE_OLD_TIME      => "Old Time",
+      WTMP_TYPE_INIT_PROCESS  => "Init Process",
+      WTMP_TYPE_LOGIN_PROCESS => "Login Process",
+      WTMP_TYPE_USER_PROCESS  => "User Process",
+      WTMP_TYPE_DEAD_PROCESS  => "Dead Process",
+      WTMP_TYPE_ACCOUNTING    => "Accounting"
+    }
+
+    def initialize(fs, path = "/var/log/wtmp")
+      @contents = nil
+      @records  = nil
+      begin
+        fs.fileOpen(path, "rb") { |fo| @contents = fo.read }
+      rescue
+      end
+    end
+
+    def last_logon(username)
+      return nil if @contents.nil?
+      last = nil
+
+      begin
+        last = records[username]
+        last = Time.at(last).getutc unless last.nil?
+      rescue => err
+        $log.error("Error processing WTMP file because <#{err.message}>") if $log
+      end
+      last
+    end
+
+    def dump(rec)
+      puts "WTMP Record:"
+      #      puts "WTMP Record: #{rec.inspect}"
+      puts "\ttype: #{WTMP_TYPES[rec["type"]]}"
+      puts "\tuser: #{rec["user"]}"
+      puts "\thost: #{rec["host"]}"
+      puts "\tline: #{rec["line"]}"
+      puts "\tpid:  #{rec["pid"]}"
+      puts "\ttime: #{Time.at(rec["seconds"])}"
+    end
+
+    def records
+      return @records unless @records.nil?
+      @records = {}
+      recnum = 0
+      nrecs  = @contents.length / WTMP_RECORD_LEN
+      # TODO(lsmola) limiting log file size and logging warning when it's over it?
+      # Cause this can potentily go through milions of records
+      while recnum < nrecs
+        offset  = recnum * WTMP_RECORD_LEN
+        recnum += 1
+        buf     = @contents[offset, WTMP_RECORD_LEN]
+        break unless buf.length == WTMP_RECORD_LEN
+        rec = WTMP_RECORD.decode(buf)
+        ['host', 'user', 'line'].each { |k| rec[k].strip! if rec[k] }
+        next if rec["user"].blank?
+        next unless rec["type"] == WTMP_TYPE_USER_PROCESS
+
+        current = rec["seconds"]
+        user    = rec["user"]
+        # Get the latest logon timestamp for each user
+        @records[user] = current if @records[user].blank? || current > @records[user]
+      end
+      @records
+    end
+  end # class FileWTMP
+end # module MiqLinux
+
+if __FILE__ == $0
+  require 'log4r'
+  require 'MiqVm/MiqVm'
+
+  vmDir = File.join(ENV.fetch("HOME", '.'), 'VMs')
+  puts "vmDir = #{vmDir}"
+
+  class ConsoleFormatter < Log4r::Formatter
+    def format(event)
+      (event.data.kind_of?(String) ? event.data : event.data.inspect)
+    end
+  end
+
+  toplog = Log4r::Logger.new 'toplog'
+  Log4r::StderrOutputter.new('err_console', :level => Log4r::ERROR, :formatter => ConsoleFormatter)
+  toplog.add 'err_console'
+  $log = toplog if $log.nil?
+
+  #
+  # *** Test start
+  #
+
+  vmCfg = File.join(vmDir, "Red Hat Linux.vmwarevm/Red Hat Linux.vmx")
+  # vmCfg = File.join(vmDir, "MIQ Server Appliance - Ubuntu MD - small/MIQ Server Appliance - Ubuntu.vmx")
+  # vmCfg = File.join(vmDir, "winxpDev.vmwarevm/winxpDev.vmx")
+  vmCfg = "/Volumes/OB VMs/vms/Ubuntu Subversion/Ubuntu.vmx"
+  puts "VM config file: #{vmCfg}"
+
+  vm = MiqVm.new(vmCfg)
+  raise "No OSs detected" if vm.rootTrees.length == 0
+  rt = vm.rootTrees[0]
+  u = MiqLinux::Users.new(rt)
+  puts "**** USERS:"
+  u.usersToXml.write($stdout, 4)
+  puts
+  puts "**** GROUPS:"
+  u.groupsToXml.write($stdout, 4)
+  puts
+end

data/lib/metadata/linux/LinuxUtils.rb

@@ -0,0 +1,197 @@
+module MiqLinux
+  class Utils
+    def self.parse_ls_l_fulltime(lines)
+      ret = []
+      return ret if lines.nil? || lines.empty?
+
+      lines.each do |line|
+        line = line.chomp
+        parts = line.split(' ')
+        next unless parts.length >= 9
+
+        perms, ftype = permissions_to_octal(parts[0])
+
+        ret << {
+          :ftype       => ftype,
+          :permissions => perms,
+          :hard_links  => perms[1],
+          :owner       => parts[2],
+          :group       => parts[3],
+          :size        => parts[4],
+          :mtime       => Time.parse(parts[5..7].join(' ')).utc,
+          :name        => parts[8..-1].join(' '),
+        }
+      end
+
+      ret
+    end
+
+    def self.permissions_to_octal(perms)
+      if perms.length == 9
+        ftype = nil
+      elsif perms.length == 10
+        ftype = perms[0, 1]
+        perms = perms[1..-1]
+      elsif perms.length == 11
+        # TODO: when se-linux is present, the format is like this '-rw-rw-r--.', . means an SELinux ACL. (+ means a
+        # general ACL.). I need to figure out where to store this fact, ignoring it for now
+        ftype = perms[0, 1]
+        perms = perms[1..-2]
+      else
+        raise "Invalid perms length"
+      end
+
+      unless ftype.nil?
+        ftype = case ftype
+                when 'd' then 'dir'
+                when 'l' then 'link'
+                else          'file'
+                end
+      end
+
+      octal = [0, 0, 0, 0]
+      perms.split(//).each_with_index do |c, i|
+        # puts [c, i, i % 3, 2 - (i % 3), 2 ** (2 - (i % 3)), i / 3, 2 - (i / 3), 2 ** (2 - (i / 3))].inspect
+        octal[i / 3 + 1] += 2**(2 - (i % 3)) unless %w(- S T).include?(c)
+        # puts octal.inspect
+        octal[0] += 2**(2 - (i / 3)) if %w(s t S T).include?(c)
+        # puts octal.inspect
+      end
+      octal = octal.join
+
+      return octal, ftype
+    end
+
+    def self.octal_to_permissions(octal, ftype = nil)
+      perms = ""
+
+      unless ftype.nil?
+        ftype = ftype[0, 1]
+        ftype = '-' if ftype == 'f'
+        perms << ftype
+      end
+
+      octal = octal.to_i(8) if octal.kind_of?(String)
+
+      perms << (octal & 00400 != 0 ? 'r' : '-')
+      perms << (octal & 00200 != 0 ? 'w' : '-')
+      perms << (octal & 04000 != 0 ? (octal & 00100 != 0 ? 's' : 'S') : octal & 00100 != 0 ? 'x' : '-')
+      perms << (octal & 00040 != 0 ? 'r' : '-')
+      perms << (octal & 00020 != 0 ? 'w' : '-')
+      perms << (octal & 02000 != 0 ? (octal & 00010 != 0 ? 's' : 'S') : octal & 00010 != 0 ? 'x' : '-')
+      perms << (octal & 00004 != 0 ? 'r' : '-')
+      perms << (octal & 00002 != 0 ? 'w' : '-')
+      perms << (octal & 01000 != 0 ? (octal & 00001 != 0 ? 't' : 'T') : octal & 00001 != 0 ? 'x' : '-')
+
+      perms
+    end
+
+    def self.parse_chkconfig_list(lines)
+      ret = []
+      return ret if lines.nil? || lines.empty?
+
+      lines.each_line do |line|
+        line = line.chomp
+        parts = line.split(' ')
+        next unless parts.length >= 8
+
+        enable_level = []
+        disable_level = []
+
+        parts[1..-1].each do |part|
+          level, state = part.split(':')
+          case state
+          when 'on'  then enable_level << level
+          when 'off' then disable_level << level
+          end
+        end
+
+        nh = {:name => parts[0]}
+        nh[:enable_run_level]  = enable_level.empty? ? nil : enable_level.sort
+        nh[:disable_run_level] = disable_level.empty? ? nil : disable_level.sort
+
+        ret << nh
+      end
+
+      ret
+    end
+
+    def self.parse_systemctl_list(lines)
+      return [] if lines.nil? || lines.empty?
+
+      lines.each_line.map do |line|
+        line = line.chomp
+        parts = line.split(' ')
+        next if (/^.*?\.service$/ =~ parts[0]).nil?
+
+        name, = parts[0].split('.')
+
+        # TODO(lsmola) investigate adding systemd targets, which are used instead of runlevels. Drawback, it's not
+        # returned by any command, so we would have to parse the dir structure of /etc/systemd/system/
+        # There is already MiqLinux::Systemd.new(@systemFs) called from class MIQExtract, we should leverage that
+        {:name              => name,
+         :systemd_load      => parts[1],
+         :systemd_active    => parts[2],
+         :systemd_sub       => parts[3],
+         :typename          => 'linux_systemd',
+         :description       => parts[4..-1].join(" "),
+         :enable_run_level  => nil,
+         :disable_run_level => nil,
+         :running           => parts[3] == 'running'}
+      end.compact
+    end
+
+    def self.collect_interface(interfaces, interface)
+      mac_addr = interface[:mac_address]
+      return if mac_addr.blank?
+
+      existing_interface = interfaces[mac_addr]
+      if existing_interface.blank?
+        interfaces[mac_addr] = interface
+      else
+        interface[:name] += "," + existing_interface[:name]
+        existing_interface.merge!(interface)
+      end
+    end
+
+    def self.parse_network_interface_list(lines)
+      return [] if lines.blank?
+
+      interfaces = {}
+      interface = {}
+      lines.each_line do |line|
+        if /^\d+\:\s([\w-]+)\:.*?mtu\s(\d+).*?$/ =~ line
+          collect_interface(interfaces, interface) unless interface.blank?
+          interface = {:name => $1}
+        elsif /^.*?link.*?((\w\w\:)+\w\w).*?$/ =~ line
+          interface[:mac_address] = $1
+        elsif /^.*?inet\s((\d+\.)+\d+).*?$/ =~ line
+          interface[:fixed_ip] = $1
+        elsif /^.*?inet6\s((\w*\:+)+\w+).*?$/ =~ line
+          interface[:fixed_ipv6] = $1
+        end
+      end
+      collect_interface(interfaces, interface)
+
+      interfaces.values
+    end
+
+    def self.parse_openstack_status(lines)
+      lines.to_s.split("\n").reject{|t| t.include? "="}.group_by{|t| t.gsub(/openstack\-([a-z]+).*/i, '\1')}.map do |title, services|
+        {
+          'name'     => title.capitalize,
+          'services' => services.map do |service_line|
+            # split service line by :, ( and ) and strip white space from results
+            service_line.split(/[:\(\)]/).map(&:strip)
+          end.map do |service|
+            {
+              'name'    => service.first,
+              'active'  => service[1] == 'active',
+              'enabled' => !(service[2] =~ /disabled/)
+            }
+          end
+        }
+      end
+    end
+  end
+end

data/lib/metadata/linux/MiqConaryPackages.rb

@@ -0,0 +1,41 @@
+require 'binary_struct'
+require 'util/miq-hash_struct'
+require 'db/MiqSqlite/MiqSqlite3'
+
+class MiqConaryPackages
+  def initialize(fs, dbFile)
+    @pkgDb = MiqSqlite3DB::MiqSqlite3.new(dbFile, fs)
+
+    tVersions  = @pkgDb.getTable("Versions")
+    tInstances = @pkgDb.getTable("Instances")
+
+    @versions = {}
+    tVersions.each_row do |row|
+      id            = row['versionId']
+      @versions[id] = row['version']
+    end
+
+    @troves = {}
+    tInstances.each_row do |row|
+      troveName = row['troveName']
+      versionId = row['versionId']
+      @troves[troveName] = versionId if @versions.key?(versionId) && !troveName.include?(":") && row['isPresent']
+    end
+  end
+
+  def each
+    @troves.keys.sort.each do |t|
+      versionId = @troves[t]
+      pkg  = MiqHashStruct.new
+      pkg.name      = t
+      pkg.version   = @versions[versionId]
+      pkg.installed = true
+
+      yield pkg
+    end
+  end # def each
+
+  def close
+    @pkgDb.close
+  end
+end # class MiqConaryPackages