machinery-tool 1.16.4 → 1.17.0

data/plugins/services/services_inspector.rb

@@ -24,28 +24,28 @@ class ServicesInspector < Inspector
   end
 
   def inspect(_filter, _options = {})
-    if @description.environment.system_type == "docker"
-      result = ServicesScope.new(
-        init_system: "none",
-        services: []
-      )
-    elsif @system.has_command?("systemctl")
-      result = ServicesScope.new(
-        init_system: "systemd",
-        services: inspect_systemd_services
-      )
-    else
-      result = ServicesScope.new(
-        init_system: "sysvinit",
-        services: inspect_sysvinit_services
-      )
-    end
-
-    @description.services = result
+    services, init_system =
+      case
+      when @description.environment.system_type == "docker"
+        then [[], "none"]
+      when @system.has_command?("systemctl")
+        then [inspect_systemd_services, "systemd"]
+      when @system.has_command?("initctl") && @system.has_command?("chkconfig")
+        then [parse_redhat_chkconfig.map { |s| s["legacy_sysv"] = true; s }, "upstart"]
+      when @system.has_command?("initctl") && !@system.has_command?("chkconfig")
+        then [inspect_ubuntu_services, "upstart"]
+      else
+        [inspect_sysvinit_services, "sysvinit"]
+      end
+
+    @description.services = ServicesScope.new(
+      services,
+      init_system: init_system
+    )
   end
 
   def summary
-    "Found #{@description.services.services.length} services."
+    "Found #{@description.services.length} services."
   end
 
   private
@@ -68,7 +68,7 @@ class ServicesInspector < Inspector
       Service.new(name: name, state: state)
     end
 
-    ServiceList.new(services.sort_by(&:name))
+    services.sort_by(&:name)
   end
 
   def inspect_sysvinit_services
@@ -84,7 +84,73 @@ class ServicesInspector < Inspector
       services = parse_suse_chkconfig
     end
 
-    ServiceList.new(services.sort_by(&:name))
+    services.sort_by(&:name)
+  end
+
+  def inspect_ubuntu_services
+    # Ubuntu is managing its services using upstart but also has some
+    # services still not handled by that. Therefor we need to scan upstart
+    # and sysV to determine all services and their bootup state
+    services = parse_ubuntu_upstart
+    parse_ubuntu_sysv.each do |service|
+      services << service unless services.find { |s| s.name == service.name }
+    end
+
+    services.sort_by(&:name)
+  end
+
+  def parse_ubuntu_upstart
+    initctl_output = @system.run_command("/sbin/initctl", "show-config", "-e", stdout: :capture)
+
+    servicelist = initctl_output.lines.map(&:chomp).slice_before { |l| !l.start_with?(" ") }
+    enabled, disabled = servicelist.partition do |s|
+      s.find { |e| e.start_with?("  start on runlevel", "  start on startup") }
+    end
+
+    services = enabled.map(&:first).each.map do |name|
+      Service.new(name: name, state: "enabled", legacy_sysv: false)
+    end
+    services + disabled.map(&:first).each.map do |name|
+      Service.new(name: name, state: "disabled", legacy_sysv: false)
+    end
+  end
+
+  def parse_ubuntu_sysv
+    # Get all sysV services
+    out, err = @system.run_command(
+      "/usr/sbin/service",
+      "--status-all",
+      stdout: :capture, stderr: :capture)
+    services_output = out + err
+
+    sysv_all = services_output.each_line.map { |line|
+      line.chomp.sub(/^.*\]../, "")
+    }
+
+    # Get all enabled sysV services - default in ubuntu1404 is runlevel 2
+    # and runlevels 3,4 and 5 are considered to be identical to 2.
+    runlevels = ["2", "S"]
+    find_output = runlevels.each.map do |runlevel|
+      @system.run_command(
+        "/usr/bin/find",
+        "/etc/rc#{runlevel}.d",
+        "-name",
+        "S\*",
+        stdout: :capture).split
+    end
+
+    sysv_enabled = find_output.flatten.map { |line|
+      line.chomp.sub(/^\/etc\/rc.\.d\/.../, "")
+    }.uniq
+    sysv_disabled = sysv_all - sysv_enabled
+
+    services = sysv_enabled.map.each do |name|
+      Service.new(name: name, state: "enabled", legacy_sysv: true)
+    end
+
+    services + sysv_disabled.map.each do |name|
+      Service.new(name: name, state: "disabled", legacy_sysv: true)
+    end
   end
 
   def parse_suse_chkconfig
