manageiq-smartstate 0.1.0

data/lib/metadata/linux/LinuxInitProcs.rb

@@ -0,0 +1,142 @@
+require 'util/miq-hash_struct'
+require 'util/miq-xml'
+require 'metadata/linux/InitProcHash'
+
+module MiqLinux
+  class InitProcs
+    INIT_DIRS   = ["/etc/rc.d/init.d", "/etc/init.d"]
+    RC_DIRS     = ["/etc/rc.d", "/etc", "/etc/init.d"]
+    RC_CHECK    = ["rc0.d", "runlevels"]
+    RUN_LEVELS1 = ['0', '1', '2', '3', '4', '5', '6', 'S']
+    RUN_LEVELS2 = ['boot', 'default', 'network', 'single']
+
+    def initialize(fs)
+      @fs = fs
+      @scriptsByName = {}
+
+      #
+      # Try to determine where the system's init.d directory is.
+      #
+      $log.debug "Determining init script directory..."
+      @init_dir = nil
+      INIT_DIRS.each do |id|
+        $log.debug "\tChecking: #{id}"
+        next unless @fs.fileExists?(id)
+        $log.debug "\tFound init script directory: #{id}"
+        @init_dir = id
+        break
+      end
+      unless @init_dir
+        $log.warn "Could not determine init script directory."
+        return
+      end
+
+      #
+      # Try to determine where the system keeps its runlevel scripts.
+      # NOTE: Gentoo is a special case. It uses "named" runlevel directories
+      # under the directory "runlevels". As opposed to rc?.d directories.
+      #
+      $log.debug "Determining RC script directory..."
+      @rc_dir = nil
+      @rc_chk = nil
+      RC_DIRS.each do |rd|
+        $log.debug "\tChecking: #{rd}"
+        next unless @fs.fileExists?(rd)
+
+        RC_CHECK.each do |rcc|
+          next unless @fs.fileExists?(File.join(rd, rcc))
+          @rc_chk = rcc
+          break
+        end
+        break unless @rc_chk
+
+        $log.debug "\tFound init script directory: #{rd} - checked: #{@rc_chk}"
+        @rc_dir = rd
+        break
+      end
+      unless @rc_dir
+        $log.warn "Could not determine RC script directory."
+        return
+      end
+
+      @fs.dirForeach(@init_dir) do |fn|
+        next if @fs.fileDirectory?(File.join(@init_dir, fn))
+        name = @fs.fileBasename(fn, ".sh")
+        next if name.downcase == "readme" || name == "." || name == ".."
+
+        addScript(@init_dir, fn, name)
+      end
+
+      if @rc_chk == "runlevels"
+        @rc_dir = File.join(@rc_dir, @rc_chk)
+        @run_levels = RUN_LEVELS2
+      else
+        @run_levels = RUN_LEVELS1
+      end
+
+      @run_levels.each do |rl|
+        if @rc_chk == "runlevels"
+          rld = File.join(@rc_dir, rl)
+        else
+          rld = File.join(@rc_dir, "rc#{rl}.d")
+        end
+
+        next unless @fs.fileDirectory?(rld)
+        @fs.dirForeach(rld) do |fn|
+          # If it's not a start of kill script, skip it.
+          next if fn[0, 1] != "S" && fn[0, 1] != "K" && @rc_chk != "runlevels"
+          # Full path to file.
+          fp = File.join(rld, fn)
+          # If the file isn't a symbolic link, skip it.
+          next unless @fs.fileSymLink?(fp)
+          lp = @fs.getLinkPath(fp)
+
+          # The init.d script to which the file is linked.
+          name = @fs.fileBasename(lp, ".sh")
+
+          addScript(@fs.fileDirname(lp), @fs.fileBasename(lp), name) unless @scriptsByName[name]
+
+          sk = (@rc_chk == "runlevels" ? 'S' : fn[0, 1])
+          @scriptsByName[name].runLevels[sk] << rl
+        end
+      end
+    end
+
+    def addScript(dir, fn, name)
+      s = MiqHashStruct.new
+      s.name = name
+      s.path = File.join(dir, fn)
+      s.desc = getDesc(s.path, name)
+      s.runLevels = Hash.new
+      s.runLevels['S'] = []
+      s.runLevels['K'] = []
+      @scriptsByName[name] = s
+    end
+
+    def toXml(doc = nil)
+      doc = MiqXml.createDoc(nil) unless doc
+
+      @scriptsByName.each_value do |s|
+        ip = doc.add_element("service", "name" => s.name, "image_path" => s.path, "typename" => "linux_initprocess")
+        ip.attributes["description"] = s.desc if s.desc
+
+        s.runLevels['S'].each { |rl| ip.add_element("enable_run_level", "value" => rl) }
+        s.runLevels['K'].each { |rl| ip.add_element("disable_run_level", "value" => rl) }
+      end
+    end
+
+    private
+
+    def getDesc(f, n)
+      fdata = ""
+      begin
+        @fs.fileOpen(f) { |fo| fdata = fo.read }
+        fdata.each_line { |fl| return $1 if fl =~ /^\s*#\s+Short-Description:\s*(.*)$/ } unless fdata.nil?
+        return InitProcHash[n]
+      rescue => err
+        $log.warn "getDesc: could not open #{f} - #{err}"
+        return ""
+      end
+    end
+  end # class InitProcs
+end # module MiqLinux

data/lib/metadata/linux/LinuxOSInfo.rb

@@ -0,0 +1,237 @@
+require 'util/miq-xml'
+
+module MiqLinux
+  class OSInfo
+    attr_reader :os, :networks
+
+    ETC = "/etc"
+    IFCFGFILE = "/etc/sysconfig/network-scripts"
+    DHCLIENTFILE = "/var/lib/dhclient/"
+    DEBIANDHCLIENTFILE = "/var/lib/dhcp3/"
+    DEBIANIFCFGILE = "/etc/network"
+    DISTRIBUTIONS = ["mandriva", "mandrake", "mandrakelinux", "gentoo", "SuSE", "fedora", "redhat", "knoppix", "debian", "lsb", "distro"]
+
+    def initialize(fs)
+      @fs = fs
+      @os_type = "Linux"
+      @distribution = nil
+      @description  = nil
+      @hostname     = nil
+
+      release_file = nil
+      version_file = nil
+      @networks = []
+      @os = {}
+
+      DISTRIBUTIONS.each do |dist|
+        release_file = File.join(ETC, dist + "-release")
+
+        if fs.fileExists?(release_file)
+          @distribution = dist
+          break
+        end
+      end
+
+      if @distribution == "lsb"
+        lsbd = ""
+        fs.fileOpen(release_file) { |fo| lsbd = fo.read }
+
+        dist = desc = chrome_dist = chrome_desc = nil
+        lsbd.each_line do |lsbl|
+          dist = $1 if lsbl =~ /^\s*DISTRIB_ID\s*=\s*(.*)$/
+          desc = $1 if lsbl =~ /^\s*DISTRIB_DESCRIPTION\s*=\s*(.*)$/
+          chrome_dist = $1 if lsbl =~ /^\s*CHROMEOS_RELEASE_NAME\s*=\s*(.*)$/
+          chrome_desc = $1 if lsbl =~ /^\s*CHROMEOS_RELEASE_DESCRIPTION\s*=\s*(.*)$/
+        end
+        chrome_desc = "#{chrome_dist} #{chrome_desc}" if chrome_dist && chrome_desc
+
+        @distribution = chrome_dist || dist if chrome_dist || dist
+        @description  = chrome_desc || desc if chrome_desc || desc
+      elsif @distribution
+        fs.fileOpen(release_file) { |fo| @description = fo.read.to_s.chomp }
+        @distribution = "CentOS" if @distribution == "redhat" && @description.include?("CentOS")
+        @distribution = "rPath"  if @distribution == "distro"
+      end
+
+      unless @distribution
+        DISTRIBUTIONS.each do |distrib|
+          version_file = File.join(ETC, distrib + "-release")
+
+          if fs.fileExists?(version_file)
+            @distribution = distrib
+            break
+          end
+        end
+        fs.fileOpen(version_file) { |fo| @description = fo.read.chomp } if @distribution
+      end
+
+      unless @distribution
+        read_file(fs, File.join(ETC, "issue")) do |line|
+          case line
+          when /\s*Hercules\s*/
+            @distribution = "hercules"
+            @description =  "Hercules"
+            break
+          end
+        end
+      end
+
+      @distribution = "" unless @distribution
+      @description  = "" unless @description
+      @description  = @description.gsub(/^"/, "").gsub(/"$/, "")
+
+      ["/etc/hostname", "/etc/HOSTNAME"].each do |hnf|
+        next unless fs.fileExists?(hnf)
+        fs.fileOpen(hnf) { |fo| @hostname = fo.read.chomp } if fs.fileExists?(hnf)
+      end
+
+      # return if @hostname
+
+      ["/etc/conf.d/hostname", "/etc/sysconfig/network"].each do |hnf|
+        next unless fs.fileExists?(hnf)
+        next if fs.fileDirectory?(hnf)
+        hnfd = ""
+        fs.fileOpen(hnf) { |fo| hnfd = fo.read }
+        hnfd.each_line do |hnfl|
+          if hnfl =~ /^\s*HOSTNAME\s*=\s*(.*)$/
+            @hostname = $1
+            break
+          end
+        end
+      end
+
+      @hostname = "" unless @hostname
+
+      network_attrs = {:hostname => @hostname}
+      # Collect network settings
+      case @distribution.downcase
+      when "ubuntu" then networking_debian(fs, network_attrs)
+      when "redhat", "fedora" then networking_redhat(fs, network_attrs)
+      when "hercules" then networking_hercules(fs, network_attrs)
+      end
+
+      @os = {:type => "linux", :machine_name => @hostname, :product_type => @os_type, :distribution => @distribution, :product_name => @description}
+      $log.info "VM OS information: [#{@os.inspect}]" if $log
+    end
+
+    def networking_debian(fs, attrs)
+      read_file(fs, File.join(DEBIANIFCFGILE, "interfaces")) do |line|
+        case line
+        when /^\s*iface eth0 inet dhcp\s*(.*)$/ then attrs[:dhcp_enabled] = 1
+        when /^\s*iface eth0 inet static\s*(.*)$/ then attrs[:dhcp_enabled] = 0
+        when /^\s*address\s*(.*)$/ then attrs[:ipaddress] = $1
+        when /^\s*netmask\s*(.*)$/ then attrs[:subnet_mask] = $1
+        when /^\s*gateway\s*(.*)$/ then attrs[:default_gateway] = $1
+        when /^\s*network\s*(.*)$/ then attrs[:network] = $1
+        end
+      end
+
+      if attrs[:dhcp_enabled] == 1
+        read_file(fs, File.join(DEBIANDHCLIENTFILE, "dhclient.eth0.leases")) do |line|
+          case line
+          when /^\s*fixed-address\s*(.*)\;$/                 then attrs[:ipaddress] = $1
+          when /^\s*option subnet-mask\s*(.*)\;$/            then attrs[:subnet_mask] = $1
+          when /^\s*option routers\s*(.*)\;$/                then attrs[:default_gateway] = $1
+          when /^\s*option domain-name-servers\s*(.*)\;$/    then attrs[:dns_server] = $1
+          when /^\s*option dhcp-server-identifier\s*(.*)\;$/ then attrs[:dhcp_server] = $1
+          when /^\s*option domain-name\s*"*(.*)"\;$/         then attrs[:domain] = $1
+          when /^\s*expire\s*[0-9]?\s*(.*)\;$/               then attrs[:lease_expires] = $1
+          when /^\s*renew\s*[0-9]?\s*(.*)\;$/                then attrs[:lease_obtained] = $1
+          end
+        end
+      end
+
+      fix_attr_values(attrs)
+      @networks << attrs
+    end
+
+    def networking_redhat(fs, attrs)
+      read_file(fs, File.join(IFCFGFILE, "ifcfg-eth0")) do |line|
+        case line
+        when  /^\s*BOOTPROTO=dhcp\s*(.*)$/    then attrs[:dhcp_enabled] = 1
+        when  /^\s*BOOTPROTO=static\s*(.*)$/  then attrs[:dhcp_enabled] = 0
+        when  /^\s*DEVICE\s*=\s*(.*)$/        then attrs[:device] = $1
+        when  /^\s*HWADDR\s*=\s*(.*)$/        then attrs[:hwaddr] = $1
+          # static setting will have these entries
+        when  /^\s*IPADDR\s*=\s*(.*)$/        then attrs[:ipaddress] = $1
+        when  /^\s*NETMASK\s*=\s*(.*)$/       then attrs[:subnet_mask] = $1
+          # static setting might have these entries
+        when  /^\s*BROADCAST\s*=\s*(.*)$/     then attrs[:broadcast] = $1
+        when  /^\s*NETWORK\s*=\s*(.*)$/       then attrs[:network] = $1
+        end
+      end
+
+      if attrs[:dhcp_enabled] == 1
+        read_file(fs, File.join(DHCLIENTFILE, "dhclient-eth0.leases")) do |line|
+          case line
+          when /^\s*fixed-address\s*(.*)\;$/                 then attrs[:ipaddress] = $1
+          when /^\s*option subnet-mask\s*(.*)\;$/            then attrs[:subnet_mask] = $1
+          when /^\s*option routers\s*(.*)\;$/                then attrs[:default_gateway] = $1
+          when /^\s*option domain-name-servers\s*(.*)\;$/    then attrs[:dns_server] = $1
+          when /^\s*option dhcp-server-identifier\s*(.*)\;$/ then attrs[:dhcp_server] = $1
+          when /^\s*option domain-name\s*"*(.*)"\;$/         then attrs[:domain] = $1
+          when /^\s*expire\s*[0-9]?\s*(.*)\;$/               then attrs[:lease_expires] = $1
+          when /^\s*renew\s*[0-9]?\s*(.*)\;$/                then attrs[:lease_obtained] = $1
+          end
+        end
+      end
+
+      fix_attr_values(attrs)
+      @networks << attrs
+    end
+
+    def networking_hercules(fs, attrs)
+      read_file(fs, File.join(DEBIANIFCFGILE, "interfaces")) do |line|
+        case line
+        when /^\s*iface eth0 inet dhcp\s*(.*)$/ then attrs[:dhcp_enabled] = 1
+        when /^\s*iface eth0 inet static\s*(.*)$/ then attrs[:dhcp_enabled] = 0
+        end
+      end
+
+      fix_attr_values(attrs)
+      @networks << attrs
+    end
+
+    def toXml(doc = nil)
+      doc = MiqXml.createDoc(nil) unless doc
+      doc.add_element(:os, @os)
+      networksToXml(doc)
+      doc
+    end
+
+    def networksToXml(doc = nil)
+      doc = MiqXml.createDoc(nil) unless doc
+      unless @networks.empty?
+        node = doc.add_element(:networks)
+        @networks.each do |n|
+          [:hwaddr, :network, :device, :broadcast].each { |key| n.delete(key) }
+          node.add_element(:network, n)
+        end
+      end
+      doc
+    end
+
+    def read_file(fs, filename)
+      if fs.fileExists?(filename)
+        file_content = ""
+        fs.fileOpen(filename) { |fo| file_content = fo.read }
+        unless file_content.nil?
+          file_content.each_line { |line| yield(line.chomp) }
+        end
+      end
+    end
+
+    def fix_attr_values(attrs)
+      # Clean the lease times and check they are in a reasonable range
+      [:lease_obtained, :lease_expires].each do |t|
+        if attrs[t] && attrs[t].to_i >= 0 && attrs[t].to_i < 0x80000000
+          attrs[t] = Time.parse(attrs[t]).utc.iso8601
+        else
+          attrs.delete(t)
+        end
+      end
+
+      attrs[:dns_server].gsub!(/(,)/) { (' ') } unless attrs[:dns_server].nil?
+    end
+  end # class OSInfo
+end # module MiqLinux

data/lib/metadata/linux/LinuxPackages.rb

@@ -0,0 +1,209 @@
+require 'util/miq-hash_struct'
+require 'util/miq-xml'
+require 'metadata/linux/MiqRpmPackages'
+require 'metadata/linux/MiqConaryPackages'
+
+module MiqLinux
+  class Packages
+    attr_accessor :fs
+    #
+    # Debian based packageing.
+    #
+    DPKG_FILE   = '/var/lib/dpkg/status'
+    #
+    # Gentoo based packageing - portage.
+    #
+    PORTAGE_DB  = '/var/db/pkg'
+    PORTAGE_CMD = '/usr/bin/emerge'
+
+    #
+    # RPM DB directory.
+    #
+    RPM_DB = "/var/lib/rpm"
+
+    #
+    # Conary DB file
+    #
+    CONARY_FILE = "/var/lib/conarydb/conarydb"
+
+    def initialize(fs = nil)
+      @fs = fs
+      @pkg = nil
+      @packages = []
+
+      return unless fs
+
+      if fs.fileExists?(DPKG_FILE)
+        procDpkg(DPKG_FILE)
+      elsif fs.fileExists?(PORTAGE_CMD) && fs.fileDirectory?(PORTAGE_DB)
+        procPortage(PORTAGE_DB)
+      elsif fs.fileDirectory?(RPM_DB)
+        procRPM(RPM_DB)
+      elsif fs.fileExists?(CONARY_FILE)
+        procConary(CONARY_FILE)
+      end
+    end
+
+    def procDpkg(pf)
+      $log.debug "Processing Dpkg package database"
+      pfls = ""
+      @fs.fileOpen(pf) { |fo| pfls = fo.read }
+      desc = false
+
+      pfls.each_line do |pfl|
+        pfl.chop!
+
+        case pfl
+        when /^Package:\s/ then
+          @pkg = MiqHashStruct.new
+          @pkg.name = pfl.gsub(/^Package:\s/, '')
+          @packages << @pkg
+          desc = false
+
+        when /^Status:\s/ then
+          @pkg.status = pfl.gsub(/^Status:\s/, '')
+          @pkg.installed = false
+          @pkg.installed = true if @pkg.status =~ /\sinstalled$/
+          desc = false
+
+        when /^Version:\s/ then
+          @pkg.version = pfl.gsub(/^Version:\s/, '')
+          desc = false
+
+        when /^Depends:\s/ then
+          @pkg.depends = pfl.gsub(/^Depends:\s/, '')
+          desc = true
+
+        when /^Section:\s/ then
+          @pkg.category = pfl.gsub(/^Section:\s/, '')
+          desc = false
+
+        when /^Description:\s/ then
+          @pkg.description = pfl.gsub(/^Description:\s/, '')
+          desc = true
+
+        when /^Priority:\s/ then
+          desc = false
+        when /^Conflicts:\s/ then
+          desc = false
+        when /^Provides:\s/ then
+          desc = false
+        when /^Pre-Depends:\s/ then
+          desc = false
+        when /^Recommends:\s/ then
+          desc = false
+        when /^Suggests:\s/ then
+          desc = false
+        when /^Conffiles:/ then
+          desc = false
+        when /^Architecture:\s/ then
+          desc = false
+        when /^Installed-Size:\s/ then
+          desc = false
+        when /^Enhances:\s/ then
+          desc = false
+        when /^Original-Maintainer:\s/ then
+          desc = false
+        when /^$/ then
+          desc = false
+
+        else
+          @pkg.description ||= ""
+          @pkg.description += "\n" + pfl if desc
+        end
+      end
+    end
+
+    def procPortage(pd)
+      $log.debug "Processing Portage package database"
+      @fs.chdir(pd)
+
+      @fs.dirForeach do |cat|
+        next if cat == '.' || cat == '..'
+        @fs.chdir(cat)
+
+        @fs.dirForeach do |pkg|
+          next if pkg == '.' || pkg == '..'
+          @fs.chdir(pkg)
+
+          p = pkg
+          v = '???'
+          if pkg =~ /-\d+.*$/
+            p = $`
+            v = $&[1, $&.length]
+          end
+
+          @pkg = MiqHashStruct.new
+          @pkg.name = p
+          @pkg.version = v
+          @pkg.category = cat
+          @pkg.status = "installed"
+          @pkg.installed = true
+          @fs.fileOpen('DEPEND') { |fo| @pkg.depends = fo.read.chomp } if @fs.fileFile?('DEPEND')
+          @fs.fileOpen('DESCRIPTION') { |fo| @pkg.description = fo.read.chomp } if @fs.fileFile?('DESCRIPTION')
+          @packages << @pkg
+
+          @fs.chdir('..')
+        end
+        @fs.chdir('..')
+      end
+    end
+
+    #
+    # Client-side RPM DB processing.
+    #
+    def procRPM(dbDir)
+      $log.debug "Processing RPM package database"
+      rpmp = MiqRpmPackages.new(@fs, File.join(dbDir, "Packages"))
+      rpmp.each { |p| @packages << p }
+      rpmp.close
+    end
+
+    #
+    # Conary DB processing
+    #
+    def procConary(dbFile)
+      $log.debug "Processing Conary package database"
+      rpmp = MiqConaryPackages.new(@fs, dbFile)
+      rpmp.each { |p| @packages << p }
+      rpmp.close
+    end
+
+    def toXml(doc = nil)
+      doc = MiqXml.createDoc(nil) unless doc
+
+      pkgs = doc.add_element 'applications'
+      @packages.each do |p|
+        next unless p.installed
+        pkgs.add_element('application', {"name" => p.name, "version" => p.version, "description" => p.description, "typename" => p.category, "arch" => p.arch, "release" => p.release, "install_time" => p.installtime})
+        # "status" => p.status, "depends" => p.depends
+      end
+      doc
+    end
+
+    def toString(_doc = nil)
+      pkgs = "<applications>\n"
+      @packages.each do |p|
+        next unless p.installed
+        pkgs += "  <application name='#{encodeStrings(p.name)}' version='#{p.version}' description='#{p.description}' typename='#{p.category}' />\n"
+      end
+      pkgs += "</applications>"
+    end
+
+    def encodeStrings(data)
+      data.gsub!(/>/, "&gt;")
+      data.gsub!(/</, "&lt;")
+      data.gsub!(/'/, "&apos;")
+      data.gsub!(/"/, "&quot;")
+      data
+    end
+  end # class Packages
+end # module MiqLinux
+
+if __FILE__ == $0
+  pkgs = MiqLinux::Packages.new
+  pkgs.procSsRPM
+  xml = pkgs.toXml
+  xml.write($stdout, 4)
+  puts
+end