machinery-tool 1.22.1 → 1.22.2

data/plugins/os/os_model.rb

@@ -15,189 +15,194 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class Os < Machinery::Object
-  include Machinery::Scope
+module Machinery
+  class Os < Machinery::Object
+    include Machinery::Scope
 
-  def self.scope_name
-    "os"
-  end
+    def self.scope_name
+      "os"
+    end
 
-  def self.descendants
-    @descendants ||= ObjectSpace.each_object(::Class).select do |klass|
-      klass < self && klass.descendants.empty?
+    def self.descendants
+      @descendants ||= ObjectSpace.each_object(::Class).select do |klass|
+        klass < self && klass.descendants.empty?
+      end
     end
-  end
 
-  def self.for(os_name)
-    descendants.each do |os_class|
-      if os_name == os_class.canonical_name
+    def self.for(os_name)
+      descendants.each do |os_class|
+        next unless os_name == os_class.canonical_name
         os = os_class.new
         os.name = os_name
         return os
       end
-    end
-    if os_name.match(/SUSE Linux|openSUSE/)
-      os = OsSuse.new
+      if os_name =~ /SUSE Linux|openSUSE/
+        os = OsSuse.new
+        os.name = os_name
+        return os
+      end
+      os = OsUnknown.new
       os.name = os_name
-      return os
+      os
     end
-    os = OsUnknown.new
-    os.name = os_name
-    os
-  end
 
-  def self.from_json(json)
-    scope_object = self.for(json["name"])
-    scope_object.set_attributes(json)
-    scope_object
-  end
+    def self.from_json(json)
+      scope_object = self.for(json["name"])
+      scope_object.set_attributes(json)
+      scope_object
+    end
 
-  def scope_name
-    "os"
-  end
+    def scope_name
+      "os"
+    end
 
-  def self.module_dependencies
-    {}
-  end
+    def self.module_dependencies
+      {}
+    end
 
-  def self.can_run_machinery?
-    true
-  end
+    def self.can_run_machinery?
+      true
+    end
 
-  def self.supported_host_systems
-    descendants.select { |os| os.can_run_machinery? }
-  end
+    def self.supported_host_systems
+      descendants.select(&:can_run_machinery?)
+    end
 
-  def can_run_machinery?
-    self.class.can_run_machinery?
-  end
+    def can_run_machinery?
+      self.class.can_run_machinery?
+    end
 
-  def module_required_by_package(package)
-    self.class.module_dependencies[package]
-  end
+    def module_required_by_package(package)
+      self.class.module_dependencies[package]
+    end
 
-  def canonical_name
-    self.class.canonical_name
-  end
+    def canonical_name
+      self.class.canonical_name
+    end
 
-  def display_name
-    "#{name} #{version} (#{architecture})"
+    def display_name
+      "#{name} #{version} (#{architecture})"
+    end
   end
-end
 
-class OsUnknown < Os
-  def self.canonical_name
-    "Unknown OS"
+  class OsUnknown < Os
+    def self.canonical_name
+      "Unknown OS"
+    end
   end
-end
 
-class OsSuse < Os
-  def self.canonical_name
-    "SUSE OS"
-  end
+  class OsSuse < Os
+    def self.canonical_name
+      "SUSE OS"
+    end
 
-  def kiwi_bootloader
-    "grub2"
-  end
+    def kiwi_bootloader
+      "grub2"
+    end
 
-  def kiwi_boot
-    os_version = version.match(/(\d+)+\.?(\d+)?/)
-    os_id = case name
-            when /SUSE Linux Enterprise Server/
-              "SLES#{os_version[1]}"
-            when /SUSE Linux Enterprise Desktop/
-              "SLED#{os_version[1]}"
-            when /openSUSE/
-              "#{os_version[1]}.#{os_version[2]}"
-    end
-    "vmxboot/suse-#{os_id}"
+    def kiwi_boot
+      os_version = version.match(/(\d+)+\.?(\d+)?/)
+      os_id = case name
+              when /SUSE Linux Enterprise Server/
+                "SLES#{os_version[1]}"
+              when /SUSE Linux Enterprise Desktop/
+                "SLED#{os_version[1]}"
+              when /openSUSE/
+                "#{os_version[1]}.#{os_version[2]}"
+      end
+      "vmxboot/suse-#{os_id}"
+    end
   end