@@ -97,7 +163,7 @@ class ServicesInspector < Inspector
       :stdout => :capture
     )
 
-    services = output.lines.map do |line|
+    output.lines.map do |line|
       name, state = line.split(/\s+/)
       Service.new(name: name, state: state)
     end

data/plugins/services/services_model.rb

@@ -28,21 +28,19 @@ class Service < Machinery::Object
   end
 end
 
-class ServiceList < Machinery::Array
-  has_elements class: Service
-end
-
-class ServicesScope < Machinery::Object
+class ServicesScope < Machinery::Array
   include Machinery::Scope
-  has_property :services, class: ServiceList
+
+  has_attributes :init_system
+  has_elements class: Service
 
   def compare_with(other)
     if self.init_system != other.init_system
       [self, other, nil, nil]
     else
-      only_self = self.services - other.services
-      only_other = other.services - self.services
-      common = self.services & other.services
+      only_self = self - other
+      only_other = other - self
+      common = self & other
       changed = Machinery::Scope.extract_changed_elements(only_self, only_other, :name)
       changed = nil if changed.empty?
 
@@ -51,17 +49,13 @@ class ServicesScope < Machinery::Object
         service_list_to_scope(only_other),
         changed,
         service_list_to_scope(common)
-      ]
+      ].map { |e| (e && !e.empty?) ? e : nil }
     end
   end
 
-  def length
-    services.try(:length) || 0
-  end
-
   private
 
   def service_list_to_scope(services)
-    self.class.new(init_system: init_system, services: services) if !services.empty?
+    self.class.new(services, init_system: init_system) unless services.elements.empty?
   end
 end

data/plugins/services/services_renderer.rb

@@ -19,12 +19,12 @@ class ServicesRenderer < Renderer
   def content(description)
     return unless description["services"]
 
-    if description["services"].services.empty?
+    if description["services"].elements.empty?
       puts "There are no services."
     end
 
     list do
-      description["services"].services.each do |p|
+      description["services"].each do |p|
         item "#{p.name}: #{p.state}"
       end
     end

data/plugins/unmanaged_files/schema/system-description-unmanaged-files.schema-v6.json

@@ -0,0 +1,162 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+
+  "type": "object",
+  "required": [
+    "_elements"
+  ],
+  "properties": {
+    "_attributes": {
+      "type": "object",
+      "required": [
+        "extracted"
+      ],
+      "properties": {
+        "extracted": {
+          "type": "boolean"
+        }
+      }
+    },
+    "_elements": {
+      "oneOf": [
+        {
+          "type": "array",
+          "maxItems": 0
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "anyOf": [
+              {
+                "$ref": "#/definitions/file_extracted"
+              },
+              {
+                "$ref": "#/definitions/file_remote_dir"
+              }
+            ]
+          }
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "anyOf": [
+              {
+                "$ref": "#/definitions/file_not_extracted"
+              },
+              {
+                "$ref": "#/definitions/file_remote_dir"
+              }
+            ]
+          }
+        }
+      ]
+    }
+  },
+  "definitions": {
+    "file_common": {
+      "type": "object",
+      "required": ["name"],
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+    "file_not_extracted": {
+      "allOf": [
+        { "$ref": "#/definitions/file_common" },
+        {
+          "required": ["type"],
+          "properties": {
+            "type": {
+              "enum": ["file", "dir", "link", "remote_dir"]
+            }
+          },
+          "not": { "$ref": "#/definitions/file_extracted" }
+        }
+      ]
+    },
+    "file_extracted": {
+      "allOf": [
+        { "$ref": "#/definitions/file_common" },
+        {
+          "required": ["user", "group"],
+          "properties": {
+          "user": {
+          "type": "string",
+          "minLength": 1
+          },
+          "group": {
+          "type": "string",
+          "minLength": 1
+          }
+          },
+          "oneOf": [
+          { "$ref": "#/definitions/file_extracted_file" },
+          { "$ref": "#/definitions/file_extracted_dir" },
+          { "$ref": "#/definitions/file_extracted_link" }
+          ]
+        }
+      ]
+    },
+    "file_extracted_file": {
+      "required": ["type", "size", "mode"],
+      "properties": {
+        "type": {
+          "enum": ["file"]
+        },
+        "size": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "mode": {
+          "type": "string",
+          "pattern": "^[0-7]{3,4}$"
+        }
+      }
+    },
+    "file_extracted_dir": {
+      "required": ["type", "size", "mode", "files"],
+      "properties": {
+        "type": {
+          "enum": ["dir"]
+        },
+        "size": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "mode": {
+          "type": "string",
+          "pattern": "^[0-4]?[0-7]{3}$"
+        },
+        "files": {
+          "type": "integer",
+          "minimum": 1
+        }
+      }
+    },
+    "file_extracted_link": {
+      "required": ["type"],
+      "properties": {
+        "type": {
+          "enum": ["link"]
+        }
+      }
+    },
+    "file_remote_dir": {
+      "allOf": [
+        { "$ref": "#/definitions/file_common" },
+        {
+          "required": ["type"],
+          "properties": {
+            "type": {
+              "enum": ["remote_dir"]
+            }
+          }
+        }
+      ]
+    }
+  }
+}

data/plugins/unmanaged_files/unmanaged_files_inspector.rb

@@ -20,7 +20,7 @@ class UnmanagedFilesInspector < Inspector
 
   # checks if all required binaries are present
   def check_requirements(check_tar)
-    @system.check_requirement("rpm", "--version")
+    @system.check_requirement(["rpm", "dpkg"], "--version")
     @system.check_requirement("sed", "--version")
     @system.check_requirement("cat", "--version")
     @system.check_requirement("find", "--version")
@@ -34,6 +34,7 @@ class UnmanagedFilesInspector < Inspector
       ["sed", "s/^\\(.\\)[^/]* /\\1 /"],
       :stdout => :capture
     )
+
     files = {}
     dirh = {}
     links = {}
@@ -52,13 +53,27 @@ class UnmanagedFilesInspector < Inspector
         files[pair.first] = pair[1]
       end
     end
+
+    process_managed_files_and_dirs(files, dirh)
+  end
+
+  def extract_dpkg_database
+    out = @system.run_script_with_progress("dpkg_unmanaged_files.sh")
+    parsed_data = parse_dpkg_package_files_output(out)
+    files = parsed_data[:files]
+    dirh = parsed_data[:directories]
+
+    process_managed_files_and_dirs(files, dirh)
+  end
+
+  def process_managed_files_and_dirs(files, dirs)
     # make sure that all parent directories of managed rpm directories are considered
     # managed
-    dirh.dup.keys.each do |d|
+    dirs.dup.keys.each do |d|
       dir = d.rpartition("/").first
 
-      while !dirh.has_key?(dir) && dir.size > 1
-        dirh[dir] = false
+      while !dirs.key?(dir) && dir.size > 1
+        dirs[dir] = false
         dir = dir[0..dir.rindex("/") - 1]
       end
     end
@@ -68,18 +83,36 @@ class UnmanagedFilesInspector < Inspector
 
       # make sure that dirs leading to a managed file are treated as if they were
       # in rpm database, otherwise we cannot exclude whole unmanaged trees