-end
 
-class OsSles11 < OsSuse
-  def self.canonical_name
-    "SUSE Linux Enterprise Server 11"
-  end
+  class OsSles11 < OsSuse
+    def self.canonical_name
+      "SUSE Linux Enterprise Server 11"
+    end
 
-  def self.can_run_machinery?
-    false
-  end
+    def self.can_run_machinery?
+      false
+    end
 
-  def display_name
-    version =~ /11 (.*)/
-    sp = $1
-    "#{name} #{sp} (#{architecture})"
-  end
+    def display_name
+      version =~ /11 (.*)/
+      sp = $1
+      "#{name} #{sp} (#{architecture})"
+    end
 
-  def kiwi_bootloader
-    "grub"
+    def kiwi_bootloader
+      "grub"
+    end
   end
-end
 
-class OsSles12 < OsSuse
-  def self.canonical_name
-    "SUSE Linux Enterprise Server 12"
-  end
+  class OsSles12 < OsSuse
+    def self.canonical_name
+      "SUSE Linux Enterprise Server 12"
+    end
 
-  def self.module_dependencies
-    { "python-glanceclient" => "Public Cloud Module" }
-  end
+    def self.module_dependencies
+      { "python-glanceclient" => "Public Cloud Module" }
+    end
 
-  def display_name
-    "#{name} (#{architecture})"
+    def display_name
+      "#{name} (#{architecture})"
+    end
   end
-end
 
-class OsOpenSuse < OsSuse
-  def display_name
-    name =~ /(.*) \(.*\)/
-    name_and_version_without_codename = $1
-    "#{name_and_version_without_codename} (#{architecture})"
+  class OsOpenSuse < OsSuse
+    def display_name
+      name =~ /(.*) \(.*\)/
+      name_and_version_without_codename = $1
+      "#{name_and_version_without_codename} (#{architecture})"
+    end
   end
-end
 
-class OsOpenSuse13_1 < OsOpenSuse
-  def self.canonical_name
-    "openSUSE 13.1 (Bottle)"
+  # rubocop:disable Style/ClassAndModuleCamelCase
+  class OsOpenSuse13_1 < OsOpenSuse
+    # rubocop:enable Style/ClassAndModuleCamelCase
+    def self.canonical_name
+      "openSUSE 13.1 (Bottle)"
+    end
   end
-end
 
-class OsOpenSuse13_2 < OsOpenSuse
-  def self.canonical_name
-    "openSUSE 13.2 (Harlequin)"
+  # rubocop:disable Style/ClassAndModuleCamelCase
+  class OsOpenSuse13_2 < OsOpenSuse
+    # rubocop:enable Style/ClassAndModuleCamelCase
+    def self.canonical_name
+      "openSUSE 13.2 (Harlequin)"
+    end
   end
-end
 
-class OsOpenSuseTumbleweed < OsSuse
-  def display_name
-    "#{name} (#{architecture})"
-  end
+  class OsOpenSuseTumbleweed < OsSuse
+    def display_name
+      "#{name} (#{architecture})"
+    end
 
-  def self.canonical_name
-    "openSUSE Tumbleweed"
-  end
+    def self.canonical_name
+      "openSUSE Tumbleweed"
+    end
 
-  def kiwi_boot
-    "vmxboot/suse-tumbleweed"
+    def kiwi_boot
+      "vmxboot/suse-tumbleweed"
+    end
   end
-end
 
-class OsOpenSuseLeap < OsSuse
-  def display_name
-    "#{name} (#{architecture})"
-  end
+  class OsOpenSuseLeap < OsSuse
+    def display_name
+      "#{name} (#{architecture})"
+    end
 
-  def self.canonical_name
-    "openSUSE Leap"
-  end
+    def self.canonical_name
+      "openSUSE Leap"
+    end
 
-  def kiwi_boot
-    "vmxboot/suse-leap42.1"
+    def kiwi_boot
+      "vmxboot/suse-leap42.1"
+    end
   end