-      while( !dirh.has_key?(dir) && dir.size > 1 )
-        dirh[dir] = false
+      while !dirs.key?(dir) && dir.size > 1
+        dirs[dir] = false
         dir=dir[0..dir.rindex("/") - 1]
       end
 
       # put links to a managed directory also into directory hash
-      if !e.empty? && dirh.has_key?(e)
-        dirh[f] = false
+      if !e.empty? && dirs.key?(e)
+        dirs[f] = false
       end
     end
-    Machinery.logger.debug "extract_rpm_database files:#{files.size} dirs:#{dirh.size}"
-    [files, dirh]
+
+    [files, dirs]
+  end
+
+  def parse_dpkg_package_files_output(data)
+    result = { files: {}, directories: {} }
+
+    data.each_line do |line|
+      type, value = line.chomp.split(" ", 2)
+
+      if type == "-" # file
+        result[:files][value] = ""
+      elsif type == "d" && value != "/." # directory
+        result[:directories][value] = true
+      elsif type == "l" # link
+        pair = value.split(" -> ", 2)
+        result[:files][pair[0]] = pair[1]
+      end
+    end
+    result
   end
 
   def check_consistency(files, dirh)
@@ -219,6 +252,8 @@ class UnmanagedFilesInspector < Inspector
     do_extract = options && options[:extract_unmanaged_files]
     check_requirements(do_extract)
 
+    determine_package_manager
+
     scope = UnmanagedFilesScope.new
 
     file_store_tmp = @description.scope_file_store("unmanaged_files.tmp")
@@ -226,8 +261,8 @@ class UnmanagedFilesInspector < Inspector
 
     scope.scope_file_store = file_store_tmp
 
-    file_filter = filter.element_filter_for("/unmanaged_files/files/name").dup if filter
-    file_filter ||= ElementFilter.new("/unmanaged_files/files/name")
+    file_filter = filter.element_filter_for("/unmanaged_files/name").dup if filter
+    file_filter ||= ElementFilter.new("/unmanaged_files/name")
     file_filter.add_matchers("=", @description.store.base_path)
 
     # Add a recursive pendant to each ignored element
@@ -244,6 +279,14 @@ class UnmanagedFilesInspector < Inspector
     end
   end
 
+  def determine_package_manager
+    if @system.has_command?("rpm")
+      @package_manager = "rpm"
+    elsif @system.has_command?("dpkg")
+      @package_manager = "dpkg"
+    end
+  end
+
   def helper_usable?(helper)
     if !helper.can_help?
       Machinery::Ui.puts(
@@ -254,7 +297,7 @@ class UnmanagedFilesInspector < Inspector
       Machinery::Ui.puts(
         "Note: Using traditional inspection because only 'root' is supported as remote user."
       )
-    else
+    elsif ["rpm", "dpkg"].include?(@package_manager)
       return true
     end
 
@@ -272,8 +315,7 @@ class UnmanagedFilesInspector < Inspector
       end
 
       helper.run_helper(scope)
-
-      scope.files.delete_if { |f| filter.matches?(f.name) }
+      scope.delete_if { |f| filter.matches?(f.name) }
 
       if do_extract
         mount_points = MountPoints.new(@system)
@@ -282,16 +324,16 @@ class UnmanagedFilesInspector < Inspector
         file_store_tmp.remove
         file_store_tmp.create
 
-        files = scope.files.select { |f| f.file? || f.link? }.map(&:name)
+        files = scope.select { |f| f.file? || f.link? }.map(&:name)
         scope.retrieve_files_from_system_as_archive(@system, files, [])
         show_extraction_progress(files.count)
 
         scope.retrieve_trees_from_system_as_archive(@system,
-          scope.files.select(&:directory?).map(&:name), excluded_trees) do |count|
+          scope.select(&:directory?).map(&:name), excluded_trees) do |count|
           show_extraction_progress(files.count + count)
         end
 
-        scope.files = extract_tar_metadata(scope.files, file_store_tmp.path)
+        scope = extract_tar_metadata(scope, file_store_tmp.path)
         file_store_final.remove
         file_store_tmp.rename(file_store_final.store_name)
         scope.scope_file_store = file_store_final
@@ -310,7 +352,11 @@ class UnmanagedFilesInspector < Inspector
   def run_inspection(file_filter, options, do_extract, file_store_tmp, file_store_final, scope)
     mount_points = MountPoints.new(@system)
 
-    rpm_files, rpm_dirs = extract_rpm_database
+    if @package_manager == "rpm"
+      inspected_files, inspected_dirs = extract_rpm_database
+    elsif @package_manager == "dpkg"
+      inspected_files, inspected_dirs = extract_dpkg_database
+    end
 
     # Btrfs subvolumes and local mounts need to be inspected separately because
     # they are not part of the `get_find_data` return data
@@ -359,7 +405,8 @@ class UnmanagedFilesInspector < Inspector
       if !local_filesystems.empty?
         # force all mount points to be non-leave directories (find is called with -xdev)
         local_filesystems.each do |mp|
-          dirs[mp] = true if dirs.has_key?(mp)
+          path = mp.sub(/^\//, "")
+          dirs[path] = true if dirs.key?(path)
         end
         local_filesystems.reject! { |mp| dirs.has_key?(mp) }
       end
@@ -372,7 +419,7 @@ class UnmanagedFilesInspector < Inspector
           file_filter.matches?("/" + dir)
         end
       end
-      managed, unmanaged = dirs.keys.partition{ |d| rpm_dirs.has_key?(find_dir + d) }
+      managed, unmanaged = dirs.keys.partition { |d| inspected_dirs.key?(find_dir + d) }
 
       # unmanaged dirs lead to removal of files and dirs below that dir
       while !unmanaged.empty?
@@ -408,7 +455,7 @@ class UnmanagedFilesInspector < Inspector
       dirs_todo.push(*managed)
 
       # unmanaged files are simply stored
-      managed, unmanaged = files.keys.partition{ |d| rpm_files.has_key?(find_dir + d) }
+      managed, unmanaged = files.keys.partition { |d| inspected_files.key?(find_dir + d) }
       links = unmanaged.reject { |d| files[d].empty? }
       unmanaged.map!{ |d| find_dir + d }
       unmanaged_files.push(*unmanaged)
@@ -426,8 +473,7 @@ class UnmanagedFilesInspector < Inspector
       excluded_files, remote_dirs, do_extract, file_store_tmp, file_store_final, scope)
 
     scope.extracted = !!do_extract
-    scope.files = UnmanagedFileList.new(processed_files.sort_by(&:name))
-
+    scope += processed_files.sort_by(&:name)
     @description["unmanaged_files"] = scope
   end
 
@@ -477,7 +523,7 @@ class UnmanagedFilesInspector < Inspector
 
   def summary
     "#{@description.unmanaged_files.extracted ? "Extracted" : "Found"} " +
-      "#{@description.unmanaged_files.files.count} unmanaged files and trees."
+      "#{@description.unmanaged_files.count} unmanaged files and trees."
   end
 
   private
@@ -490,10 +536,14 @@ class UnmanagedFilesInspector < Inspector
   end
 
   def btrfs_subvolumes
-    @system.run_command(
-      ["btrfs", "subvolume", "list", "/"],
-      ["awk", "{print $NF}"],
-      stdout: :capture
-    ).split
+    if @system.has_command?("/sbin/btrfs")
+      @system.run_command(
+        ["/sbin/btrfs", "subvolume", "list", "/"],
+        ["awk", "{print $NF}"],
+        stdout: :capture
+      ).split
+    else
+      []
+    end
   end
 end