-end
 
-class Rhel < Os
-  def self.canonical_name
-    "Red Hat Enterprise Linux Server"
+  class Rhel < Os
+    def self.canonical_name
+      "Red Hat Enterprise Linux Server"
+    end
   end
 end

data/plugins/os/os_renderer.rb

@@ -16,16 +16,20 @@
 # you may find current contact information at www.suse.com
 
 #  This renderer prints the operating system
-class OsRenderer < Renderer
-  def content(description)
-    return unless description.os
+module Machinery
+  class Ui
+    class OsRenderer < Machinery::Ui::Renderer
+      def content(description)
+        return unless description.os
 
-    puts "Name: #{description.os.name}"
-    puts "Version: #{description.os.version}"
-    puts "Architecture: #{description.os.architecture}"
-  end
+        puts "Name: #{description.os.name}"
+        puts "Version: #{description.os.version}"
+        puts "Architecture: #{description.os.architecture}"
+      end
 
-  def display_name
-    "Operating System"
+      def display_name
+        "Operating System"
+      end
+    end
   end
 end

data/plugins/packages/packages_inspector.rb

@@ -15,111 +15,124 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class PackagesInspector < Inspector
-  has_priority 20
-  def initialize(system, description)
-    @system = system
-    @description = description
-  end
+module Machinery
+  class PackagesInspector < Machinery::Inspector
+    has_priority 20
+    def initialize(system, description)
+      @system = system
+      @description = description
+    end
 
-  def inspect(_filter, _options = {})
-    @system.check_requirement(["rpm", "dpkg"], "--version")
+    def inspect(_filter, _options = {})
+      @system.check_requirement(["rpm", "dpkg"], "--version")
+
+      if @system.has_command?("rpm")
+        inspect_rpm
+      elsif @system.has_command?("dpkg")
+        @system.check_requirement("apt-cache", "--version")
+        inspect_dpkg
+      end
 
-    if @system.has_command?("rpm")
-      inspect_rpm
-    elsif @system.has_command?("dpkg")
-      @system.check_requirement("apt-cache", "--version")
-      inspect_dpkg
+      @description
     end
 
-    @description
-  end
+    def summary
+      "Found #{Machinery.pluralize(@description.packages.length, "%d package")}."
+    end
 
-  def summary
-    "Found #{Machinery.pluralize(@description.packages.length, "%d package")}."
-  end
+    private
 
-  private
-
-  def inspect_rpm
-    packages = Machinery::Array.new
-    rpm_data = @system.run_command(
-      "rpm","-qa","--qf",
-      "%{NAME}|%{VERSION}|%{RELEASE}|%{ARCH}|%{VENDOR}|%{SIGMD5}$",
-      :stdout=>:capture
-    )
-    # gpg-pubkeys are no real packages but listed by rpm in the regular
-    # package list
-    rpm_data.scan(/(.*?)\|(.*?)\|(.*?)\|(.*?)\|(.*?)\|(.*?)\$/).reject do |name, *attrs|
-      name =~ /^gpg-pubkey$/
-    end.each do |name, version, release, arch, vendor, checksum|
-      packages << RpmPackage.new(
-        :name     => name,
-        :version  => version,
-        :release  => release,
-        :arch     => arch,
-        :vendor   => vendor,
-        :checksum => checksum
+    def inspect_rpm
+      packages = Machinery::Array.new
+      rpm_data = @system.run_command(
+        "rpm",
+        "-qa",
+        "--qf",
+        "%{NAME}|%{VERSION}|%{RELEASE}|%{ARCH}|%{VENDOR}|%{SIGMD5}$",
+        stdout: :capture
+      )
+      # gpg-pubkeys are no real packages but listed by rpm in the regular
+      # package list
+      rpm_data.scan(/(.*?)\|(.*?)\|(.*?)\|(.*?)\|(.*?)\|(.*?)\$/).reject do |name, *_attrs|
+        name =~ /^gpg-pubkey$/
+      end.each do |name, version, release, arch, vendor, checksum|
+        packages << RpmPackage.new(
+          name:     name,
+          version:  version,
+          release:  release,
+          arch:     arch,
+          vendor:   vendor,
+          checksum: checksum
+        )
+      end
+
+      @description.packages = PackagesScope.new(
+        packages.sort_by(&:name),
+        package_system: "rpm"
       )
     end
 
-    @description.packages = PackagesScope.new(
-      packages.sort_by(&:name),
-      package_system: "rpm"
-    )
-  end
+    def inspect_dpkg
+      dpkg_data = @system.run_command(
+        "dpkg", "-l", stdout: :capture
+      )
 
-  def inspect_dpkg
-    dpkg_data = @system.run_command(
-      "dpkg", "-l", stdout: :capture
-    )
+      lines = dpkg_data.lines.reject { |line| !line.start_with?("ii ") }
 
-    lines = dpkg_data.lines.reject { |line| !line.start_with?("ii ") }
+      packages = lines.map do |line|
+        name, version, arch = line.split[1..3]
+        version_segments = version.split("-")
+        release = version_segments.pop if version_segments.length > 1
+        version = version_segments.join("-")
 
-    packages = lines.map do |line|
-      name, version, arch = line.split[1..3]
-      version_segments = version.split("-")
-      release = version_segments.pop if version_segments.length > 1
-      version = version_segments.join("-")
+        Machinery::DpkgPackage.new(
+          name: name,
+          version: version,
+          release: release,
+          arch: arch
+        )
+      end
+      packages.each_slice(100) do |packages_slice|
+        apt_cache_output = run_apt_cache(packages_slice)
 
-      DpkgPackage.new(
-        name: name,
-        version: version,
-        release: release,
-        arch: arch
-      )
+        apt_cache_elements = Hash[
+          *apt_cache_output.split("\n\n").flat_map do |element|
+            name = element[/Package: (.+)$/, 1]
+            [name, element]
+          end
+        ]
+
+        packages_slice.each do |package|
+          name = package.name.sub(/:[^:]+$/, "")
+          apt_cache_element = apt_cache_elements[name]
+          if apt_cache_element
+            package.arch = apt_cache_element[/Architecture: (\w+)\n/, 1]
+            checksum = apt_cache_element[/MD5[Ss]um: (\w+)\n/, 1]
+            vendor = apt_cache_element[/Origin: (\w+)\n/, 1]
+          end
+          package.checksum = checksum || ""
+          package.vendor = vendor || ""
+          package.release ||= ""
+        end
+
+        @description.packages = Machinery::PackagesScope.new(
+          packages.sort_by(&:name),
+          package_system: "dpkg"
+        )
+      end
     end
-    packages.each_slice(100) do |packages_slice|
-      apt_cache_output = @system.run_command(
+
+    def run_apt_cache(packages_slice)
+      @system.run_command(
         "apt-cache",
         "show",
         *packages_slice.map { |p| "#{p.name}=#{[p.version, p.release].compact.join("-")}" },
         stdout: :capture
       )
-
-      apt_cache_elements = Hash[
-        *apt_cache_output.split("\n\n").flat_map do |element|
-          name = element[/Package: (\w+)$/, 1]
-          [name, element]
-        end
-      ]
-
-      packages_slice.each do |package|
-        name = package.name.sub(/:[^:]+$/, "")
-        apt_cache_element = apt_cache_elements[name]
-        if apt_cache_element
-          checksum = apt_cache_element[/MD5sum: (\w+)\n/, 1]
-          vendor = apt_cache_element[/Origin: (\w+)\n/, 1]
-        end
-        package.checksum = checksum || ""
-        package.vendor = vendor || ""
-        package.release ||= ""
-      end
+    rescue Cheetah::ExecutionFailed => e
+      # Older Debian systems do not support the version parameter for `apt-cache show`
+      raise unless e.stderr.include?("E: No packages found")
+      @system.run_command("apt-cache", "show", *packages_slice.map(&:name), stdout: :capture)
     end
-
-    @description.packages = PackagesScope.new(
-      packages.sort_by(&:name),
-      package_system: "dpkg"
-    )
   end
 end