machinery-tool 1.22.1 → 1.22.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dacdd7ed294b3fa071ce5c205cff0c9bc4888c33
-  data.tar.gz: e5679c290377bd246cbde4d82c3bab5ad64c2ef7
+  metadata.gz: da0041ff3a8d3c178063228340914aca550a308f
+  data.tar.gz: e333966071f57a102961d8de5eb57f47d0cea5a2
 SHA512:
-  metadata.gz: b66684bde79b39bb03551a8249a600b1c9c1811df5582ae4d48559c240a4dfc46a975e6bbb8425747216a576599297cb43b2419385cb15be5d36c5dd94569572
-  data.tar.gz: aba642cb4e81b629a4cf1aa6a0090c97507b2995ba36097387eaed96a0a7f7f107ce976f3af602655b042f4c557ba4d2425655557ce884614d29df4133d3e86b
+  metadata.gz: 99fa10a1ff34c692d35638a5aaef0b411456e3f183ee822b4d803a1366b65ad7cc52b1be636e6df78ce4914bfbca17201efa7954f09efe0ab1f13dfbcff1a846
+  data.tar.gz: f612d4f45396600d41b6b579077bd85bce57768386b109a2bf549f25c8818e9ec48c8d8138ac1dec35ecfd31027464e4179ac0319129d7e74c43e622c674680f

data/.git_revision

@@ -1 +1 @@
-c9cc765d7146920c59d05dd9e483a82eb5f836df
+5544d3469a45c0bf15d3263bc1bbbd32afb7f274

data/NEWS

@@ -1,6 +1,16 @@
 # Machinery Release Notes
 
 
+## Version 1.22.2 - Wed Nov 16 16:44:00 CET 2016 - thardeck@suse.de
+
+* Prevent machinery-helper from crashing when files are inaccessible during
+  inspection (bnc#1009774)
+* Fix analyze of changed-config-files when NFS or SMB repositories are
+  used (gh#SUSE/machinery#2132)
+* Do not add repositories which require registration to built images (bnc#1004697)
+* Fix package inspection on older Debian systems
+* Fix extraction of information for Debian packages containing a dash in their name
+
 ## Version 1.22.1 - Fri Oct 14 16:13:50 CEST 2016 - thardeck@suse.de
 
 * Only use sudo for reading files when necessary (gh#SUSE/machinery#2077)

data/bin/machinery

@@ -38,7 +38,7 @@ begin
   command_log = "Executing (Version #{Machinery::VERSION}) '#{$PROGRAM_NAME} #{ARGV.join(" ")}'"
   command_log += " (store: #{ENV["MACHINERY_DIR"]})" if ENV["MACHINERY_DIR"]
   Machinery.logger.info command_log
-  Cli.run(ARGV)
+  Machinery::Cli.run(ARGV)
 rescue Machinery::Errors::IncompatibleHost => e
   puts e
 end

data/lib/analyze_changed_config_files_diffs_task.rb

@@ -15,11 +15,11 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class AnalyzeConfigFileDiffsTask
+class Machinery::AnalyzeConfigFileDiffsTask
   def analyze(description)
     description.assert_scopes("os")
     check_os(description)
-    LocalSystem.validate_existence_of_packages(["zypper"])
+    Machinery::LocalSystem.validate_existence_of_packages(["zypper"])
     description.validate_analysis_compatibility
     description.assert_scopes(
       "repositories",
@@ -55,7 +55,7 @@ class AnalyzeConfigFileDiffsTask
         end
 
         package.files.each do |file|
-          diff = Rpm.new(path).diff(file, File.join(extracted_files_path, file))
+          diff = Machinery::Rpm.new(path).diff(file, File.join(extracted_files_path, file))
 
           if !diff || diff.empty?
             Machinery::Ui.warn "Warning: Could not generate diff for #{file}."
@@ -76,7 +76,7 @@ class AnalyzeConfigFileDiffsTask
   private
 
   def check_os(description)
-    unless description.os.is_a?(OsSuse)
+    unless description.os.is_a?(Machinery::OsSuse)
       raise Machinery::Errors::AnalysisFailed.new(
         "Can not analyze the system description because its operating system" \
           " '#{description.os.display_name}' is not supported."
@@ -100,7 +100,7 @@ class AnalyzeConfigFileDiffsTask
 
     files.inject({}) do |result, file|
         key = "#{file.package_name}-#{file.package_version}"
-        result[key] ||= Package.new(
+        result[key] ||= Machinery::Package.new(
           "name"    => file["package_name"],
           "version" => file["package_version"],
           "files"   => []
@@ -114,7 +114,7 @@ class AnalyzeConfigFileDiffsTask
   def with_repositories(description, &block)
     Machinery::Ui.puts "Setting up repository access..."
     arch = description.os.architecture
-    Zypper.isolated(arch: arch) do |zypper|
+    Machinery::Zypper.isolated(arch: arch) do |zypper|
       begin
         remote_repos = description.repositories.reject do |repo|
           repo.url.start_with?("cd://") || repo.url.start_with?("dvd://")

data/lib/autoyast.rb

@@ -15,7 +15,7 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class Autoyast < Exporter
+class Machinery::Autoyast < Machinery::Exporter
   attr_accessor :name
 
   def initialize(description)
@@ -110,7 +110,7 @@ class Autoyast < Exporter
   private
 
   def check_exported_os
-    unless @system_description.os.is_a?(OsSuse)
+    unless @system_description.os.is_a?(Machinery::OsSuse)
       raise Machinery::Errors::ExportFailed.new(
         "Export is not possible because the operating system " \
         "'#{@system_description.os.display_name}' is not supported."

data/lib/build_task.rb

@@ -15,23 +15,26 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class BuildTask
+class Machinery::BuildTask
   def build(system_description, output_path, options = {})
-    LocalSystem.validate_architecture("x86_64")
-    LocalSystem.validate_existence_of_packages(["kiwi", "kiwi-desc-vmxboot"])
+    Machinery::LocalSystem.validate_architecture("x86_64")
+    Machinery::LocalSystem.validate_existence_of_packages(["kiwi", "kiwi-desc-vmxboot"])
     system_description.validate_build_compatibility
 
     tmp_config_dir = Dir.mktmpdir("machinery-config", "/tmp")
     tmp_image_dir = Dir.mktmpdir("machinery-image", "/tmp")
     img_extension = "qcow2"
 
-    config = KiwiConfig.new(system_description, options)
+    config = Machinery::KiwiConfig.new(system_description, options)
     config.write(tmp_config_dir)
 
     begin
       FileUtils.mkdir_p(output_path)
     rescue Errno::EACCES
-      raise Machinery::Errors::BuildDirectoryCreateError.new(output_path, CurrentUser.new.username)
+      raise Machinery::Errors::BuildDirectoryCreateError.new(
+        output_path,
+        Machinery::CurrentUser.new.username
+      )
     end
 
     if tmp_image_dir.start_with?("/tmp/") && tmp_config_dir.start_with?("/tmp/")
@@ -40,7 +43,7 @@ class BuildTask
 
       begin
         with_c_locale do
-          LoggedCheetah.run(
+          Machinery::LoggedCheetah.run(
             "sudo",
             tmp_script.path,
             stdout: $stdout,
@@ -68,7 +71,7 @@ class BuildTask
 
           Machinery::Ui.warn "Cleaning up temporary files..."
           [tmp_config_dir, tmp_image_dir].each do |path|
-            LoggedCheetah.run("sudo", "rm", "-r", path) if Dir.exist?(path)
+            Machinery::LoggedCheetah.run("sudo", "rm", "-r", path) if Dir.exist?(path)
           end
         end
         raise

data/lib/cli.rb

@@ -15,672 +15,756 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class Cli
-  extend GLI::App
+module Machinery
+  class Cli
+    extend GLI::App
+
+    program_desc "A systems management toolkit for Linux"
+    preserve_argv(true)
+    @version = "#{Machinery::VERSION} (system description format version "\
+      "#{SystemDescription::CURRENT_FORMAT_VERSION})"
+    @config = Machinery::Config.new
+    switch :version, negatable: false, desc: "Show version"
+    switch :debug, negatable: false, desc: "Enable debug mode"
+    switch [:help, :h], negatable: false, desc: "Show help"
+
+    sort_help :manually
+    pre do |global_options, command, _options, args|
+      Machinery.logger.level = if global_options[:debug]
+        Logger::DEBUG
+      else
+        Logger::INFO
+      end
 
-  program_desc 'A systems management toolkit for Linux'
-  preserve_argv(true)
-  @version = Machinery::VERSION + " (system description format version " +
-    "#{SystemDescription::CURRENT_FORMAT_VERSION})"
-  @config = Machinery::Config.new
-  switch :version, negatable: false, desc: "Show version"
-  switch :debug, negatable: false, desc: "Enable debug mode"
-  switch [:help, :h], negatable: false, desc: "Show help"
+      validate_command_line(command.arguments, args)
 
-  sort_help :manually
-  pre do |global_options,command,options,args|
-    if global_options[:debug]
-      Machinery.logger.level = Logger::DEBUG
-    else
-      Machinery.logger.level = Logger::INFO
+      true
     end
 
-    validate_command_line(command.arguments, args)
+    post do |global_options, command, _options, _args|
+      if (command.is_a?(GLI::Commands::Help) &&
+        !global_options[:version]) || ARGV == ["help"]
 
-    true
-  end
+        Machinery::Ui.puts "\nFor more detailed information, open the "\
+          "documentation by typing 'machinery man --html'.\nIf you are unable "\
+          "to find a solution within the man page visit our wiki page\nat "\
+          "https://github.com/SUSE/machinery/wiki"
 
-  post do |global_options,command,options,args|
-    if (command.is_a?(GLI::Commands::Help) && !global_options[:version]) || ARGV == ["help"]
-
-      Machinery::Ui.puts "\nFor more detailed information, open the documentation by typing " \
-        "'machinery man --html'.\nIf you are unable to find a solution within the man page " \
-        "visit our wiki page\nat https://github.com/SUSE/machinery/wiki"
+        Machinery::Ui.puts "\nMachinery can show hints which guide through a "\
+          "typical workflow."
+        if @config.hints
+          Machinery::Ui.puts "These hints can be switched off by " \
+            "'#{Ui::Hint.program_name} config hints=off'."
+        else
+          Machinery::Ui.puts "These hints can be switched on by " \
+            "'#{Ui::Hint.program_name} config hints=on'."
+        end
 
-      Machinery::Ui.puts "\nMachinery can show hints which guide through a typical workflow."
-      if @config.hints
-        Machinery::Ui.puts "These hints can be switched off by " \
-          "'#{Hint.program_name} config hints=off'."
-      else
-        Machinery::Ui.puts "These hints can be switched on by " \
-          "'#{Hint.program_name} config hints=on'."
+        Ui::Hint.print(:get_started)
       end
-
-      Hint.print(:get_started)
-    end
-    Machinery::Ui.close_pager
-  end
-
-  GLI::Commands::Help.skips_post = false
-
-  def self.validate_command_line(defined, parsed)
-    if defined.any?(&:multiple?) && !defined.any?(&:optional?) && parsed.empty?
-      message = "No arguments given. Nothing to do."
-      raise GLI::BadCommandLine.new(message)
-    elsif !defined.any?(&:multiple?) && parsed.size > defined.size
-      parsed_arguments = "#{parsed.size} #{Machinery.pluralize(parsed.size, "argument")}"
-      defined_arguments = defined.empty? ? "none" : "only: #{defined.map(&:name).join(", ")}"
-      message = "Too many arguments: got #{parsed_arguments}, expected #{defined_arguments}"
-      raise GLI::BadCommandLine.new(message)
+      Machinery::Ui.close_pager
     end
-  end
 
-  def self.handle_error(e)
-    Machinery::Ui.kill_pager
-
-    case e
-    when GLI::MissingRequiredArgumentsException
-      Machinery::Ui.error("Option --" + e.message)
-      exit 1
-    when GLI::UnknownCommandArgument, GLI::UnknownGlobalArgument,
-      GLI::UnknownCommand, GLI::BadCommandLine,
-      OptionParser::MissingArgument, OptionParser::AmbiguousOption
-      Machinery::Ui.error e.to_s + "\n\n"
-      command = ARGV & @commands.keys.map(&:to_s)
-      Machinery::Ui.error "Run '#{Hint.program_name} #{command.first} --help' for more information."
-      exit 1
-    when Machinery::Errors::MachineryError
-      Machinery.logger.error(e.message)
-      Machinery::Ui.error e.message
-      exit 1
-    when SystemExit
-      raise
-    when SignalException
-      Machinery.logger.info "Machinery was aborted with signal #{e.signo}."
-      exit 1
-    when Errno::ENOSPC
-      Machinery::Ui.error("Error: " + e.message)
-      exit 1
-    else
-      if LocalSystem.os.canonical_name.include? ("SUSE Linux Enterprise")
-        Machinery::Ui.error "Machinery experienced an unexpected error.\n" \
-        "If this impacts your business please file a service request at " \
-        "https://www.suse.com/mysupport\n" \
-        "so that we can assist you on this issue. An active support contract is required.\n"
-      else
-        Machinery::Ui.error "Machinery experienced an unexpected error. Please file a " \
-          "bug report at: https://github.com/SUSE/machinery/issues/new\n"
-      end
-
-      if e.is_a?(Cheetah::ExecutionFailed)
-        result = ""
-        result << "#{e.message}\n"
-        result << "\n"
-
-        if e.stderr && !e.stderr.empty?
-          result << "Error output:\n"
-          result << "#{e.stderr}\n"
+    GLI::Commands::Help.skips_post = false
+
+    def self.validate_command_line(defined, parsed)
+      if defined.any?(&:multiple?) &&
+          !defined.any?(&:optional?) &&
+          parsed.empty?
+        message = "No arguments given. Nothing to do."
+        raise GLI::BadCommandLine.new(message)
+      elsif !defined.any?(&:multiple?) && parsed.size > defined.size
+        parsed_arguments = "#{parsed.size} "\
+          "#{Machinery.pluralize(parsed.size, "argument")}"
+        defined_arguments = if defined.empty?
+          "none"
+        else
+          "only: #{defined.map(&:name).join(", ")}"
         end
+        message = "Too many arguments: got #{parsed_arguments}, "\
+          "expected #{defined_arguments}"
+        raise GLI::BadCommandLine.new(message)
+      end
+    end
 
-        if e.stdout && !e.stdout.empty?
-          result << "Standard output:\n"
-          result << "#{e.stdout}\n\n"
-        end
+    def self.handle_error(e)
+      Machinery::Ui.kill_pager
 
-        if e.backtrace && !e.backtrace.empty?
-          result << "Backtrace:\n"
-          result << "#{e.backtrace.join("\n")}\n\n"
-        end
-        Machinery.logger.error(result)
-        Machinery::Ui.error result
+      case e
+      when GLI::MissingRequiredArgumentsException
+        Machinery::Ui.error("Option --" + e.message)
         exit 1
-      else
-        Machinery.logger.error("Machinery experienced an unexpected error:")
+      when GLI::UnknownCommandArgument, GLI::UnknownGlobalArgument,
+        GLI::UnknownCommand, GLI::BadCommandLine,
+        OptionParser::MissingArgument, OptionParser::AmbiguousOption
+        Machinery::Ui.error e.to_s + "\n\n"
+        command = ARGV & @commands.keys.map(&:to_s)
+        Machinery::Ui.error "Run '#{Ui::Hint.program_name} #{command.first} "\
+          "--help' for more information."
+        exit 1
+      when Machinery::Errors::MachineryError
         Machinery.logger.error(e.message)
-        Machinery.logger.error(e.backtrace.join("\n"))
+        Machinery::Ui.error e.message
+        exit 1
+      when SystemExit
         raise
+      when SignalException
+        Machinery.logger.info "Machinery was aborted with signal #{e.signo}."
+        exit 1
+      when Errno::ENOSPC
+        Machinery::Ui.error("Error: " + e.message)
+        exit 1
+      else
+        if LocalSystem.os.canonical_name.include? "SUSE Linux Enterprise"
+          Machinery::Ui.error "Machinery experienced an unexpected error.\n" \
+            "If this impacts your business please file a service request at " \
+            "https://www.suse.com/mysupport\n" \
+            "so that we can assist you on this issue. An active support "\
+            "contract is required.\n"
+        else
+          Machinery::Ui.error "Machinery experienced an unexpected error. "\
+            "Please file a bug report at: "\
+            "https://github.com/SUSE/machinery/issues/new\n"
+        end
+
+        if e.is_a?(Cheetah::ExecutionFailed)
+          result = ""
+          result << "#{e.message}\n"
+          result << "\n"
+
+          if e.stderr && !e.stderr.empty?
+            result << "Error output:\n"
+            result << "#{e.stderr}\n"
+          end
+
+          if e.stdout && !e.stdout.empty?
+            result << "Standard output:\n"
+            result << "#{e.stdout}\n\n"
+          end
+
+          if e.backtrace && !e.backtrace.empty?
+            result << "Backtrace:\n"
+            result << "#{e.backtrace.join("\n")}\n\n"
+          end
+          Machinery.logger.error(result)
+          Machinery::Ui.error result
+          exit 1
+        else
+          Machinery.logger.error("Machinery experienced an unexpected error:")
+          Machinery.logger.error(e.message)
+          Machinery.logger.error(e.backtrace.join("\n"))
+          raise
+        end
       end
+      true
     end
-    true
-  end
 
-  def self.check_container_name!(image, name)
-    if image == name && !SystemDescription.valid_name?(name)
-      raise Machinery::Errors::InvalidCommandLine.new(
-        "Error: System description name '#{name}' is invalid. By default Machinery" \
-          " uses the image name as description name if the parameter `--name` is not" \
-          " provided.\nIf the image name contains a slash the `--name=NAME` parameter" \
-          " is mandatory. Valid characters are 'a-zA-Z0-9_:.-'.\n\nFor example run:\n" \
-          "#{Hint.program_name} #{ARGV.join(" ")} --name='#{image.tr("/", "_")}'"
-      )
+    def self.check_container_name!(image, name)
+      if image == name && !SystemDescription.valid_name?(name)
+        raise Machinery::Errors::InvalidCommandLine,
+          "Error: System description name '#{name}' is invalid. By default "\
+          "Machinery uses the image name as description name if the "\
+          "parameter `--name` is not provided.\nIf the image name contains "\
+          "a slash the `--name=NAME` parameter is mandatory. "\
+          "Valid characters are 'a-zA-Z0-9_:.-'.\n\nFor example run:\n" \
+          "#{Ui::Hint.program_name} #{ARGV.join(" ")} "\
+          "--name='#{image.tr("/", "_")}'"
+      end
     end
-  end
 
-  on_error do |e|
-    Cli.handle_error(e)
-  end
+    on_error do |e|
+      Cli.handle_error(e)
+    end
 
-  def self.show_filter_note(scopes, filter)
-    if scopes.any? { |scope| !filter.element_filters_for_scope(scope).empty? }
-      Machinery::Ui.puts "\nNote: There are filters being applied during inspection. " \
-        "(Use `--verbose` option to show the filters)\n\n"
+    def self.show_filter_note(scopes, filter)
+      if scopes.any? { |scope| !filter.element_filters_for_scope(scope).empty? }
+        Machinery::Ui.puts "\nNote: There are filters being applied during "\
+          "inspection. (Use `--verbose` option to show the filters)\n\n"
+      end
     end
-  end
 
-  def self.shift_arg(args, name)
-    unless res = args.shift
-      raise GLI::BadCommandLine.new("You need to provide the required argument #{name}.")
+    def self.shift_arg(args, name)
+      unless res = args.shift
+        raise GLI::BadCommandLine,
+          "You need to provide the required argument #{name}."
+      end
+      res
     end
-    res
-  end
 
-  def self.process_scope_option(scopes, exclude_scopes)
-    if scopes
-      if exclude_scopes
+    def self.process_scope_option(scopes, exclude_scopes)
+      if scopes && exclude_scopes
         # scope and ignore-scope
-        raise Machinery::Errors::InvalidCommandLine.new("You cannot provide the --scope and " \
-          "--ignore-scope option at the same time.")
-      else
+        raise Machinery::Errors::InvalidCommandLine,
+          "You cannot provide the --scope and "\
+          "--ignore-scope option at the same time."
+      elsif scopes && !exclude_scopes
         # scope only
         scope_list = parse_scopes(scopes)
-      end
-    else
-      if exclude_scopes
+      elsif !scopes && exclude_scopes
         # ignore-scope only
         scope_list = Inspector.all_scopes - parse_scopes(exclude_scopes)
-      else
+      elsif !scopes && !exclude_scopes
         # neither scope nor ignore-scope
         scope_list = Inspector.all_scopes
       end
+      if scope_list.empty?
+        raise Machinery::Errors::InvalidCommandLine,
+          "No scopes to process. Nothing to do."
+      end
+      scope_list
     end
-    if scope_list.empty?
-      raise Machinery::Errors::InvalidCommandLine.new( "No scopes to process. Nothing to do.")
-    end
-    scope_list
-  end
 
-  def self.parse_scopes(scope_string)
-    unknown_scopes = []
-    invalid_scopes = []
-    scopes = []
+    def self.parse_scopes(scope_string)
+      unknown_scopes = []
+      invalid_scopes = []
+      scopes = []
+
+      scope_string.split(",").each do |scope|
+        unless scope =~ /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/
+          invalid_scopes << scope
+          next
+        end
+
+        if scope == "config-files"
+          Machinery::Ui.warn(
+            "The scope name `config-files` is deprecated. "\
+            "The new name is `changed-config-files`."
+          )
+          scope = "changed-config-files"
+        end
+
+        # convert cli scope naming to internal one
+        scope.tr!("-", "_")
 
-    scope_string.split(",").each do |scope|
-      unless scope =~ /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/
-        invalid_scopes << scope
-        next
+        if Inspector.all_scopes.include?(scope) && Ui::Renderer.for(scope)
+          scopes << scope
+        else
+          unknown_scopes << scope
+        end
       end
 
-      if scope == "config-files"
-        Machinery::Ui.warn(
-          "The scope name `config-files` is deprecated. The new name is `changed-config-files`."
+      unless invalid_scopes.empty?
+        form = invalid_scopes.length > 1 ? "scopes are" : "scope is"
+        raise Machinery::Errors::UnknownScope.new(
+          "The following #{form} not valid:" \
+            " '#{invalid_scopes.join("', '")}'." \
+            " Scope names must start with a letter and contain only lowercase" \
+            " letters and digits separated by dashes ('-')."
         )
-        scope = "changed-config-files"
       end
 
-      # convert cli scope naming to internal one
-      scope.tr!("-", "_")
-
-      if Inspector.all_scopes.include?(scope) && Renderer.for(scope)
-        scopes << scope
-      else
-        unknown_scopes << scope
+      unless unknown_scopes.empty?
+        form = unknown_scopes.length > 1 ? "scopes are" : "scope is"
+        raise Machinery::Errors::UnknownScope.new(
+          "The following #{form} not supported: " \
+            "#{Machinery::Ui.internal_scope_list_to_string(unknown_scopes)}. " \
+          "Valid scopes are: #{AVAILABLE_SCOPE_LIST}."
+        )
       end
+
+      Inspector.sort_scopes(scopes.uniq)
     end
 
-    if invalid_scopes.length > 0
-      form = invalid_scopes.length > 1 ? "scopes are" : "scope is"
-      raise Machinery::Errors::UnknownScope.new(
-        "The following #{form} not valid:" \
-          " '#{invalid_scopes.join("', '")}'." \
-          " Scope names must start with a letter and contain only lowercase" \
-          " letters and digits separated by dashes ('-')."
-      )
+    def self.supports_filtering(command)
+      if @config.experimental_features
+        command.flag :exclude,
+          negatable: false,
+          desc:      "Exclude elements matching the filter criteria"
+      end
     end
 
-    if unknown_scopes.length > 0
-      form = unknown_scopes.length > 1 ? "scopes are" : "scope is"
-      raise Machinery::Errors::UnknownScope.new(
-        "The following #{form} not supported: " \
-          "#{Machinery::Ui.internal_scope_list_to_string(unknown_scopes)}. " \
-        "Valid scopes are: #{AVAILABLE_SCOPE_LIST}."
-      )
+    def self.check_port_validity(port)
+      if port < 2 || port > 65_535
+        raise Machinery::Errors::ServerPortError,
+          "The specified port '#{port}' is not valid. " \
+          "A valid port can be in a range between 2 and 65535."
+      elsif port >= 2 && port <= 1_023 && !CurrentUser.new.is_root?
+        raise Machinery::Errors::ServerPortError,
+          "The specified port '#{port}' needs root privileges. "\
+          "Otherwise, the server cannot be started. All ports " \
+          "in a range of 2-1023 need root privileges."
+      end
     end
 
-    Inspector.sort_scopes(scopes.uniq)
-  end
+    AVAILABLE_SCOPE_LIST = Machinery::Ui.internal_scope_list_to_string(
+      Inspector.all_scopes
+    )
 
-  def self.supports_filtering(command)
-    if @config.experimental_features
-      command.flag :exclude, negatable: false, desc: "Exclude elements matching the filter criteria"
-    end
-  end
+    desc "Analyze system description"
+    long_desc <<-LONGDESC
+      Analyze stored system description.
 
-  def self.check_port_validity(port)
-    if port < 2 || port > 65535
-      raise Machinery::Errors::ServerPortError.new("The specified port '#{port}' is not " \
-        "valid. A valid port can be in a range between 2 and 65535.")
-    else
-      if port >= 2 && port <= 1023 && !CurrentUser.new.is_root?
-        raise Machinery::Errors::ServerPortError.new("The specified port '#{port}' needs " \
-          "root privileges. Otherwise, the server cannot be started. All ports in a range " \
-          "of 2-1023 need root privileges.")
-      end
-    end
-  end
+      The supported operations are:
 
-  AVAILABLE_SCOPE_LIST = Machinery::Ui.internal_scope_list_to_string(
-    Inspector.all_scopes
-  )
-
-  desc "Analyze system description"
-  long_desc <<-LONGDESC
-    Analyze stored system description.
-
-    The supported operations are:
-
-    - changed-config-files-diffs: Generate diffs against the original version from
-      the package for the changed configuration files
-  LONGDESC
-  arg "NAME"
-  command "analyze" do |c|
-    c.flag [:operation, :o], type: String, required: false,
-      desc: "The analyze operation to perform", arg_name: "OPERATION", default_value: "changed-config-files-diffs"
-
-    c.action do |global_options,options,args|
-      name = shift_arg(args, "NAME")
-      description = SystemDescription.load(name, system_description_store)
-
-      case options[:operation]
-      when "changed-config-files-diffs"
-        task = AnalyzeConfigFileDiffsTask.new
-        task.analyze(description)
-        Hint.print(:show_analyze_data, name: name)
-      else
-        raise Machinery::Errors::InvalidCommandLine.new(
-          "The operation '#{options[:operation]}' is not supported. " \
-          "Valid operations are: changed-config-files-diffs."
-        )
+      - changed-config-files-diffs: Generate diffs against the original
+        version from the package for the changed configuration files
+    LONGDESC
+    arg "NAME"
+    command "analyze" do |c|
+      c.flag [:operation, :o],
+        type:          String,
+        required:      false,
+        desc:          "The analyze operation to perform",
+        arg_name:      "OPERATION",
+        default_value: "changed-config-files-diffs"
+
+      c.action do |_global_options, options, args|
+        name = shift_arg(args, "NAME")
+        description = SystemDescription.load(name, system_description_store)
+
+        case options[:operation]
+        when "changed-config-files-diffs"
+          task = AnalyzeConfigFileDiffsTask.new
+          task.analyze(description)
+          Ui::Hint.print(:show_analyze_data, name: name)
+        else
+          raise Machinery::Errors::InvalidCommandLine,
+            "The operation '#{options[:operation]}' is not supported. " \
+            "Valid operations are: changed-config-files-diffs."
+        end
       end
     end
-  end
 
 
 
-  desc "Build image from system description"
-  long_desc <<-LONGDESC
-    Build image from a given system description and store it to the given
-    location.
-  LONGDESC
-  arg "NAME"
-  command "build" do |c|
-    c.flag ["image-dir", :i], type: String, required: true,
-      desc: "Store the image under the specified path", arg_name: "DIRECTORY"
-    c.switch ["enable-dhcp", :d], required: false, negatable: false,
-      desc: "Enable DCHP client on first network card of built image"
-    c.switch ["enable-ssh", :s], required: false, negatable: false,
-      desc: "Enable SSH service in built image"
-
-    c.action do |global_options,options,args|
-      name = shift_arg(args, "NAME")
-      description = SystemDescription.load(name, system_description_store)
-
-      task = BuildTask.new
-      task.build(
-        description, File.expand_path(options["image-dir"]),
-        enable_dhcp: options["enable-dhcp"], enable_ssh: options["enable-ssh"]
-      )
-    end
-  end
+    desc "Build image from system description"
+    long_desc <<-LONGDESC
+      Build image from a given system description and store it to the given
+      location.
+    LONGDESC
+    arg "NAME"
+    command "build" do |c|
+      c.flag ["image-dir", :i],
+        type:     String,
+        required: true,
+        desc:     "Store the image under the specified path",
+        arg_name: "DIRECTORY"
+      c.switch ["enable-dhcp", :d],
+        required:  false,
+        negatable: false,
+        desc:      "Enable DCHP client on first network card of built image"
+      c.switch ["enable-ssh", :s],
+        required:  false,
+        negatable: false,
+        desc:      "Enable SSH service in built image"
 
+      c.action do |_global_options, options, args|
+        name = shift_arg(args, "NAME")
+        description = SystemDescription.load(name, system_description_store)
 
+        task = BuildTask.new
+        task.build(
+          description,
+          File.expand_path(options["image-dir"]),
+          enable_dhcp: options["enable-dhcp"],
+          enable_ssh:  options["enable-ssh"]
+        )
+      end
+    end
 
-  desc "Compare system descriptions"
-  long_desc <<-LONGDESC
-    Compare system descriptions stored under specified names.
 
-    Multiple scopes can be passed as comma-separated list. If no specific scopes
-    are given, all scopes are compared.
 
-    Available scopes: #{AVAILABLE_SCOPE_LIST}
-  LONGDESC
-  arg "NAME1"
-  arg "NAME2"
-  command "compare" do |c|
-    c.flag [:scope, :s], type: String, required: false,
-      desc: "Compare specified scopes", arg_name: "SCOPE_LIST"
-    c.flag ["ignore-scope", :e], type: String, required: false,
-      desc: "Exclude specified scopes", arg_name: "SCOPE_LIST"
-    c.switch "show-all", required: false, negatable: false,
-      desc: "Show also common properties"
-    c.switch "html", required: false, negatable: false,
-      desc: "Open comparison in HTML format in your web browser."
-    c.switch "pager", required: false, default_value: true,
-      desc: "Pipe output into a pager"
+    desc "Compare system descriptions"
+    long_desc <<-LONGDESC
+      Compare system descriptions stored under specified names.
 
-    c.action do |global_options,options,args|
-      Machinery::Ui.use_pager = options[:pager]
+      Multiple scopes can be passed as comma-separated list. If no
+      specific scopes are given, all scopes are compared.
 
-      name1 = shift_arg(args, "NAME1")
-      name2 = shift_arg(args, "NAME2")
+      Available scopes: #{AVAILABLE_SCOPE_LIST}
+    LONGDESC
+    arg "NAME1"
+    arg "NAME2"
+    command "compare" do |c|
+      c.flag [:scope, :s],
+        type:     String,
+        required: false,
+        desc:     "Compare specified scopes",
+        arg_name: "SCOPE_LIST"
+      c.flag ["ignore-scope", :e],
+        type:     String,
+        required: false,
+        desc:     "Exclude specified scopes",
+        arg_name: "SCOPE_LIST"
+      c.switch "show-all",
+        required:  false,
+        negatable: false,
+        desc:      "Show also common properties"
+      c.switch "html",
+        required:  false,
+        negatable: false,
+        desc:      "Open comparison in HTML format in your web browser."
+      c.switch "pager",
+        required:      false,
+        default_value: true,
+        desc:          "Pipe output into a pager"
 
-      if options[:html]
-        begin
-          check_port_validity(@config.http_server_port)
-        rescue Machinery::Errors::ServerPortError => e
-          raise Machinery::Errors::InvalidCommandLine.new(e.message + " The port can be " \
-            "specified in the 'http_server_port' section of the configuration file.")
+      c.action do |_global_options, options, args|
+        Machinery::Ui.use_pager = options[:pager]
+
+        name1 = shift_arg(args, "NAME1")
+        name2 = shift_arg(args, "NAME2")
+
+        if options[:html]
+          begin
+            check_port_validity(@config.http_server_port)
+          rescue Machinery::Errors::ServerPortError => e
+            raise Machinery::Errors::InvalidCommandLine,
+              "#{e.message} The port can be specified in the " \
+              "'http_server_port' section of the configuration file."
+          end
         end
-      end
 
-      store = system_description_store
-      description1 = SystemDescription.load(name1, store)
-      description2 = SystemDescription.load(name2, store)
-      scope_list = process_scope_option(options[:scope], options["ignore-scope"])
-
-      task = CompareTask.new
-      opts = {
-        show_html: options["html"],
-        show_all: options["show-all"],
-        ip: "127.0.0.1",
-        port: @config.http_server_port
-      }
-      task.compare(description1, description2, scope_list, opts)
+        store = system_description_store
+        description1 = SystemDescription.load(name1, store)
+        description2 = SystemDescription.load(name2, store)
+        scope_list =
+          process_scope_option(options[:scope], options["ignore-scope"])
+
+        task = CompareTask.new
+        opts = {
+          show_html: options["html"],
+          show_all: options["show-all"],
+          ip: "127.0.0.1",
+          port: @config.http_server_port
+        }
+        task.compare(description1, description2, scope_list, opts)
+      end
     end
-  end
 
 
 
-  desc "Copy system description"
-  long_desc <<-LONGDESC
-    Copy a system description.
+    desc "Copy system description"
+    long_desc <<-LONGDESC
+      Copy a system description.
 
-    The system description is copied and stored under the provided name.
-  LONGDESC
-  arg "FROM_NAME"
-  arg "TO_NAME"
-  command "copy" do |c|
-    c.action do |global_options,options,args|
-      from = shift_arg(args, "FROM_NAME")
-      to = shift_arg(args, "TO_NAME")
-      task = CopyTask.new
-      task.copy(system_description_store, from, to)
+      The system description is copied and stored under the provided name.
+    LONGDESC
+    arg "FROM_NAME"
+    arg "TO_NAME"
+    command "copy" do |c|
+      c.action do |_global_options, _options, args|
+        from = shift_arg(args, "FROM_NAME")
+        to = shift_arg(args, "TO_NAME")
+        task = CopyTask.new
+        task.copy(system_description_store, from, to)
+      end
     end
-  end
 
-  desc "Move system description"
-  long_desc <<-LONGDESC
-    Move a system description.
-
-    The system description name is changed to the provided name.
-  LONGDESC
-  arg "FROM_NAME"
-  arg "TO_NAME"
-  command "move" do |c|
-    c.action do |_global_options, _options, args|
-      from = shift_arg(args, "FROM_NAME")
-      to = shift_arg(args, "TO_NAME")
-      task = MoveTask.new
-      task.move(system_description_store, from, to)
+    desc "Move system description"
+    long_desc <<-LONGDESC
+      Move a system description.
+
+      The system description name is changed to the provided name.
+    LONGDESC
+    arg "FROM_NAME"
+    arg "TO_NAME"
+    command "move" do |c|
+      c.action do |_global_options, _options, args|
+        from = shift_arg(args, "FROM_NAME")
+        to = shift_arg(args, "TO_NAME")
+        task = MoveTask.new
+        task.move(system_description_store, from, to)
+      end
     end
-  end
 
 
-  desc "Deploy image to OpenStack cloud"
-  long_desc <<-LONGDESC
-    Deploy system description as image to OpenStack cloud.
-
-    The image will be deployed to the OpenStack cloud. If no --image-dir is
-    specified an image will be built from the description before deployment.
-  LONGDESC
-  arg "NAME"
-  command "deploy" do |c|
-    c.flag ["cloud-config", :c], type: String, required: true, arg_name: "FILE",
-      desc: "Path to file where the cloud config (openrc.sh) is located"
-    c.flag ["image-dir", :i], type: String, required: false,
-      desc: "Directory where the image is located", arg_name: "DIRECTORY"
-    c.switch [:insecure, :s], required: false, negatable: false,
-      desc: "Explicitly allow glanceclient to perform 'insecure SSL' (https) requests."
-    c.flag ["cloud-image-name", :n], type: String, required: false,
-      desc: "Name of the image in the cloud", arg_name: "NAME"
-
-    c.action do |global_options,options,args|
-      name = shift_arg(args, "NAME")
-      description = SystemDescription.load(name, system_description_store)
-
-      task = DeployTask.new
-      opts = {
+    desc "Deploy image to OpenStack cloud"
+    long_desc <<-LONGDESC
+      Deploy system description as image to OpenStack cloud.
+
+      The image will be deployed to the OpenStack cloud. If no --image-dir is
+      specified an image will be built from the description before deployment.
+    LONGDESC
+    arg "NAME"
+    command "deploy" do |c|
+      c.flag ["cloud-config", :c],
+        type:     String,
+        required: true,
+        arg_name: "FILE",
+        desc:     "Path to file where the cloud config (openrc.sh) is located"
+      c.flag ["image-dir", :i],
+        type:     String,
+        required: false,
+        desc:     "Directory where the image is located",
+        arg_name: "DIRECTORY"
+      c.switch [:insecure, :s],
+        required:  false,
+        negatable: false,
+        desc:      "Explicitly allow glanceclient to perform "\
+                   "'insecure SSL' (https) requests."
+      c.flag ["cloud-image-name", :n],
+        type:     String,
+        required: false,
+        desc:     "Name of the image in the cloud",
+        arg_name: "NAME"
+
+      c.action do |_global_options, options, args|
+        name = shift_arg(args, "NAME")
+        description = SystemDescription.load(name, system_description_store)
+
+        task = DeployTask.new
+        opts = {
           image_name: options[:cloud_image_name],
-          insecure: options[:insecure]
-      }
-      opts[:image_dir] = File.expand_path(options["image-dir"]) if options["image-dir"]
-      task.deploy(description, File.expand_path(options["cloud-config"]), opts)
+          insecure:   options[:insecure]
+        }
+        if options["image-dir"]
+          opts[:image_dir] = File.expand_path(options["image-dir"])
+        end
+        task.deploy(
+          description,
+          File.expand_path(options["cloud-config"]),
+          opts
+        )
+      end
     end
-  end
 
 
 
-  desc  "Export system description as KIWI image description"
-  long_desc <<-LONGDESC
-    Export system description as KIWI image description.
+    desc "Export system description as KIWI image description"
+    long_desc <<-LONGDESC
+      Export system description as KIWI image description.
 
-    The description will be placed in a subdirectory at the given location. The image format in
-    the description is 'vmx'.
-  LONGDESC
-  arg "NAME"
-  command "export-kiwi" do |c|
-    c.flag ["kiwi-dir", :k], type: String, required: true,
-      desc: "Location where the description will be stored", arg_name: "DIRECTORY"
-    c.switch :force, default_value: false, required: false, negatable: false,
-      desc: "Overwrite existing directory"
+      The description will be placed in a subdirectory at the given location.
+      The image format in the description is 'vmx'.
+    LONGDESC
+    arg "NAME"
+    command "export-kiwi" do |c|
+      c.flag ["kiwi-dir", :k],
+        type:     String,
+        required: true,
+        desc:     "Location where the description will be stored",
+        arg_name: "DIRECTORY"
+      c.switch :force,
+        default_value: false,
+        required:      false,
+        negatable:     false,
+        desc:          "Overwrite existing directory"
 
-    c.action do |global_options,options,args|
-      name = shift_arg(args, "NAME")
-      description = SystemDescription.load(name, system_description_store)
-      exporter = KiwiConfig.new(description)
+      c.action do |_global_options, options, args|
+        name = shift_arg(args, "NAME")
+        description = SystemDescription.load(name, system_description_store)
+        exporter = KiwiConfig.new(description)
 
-      task = ExportTask.new(exporter)
-      task.export(
-        File.expand_path(options["kiwi-dir"]),
-        force: options[:force]
-      )
+        task = ExportTask.new(exporter)
+        task.export(
+          File.expand_path(options["kiwi-dir"]),
+          force: options[:force]
+        )
+      end
     end
-  end
 
-  desc "Export system description as AutoYaST profile"
-  long_desc <<-LONGDESC
-    Export system description as AutoYaST profile
-
-    The profile will be placed in a subdirectory at the given location by the 'autoyast-dir'
-    option.
-  LONGDESC
-  arg "NAME"
-  command "export-autoyast" do |c|
-    c.flag ["autoyast-dir", :a], type: String, required: true,
-      desc: "Location where the autoyast profile will be stored", arg_name: "DIRECTORY"
-    c.switch :force, default_value: false, required: false, negatable: false,
-      desc: "Overwrite existing directory"
-
-    c.action do |_global_options, options, args|
-      name = shift_arg(args, "NAME")
-      description = SystemDescription.load(name, system_description_store)
-      exporter = Autoyast.new(description)
-
-      task = ExportTask.new(exporter)
-      task.export(
-        File.expand_path(options["autoyast-dir"]),
-        force: options[:force]
-      )
-    end
-  end
+    desc "Export system description as AutoYaST profile"
+    long_desc <<-LONGDESC
+      Export system description as AutoYaST profile
 
-  desc "Export static HTML view of a system description"
-  long_desc <<-LONGDESC
-    Export system description as HTML
-
-    The HTML view will be placed in a subdirectory at the given location by the 'html-dir'
-    option.
-  LONGDESC
-  arg "NAME"
-  command "export-html" do |c|
-    c.flag ["html-dir", :d], type: String, required: true,
-      desc: "Location where the HTML view will be stored", arg_name: "DIRECTORY"
-    c.switch :force, default_value: false, required: false, negatable: false,
-      desc: "Overwrite existing directory"
-
-    c.action do |_global_options, options, args|
-      name = shift_arg(args, "NAME")
-      description = SystemDescription.load(name, system_description_store)
-      exporter = StaticHtml.new(description, options["html-dir"])
-      exporter.create_directory(options[:force])
-      exporter.write
-    end
-  end
+      The profile will be placed in a subdirectory at the given location by
+      the 'autoyast-dir' option.
+    LONGDESC
+    arg "NAME"
+    command "export-autoyast" do |c|
+      c.flag ["autoyast-dir", :a],
+        type:     String,
+        required: true,
+        desc:     "Location where the autoyast profile will be stored",
+        arg_name: "DIRECTORY"
+      c.switch :force,
+        default_value: false,
+        required:      false,
+        negatable:     false,
+        desc:          "Overwrite existing directory"
 
-  def self.define_inspect_command_options(c)
-    c.flag [:name, :n], type: String, required: false, arg_name: "NAME",
-      desc: "Store system description under the specified name"
-    c.flag [:scope, :s], type: String, required: false,
-      desc: "Inspect specified scopes", arg_name: "SCOPE_LIST"
-    c.flag ["ignore-scope", :e], type: String, required: false,
-      desc: "Exclude specified scopes", arg_name: "SCOPE_LIST"
-    c.flag "skip-files", required: false, negatable: false,
-      desc: "Do not consider given files or directories during inspection. " \
-        "Either provide one file or directory name or a list of names separated by commas."
-    c.switch ["extract-files", :x], required: false, negatable: false,
-      desc: "Extract changed configuration files and unmanaged files from inspected system"
-    if @config.experimental_features
-      c.switch ["extract-metadata", :m], required: false, negatable: false,
-        desc: "Extract unmanaged files metadata without extracting the files."
-    end
-    c.switch "extract-changed-config-files", required: false, negatable: false,
-      desc: "Extract changed configuration files from inspected system"
-    c.switch "extract-unmanaged-files", required: false, negatable: false,
-      desc: "Extract unmanaged files from inspected system"
-    c.switch "extract-changed-managed-files", required: false, negatable: false,
-      desc: "Extract changed managed files from inspected system"
-    c.switch :show, required: false, negatable: false,
-      desc: "Print inspection result"
-    c.switch :verbose, required: false, negatable: false,
-      desc: "Display the filters which are used during inspection"
-  end
+      c.action do |_global_options, options, args|
+        name = shift_arg(args, "NAME")
+        description = SystemDescription.load(name, system_description_store)
+        exporter = Autoyast.new(description)
 
-  def self.parse_inspect_command_options(host, options)
-    scope_list = process_scope_option(options[:scope], options["ignore-scope"])
-    name = options[:name] || host
+        task = ExportTask.new(exporter)
+        task.export(
+          File.expand_path(options["autoyast-dir"]),
+          force: options[:force]
+        )
+      end
+    end
 
+    desc "Export static HTML view of a system description"
+    long_desc <<-LONGDESC
+      Export system description as HTML
 
-    unless scope_list.empty?
-      inspected_scopes = " for #{Machinery::Ui.internal_scope_list_to_string(scope_list)}"
-    end
-    Machinery::Ui.puts "Inspecting #{host}#{inspected_scopes}..."
+      The HTML view will be placed in a subdirectory at the given location by
+      the 'html-dir' option.
+    LONGDESC
+    arg "NAME"
+    command "export-html" do |c|
+      c.flag ["html-dir", :d],
+        type:     String,
+        required: true,
+        desc:     "Location where the HTML view will be stored",
+        arg_name: "DIRECTORY"
+      c.switch :force,
+        default_value: false,
+        required:      false,
+        negatable:     false,
+        desc:          "Overwrite existing directory"
 
-    inspect_options = {}
-    if options["show"]
-      inspect_options[:show] = true
-    end
-    if options["verbose"]
-      inspect_options[:verbose] = true
-    end
-    if options["extract-files"] || options["extract-changed-config-files"]
-      inspect_options[:extract_changed_changed_config_files] = true
-    end
-    if options["extract-files"] || options["extract-changed-managed-files"]
-      inspect_options[:extract_changed_managed_files] = true
-    end
-    if options["extract-files"] || options["extract-unmanaged-files"]
-      inspect_options[:extract_unmanaged_files] = true
+      c.action do |_global_options, options, args|
+        name = shift_arg(args, "NAME")
+        description = SystemDescription.load(name, system_description_store)
+        exporter = StaticHtml.new(description, options["html-dir"])
+        exporter.create_directory(options[:force])
+        exporter.write
+      end
     end
-    if options["extract-metadata"]
-      inspect_options[:extract_metadata] = true
+
+    def self.define_inspect_command_options(c)
+      c.flag [:name, :n],
+        type:     String,
+        required: false,
+        arg_name: "NAME",
+        desc:     "Store system description under the specified name"
+      c.flag [:scope, :s],
+        type:     String,
+        required: false,
+        desc:     "Inspect specified scopes",
+        arg_name: "SCOPE_LIST"
+      c.flag ["ignore-scope", :e],
+        type:     String,
+        required: false,
+        desc:     "Exclude specified scopes",
+        arg_name: "SCOPE_LIST"
+      c.flag "skip-files",
+        required:  false,
+        negatable: false,
+        desc:      "Do not consider given files or directories during " \
+                   "inspection. Either provide one file or directory name "\
+                   "or a list of names separated by commas."
+      c.switch ["extract-files", :x],
+        required:  false,
+        negatable: false,
+        desc:      "Extract changed configuration files and unmanaged "\
+                   "files from inspected system"
+      if @config.experimental_features
+        c.switch ["extract-metadata", :m],
+          required:  false,
+          negatable: false,
+          desc:      "Extract unmanaged files metadata without "\
+                     "extracting the files."
+      end
+      c.switch "extract-changed-config-files",
+        required:  false,
+        negatable: false,
+        desc:      "Extract changed configuration files from inspected system"
+      c.switch "extract-unmanaged-files",
+        required:  false,
+        negatable: false,
+        desc:      "Extract unmanaged files from inspected system"
+      c.switch "extract-changed-managed-files",
+        required:  false,
+        negatable: false,
+        desc:      "Extract changed managed files from inspected system"
+      c.switch :show,
+        required:  false,
+        negatable: false,
+        desc:      "Print inspection result"
+      c.switch :verbose,
+        required:  false,
+        negatable: false,
+        desc:      "Display the filters which are used during inspection"
     end
 
-    filter = FilterOptionParser.parse("inspect", options)
+    def self.parse_inspect_command_options(host, options)
+      scope_list = process_scope_option(
+        options[:scope],
+        options["ignore-scope"]
+      )
+      name = options[:name] || host
 
-    if options["verbose"] && !filter.empty?
-      Machinery::Ui.puts "\nThe following filters are applied during inspection:"
-      Machinery::Ui.puts filter.to_array.join("\n") + "\n\n"
-    else
-      show_filter_note(scope_list, filter)
-    end
 
-    [name, scope_list, inspect_options, filter]
-  end
+      unless scope_list.empty?
+        inspected_scopes =
+          " for #{Machinery::Ui.internal_scope_list_to_string(scope_list)}"
+      end
+      Machinery::Ui.puts "Inspecting #{host}#{inspected_scopes}..."
 
-  desc "Inspect running system"
-  long_desc <<-LONGDESC
-    Inspect running system and generate system descripton from inspected data.
-
-    Multiple scopes can be passed as comma-separated list. If no specific scopes
-    are given, all scopes are inspected.
-
-    Available scopes: #{AVAILABLE_SCOPE_LIST}
-  LONGDESC
-  arg "HOSTNAME"
-  command "inspect" do |c|
-    supports_filtering(c)
-    define_inspect_command_options(c)
-    c.flag ["remote-user", :r], type: String, required: false, default_value: @config.remote_user,
-      desc: "Defines the user which is used to access the inspected system via SSH."\
-        "This user needs sudo access on the remote machine or be root.", arg_name: "USER"
-    c.flag ["ssh-port", :p], type: Integer, required: false,
-      desc: "The SSH port of the remote server.",
-      arg_name: "SSH-PORT"
-    c.flag ["ssh-identity-file", :i], type: String, required: false,
-      desc: "The private SSH key location what can be used to authenticate with the remote system.",
-      arg_name: "SSH-KEY"
-
-    c.action do |_global_options, options, args|
-      host = shift_arg(args, "HOSTNAME")
-      system = System.for(host, remote_user: options["remote-user"], ssh_port: options["ssh-port"],
-        ssh_identity_file: options["ssh-identity-file"])
-      inspector_task = InspectTask.new
-
-      name, scope_list, inspect_options, filter = parse_inspect_command_options(host, options)
-
-      inspector_task.inspect_system(
-        system_description_store,
-        system,
-        name,
-        CurrentUser.new,
-        scope_list,
-        filter,
-        inspect_options
-      )
+      inspect_options = {}
+      if options["show"]
+        inspect_options[:show] = true
+      end
+      if options["verbose"]
+        inspect_options[:verbose] = true
+      end
+      if options["extract-files"] || options["extract-changed-config-files"]
+        inspect_options[:extract_changed_changed_config_files] = true
+      end
+      if options["extract-files"] || options["extract-changed-managed-files"]
+        inspect_options[:extract_changed_managed_files] = true
+      end
+      if options["extract-files"] || options["extract-unmanaged-files"]
+        inspect_options[:extract_unmanaged_files] = true
+      end
+      if options["extract-metadata"]
+        inspect_options[:extract_metadata] = true
+      end
 
-      Hint.print(:show_data, name: name) if options[:show] == false
+      filter = FilterOptionParser.parse("inspect", options)
 
-      if !options["extract-files"] || Inspector.all_scopes.count != scope_list.count
-        Hint.print(:do_complete_inspection, name: name, host: host)
+      if options["verbose"] && !filter.empty?
+        Machinery::Ui.puts "\nThe following filters are applied "\
+          "during inspection:"
+        Machinery::Ui.puts filter.to_array.join("\n") + "\n\n"
+      else
+        show_filter_note(scope_list, filter)
       end
-    end
-  end
 
-  desc "Inspect container image"
-  long_desc <<-LONGDESC
-    Inspect container image and generate system descripton from inspected data.
-    Right now we only support docker images.
+      [name, scope_list, inspect_options, filter]
+    end
 
-    Multiple scopes can be passed as comma-separated list. If no specific scopes
-    are given, all scopes are inspected.
+    desc "Inspect running system"
+    long_desc <<-LONGDESC
+      Inspect running system and generate system descripton from inspected data.
 
-    Available scopes: #{AVAILABLE_SCOPE_LIST}
-  LONGDESC
-  arg "(IMAGENAME|IMAGEID)"
-  command "inspect-container" do |c|
-    supports_filtering(c)
-    define_inspect_command_options(c)
+      Multiple scopes can be passed as comma-separated list. If no specific
+      scopes are given, all scopes are inspected.
 
-    c.action do |_global_options, options, args|
-      image = shift_arg(args, "(IMAGENAME|IMAGEID)")
-      system = DockerSystem.new(image)
-      inspector_task = InspectTask.new
+      Available scopes: #{AVAILABLE_SCOPE_LIST}
+    LONGDESC
+    arg "HOSTNAME"
+    command "inspect" do |c|
+      supports_filtering(c)
+      define_inspect_command_options(c)
+      c.flag ["remote-user", :r],
+        type:          String,
+        required:      false,
+        default_value: @config.remote_user,
+        desc:          "Defines the user which is used to access the "\
+                       "inspected system via SSH. This user needs sudo "\
+                       "access on the remote machine or be root.",
+        arg_name:      "USER"
+      c.flag ["ssh-port", :p],
+        type:     Integer,
+        required: false,
+        desc:     "The SSH port of the remote server.",
+        arg_name: "SSH-PORT"
+      c.flag ["ssh-identity-file", :i],
+        type:     String,
+        required: false,
+        desc:     "The private SSH key location what can be used to "\
+                  "authenticate with the remote system.",
+        arg_name: "SSH-KEY"
 
-      name, scope_list, inspect_options, filter = parse_inspect_command_options(image, options)
+      c.action do |_global_options, options, args|
+        host = shift_arg(args, "HOSTNAME")
+        system = System.for(
+          host,
+          remote_user:       options["remote-user"],
+          ssh_port:          options["ssh-port"],
+          ssh_identity_file: options["ssh-identity-file"]
+        )
+        inspector_task = InspectTask.new
 
-      check_container_name!(image, name)
+        name, scope_list, inspect_options, filter =
+          parse_inspect_command_options(host, options)
 
-      begin
-        system.start
         inspector_task.inspect_system(
           system_description_store,
           system,
@@ -690,317 +774,437 @@ class Cli
           filter,
           inspect_options
         )
-      ensure
-        system.stop
-      end
 
-      Hint.print(:show_data, name: name) unless options[:show]
+        Ui::Hint.print(:show_data, name: name) if options[:show] == false
 
-      if !options["extract-files"] || Inspector.all_scopes.count != scope_list.count
-        Hint.print(:do_complete_inspection, name: name, docker_container: image)
+        if !options["extract-files"] ||
+            Inspector.all_scopes.count != scope_list.count
+          Ui::Hint.print(:do_complete_inspection, name: name, host: host)
+        end
       end
     end
-  end
 
-  desc "List system descriptions"
-  long_desc <<-LONGDESC
-    List all system descriptions and their stored scopes, when no NAME parameter is specified.
+    desc "Inspect container image"
+    long_desc <<-LONGDESC
+      Inspect container image and generate system descripton from inspected data.
+      Right now we only support docker images.
+
+      Multiple scopes can be passed as comma-separated list. If no specific scopes
+      are given, all scopes are inspected.
 
-    List only the specified system descriptions and its stored scopes, when NAME parameter is given.
+      Available scopes: #{AVAILABLE_SCOPE_LIST}
+    LONGDESC
+    arg "(IMAGENAME|IMAGEID)"
+    command "inspect-container" do |c|
+      supports_filtering(c)
+      define_inspect_command_options(c)
+
+      c.action do |_global_options, options, args|
+        image = shift_arg(args, "(IMAGENAME|IMAGEID)")
+        system = DockerSystem.new(image)
+        inspector_task = InspectTask.new
 
-    The date of modification for each scope can be shown with the verbose
-    option.
-  LONGDESC
-  arg "NAME", [:multiple, :optional]
+        name, scope_list, inspect_options, filter =
+          parse_inspect_command_options(image, options)
 
-  command "list" do |c|
-    c.switch :verbose, required: false, negatable: false,
-      desc: "Display additional information about origin of scopes"
-    c.switch :short, required: false, negatable: false,
-      desc: "List only description names"
-    c.switch :html, required: false, negatable: false,
-      desc: "Open overview of all system descriptions in HTML format in your web browser"
+        check_container_name!(image, name)
 
-    c.action do |global_options,options,args|
-      if options[:html]
         begin
-          check_port_validity(@config.http_server_port)
-        rescue Machinery::Errors::ServerPortError => e
-          raise Machinery::Errors::InvalidCommandLine.new(e.message + " The port can be " \
-            "specified in the 'http_server_port' section of the configuration file.")
+          system.start
+          inspector_task.inspect_system(
+            system_description_store,
+            system,
+            name,
+            CurrentUser.new,
+            scope_list,
+            filter,
+            inspect_options
+          )
+        ensure
+          system.stop
         end
-      end
 
-      opts = {
-        ip: "127.0.0.1",
-        port: @config.http_server_port
-      }.merge(options)
+        Ui::Hint.print(:show_data, name: name) unless options[:show]
 
-      task = ListTask.new
-      task.list(system_description_store, args, opts)
+        if !options["extract-files"] ||
+            Inspector.all_scopes.count != scope_list.count
+          Ui::Hint.print(
+            :do_complete_inspection,
+            name:             name,
+            docker_container: image
+          )
+        end
+      end
     end
-  end
 
-  desc "Shows man page"
-  long_desc <<-LONGDESC
-    Shows the man page of the machinery tool.
+    desc "List system descriptions"
+    long_desc <<-LONGDESC
+      List all system descriptions and their stored scopes, when no NAME
+      parameter is specified.
 
-  LONGDESC
-  command "man" do |c|
-    c.switch "html", required: false, negatable: false,
-      desc: "Open documentation in HTML format in your web browser."
+      List only the specified system descriptions and its stored scopes, when
+      NAME parameter is given.
 
-    c.action do |_global_options, options, _args|
-      options = {
-        ip: "127.0.0.1",
-        port: @config.http_server_port
-      }.merge(options)
+      The date of modification for each scope can be shown with the verbose
+      option.
+    LONGDESC
+    arg "NAME", [:multiple, :optional]
+
+    command "list" do |c|
+      c.switch :verbose,
+        required:  false,
+        negatable: false,
+        desc:      "Display additional information about origin of scopes"
+      c.switch :short,
+        required:  false,
+        negatable: false,
+        desc:      "List only description names"
+      c.switch :html,
+        required:  false,
+        negatable: false,
+        desc:      "Open overview of all system descriptions in "\
+                   "HTML format in your web browser"
 
-      task = ManTask.new
-      task.man(options)
-    end
-  end
+      c.action do |_global_options, options, args|
+        if options[:html]
+          begin
+            check_port_validity(@config.http_server_port)
+          rescue Machinery::Errors::ServerPortError => e
+            raise Machinery::Errors::InvalidCommandLine,
+              "#{e.message} The port can be specified in the "\
+              "'http_server_port' section of the configuration file."
+          end
+        end
 
+        opts = {
+          ip: "127.0.0.1",
+          port: @config.http_server_port
+        }.merge(options)
 
+        task = ListTask.new
+        task.list(system_description_store, args, opts)
+      end
+    end
 
-  desc "Remove system descriptions"
-  long_desc <<-LONGDESC
-    Removes all specified descriptions stored under the specified names.
+    desc "Shows man page"
+    long_desc <<-LONGDESC
+      Shows the man page of the machinery tool.
 
-    The success of a removal can be shown with the verbose option.
-  LONGDESC
-  arg "NAME", [:multiple, :optional]
+    LONGDESC
+    command "man" do |c|
+      c.switch "html",
+        required:  false,
+        negatable: false,
+        desc:      "Open documentation in HTML format in your web browser."
+
+      c.action do |_global_options, options, _args|
+        options = {
+          ip: "127.0.0.1",
+          port: @config.http_server_port
+        }.merge(options)
+
+        task = ManTask.new
+        task.man(options)
+      end
+    end
 
-  command "remove" do |c|
-    c.switch :all, negatable: false,
-      desc: "Remove all system descriptions"
-    c.switch :verbose, required: false, negatable: false,
-      desc: "Explain what is being done"
 
-    c.action do |global_options,options,args|
-      if !options[:all] && args.empty?
-        raise GLI::BadCommandLine.new, "You need to either specify `--all` or a list of system descriptions"
-      end
 
-      task = RemoveTask.new
-      task.remove(system_description_store, args, verbose: options[:verbose], all: options[:all])
-    end
-  end
+    desc "Remove system descriptions"
+    long_desc <<-LONGDESC
+      Removes all specified descriptions stored under the specified names.
 
+      The success of a removal can be shown with the verbose option.
+    LONGDESC
+    arg "NAME", [:multiple, :optional]
 
+    command "remove" do |c|
+      c.switch :all,
+        negatable: false,
+        desc:      "Remove all system descriptions"
+      c.switch :verbose,
+        required:  false,
+        negatable: false,
+        desc:      "Explain what is being done"
 
-  desc "Show system description"
-  long_desc <<-LONGDESC
-    Show system description stored under the specified name.
-
-    Multiple scopes can be passed as comma-separated list. If no specific scopes
-    are given, all scopes are shown.
-
-    Available scopes: #{AVAILABLE_SCOPE_LIST}
-  LONGDESC
-  arg "NAME"
-  command "show" do |c|
-    supports_filtering(c)
-    c.flag [:scope, :s], type: String, required: false,
-      desc: "Show specified scopes", arg_name: "SCOPE_LIST"
-    c.flag ["ignore-scope", :e], type: String, required: false,
-      desc: "Exclude specified scopes", arg_name: "SCOPE_LIST"
-    c.switch "pager", required: false, default_value: true,
-      desc: "Pipe output into a pager"
-    c.switch "show-diffs", required: false, negatable: false,
-      desc: "Show diffs of changed configuration files changes."
-    c.switch "html", required: false, negatable: false,
-      desc: "Open system description in HTML format in your web browser."
-    c.switch "verbose", required: false, negatable: false,
-      desc: "Show the filters that were applied before showing the description."
-
-    c.action do |global_options,options,args|
-      Machinery::Ui.use_pager = options["pager"]
-
-      if options[:html]
-        begin
-          check_port_validity(@config.http_server_port)
-        rescue Machinery::Errors::ServerPortError => e
-          raise Machinery::Errors::InvalidCommandLine.new(e.message + " The port can be " \
-            "specified in the 'http_server_port' section of the configuration file.")
+      c.action do |_global_options, options, args|
+        if !options[:all] && args.empty?
+          raise GLI::BadCommandLine,
+            "You need to either specify `--all` or a list of "\
+            "system descriptions"
         end
-      end
 
-      name = shift_arg(args, "NAME")
-      if name == "localhost" && !CurrentUser.new.is_root?
-        Machinery::Ui.puts "You need root rights to access the system description of your locally inspected system."
+        task = RemoveTask.new
+        task.remove(
+          system_description_store,
+          args,
+          verbose: options[:verbose],
+          all:     options[:all]
+        )
       end
+    end
 
-      description = SystemDescription.load(name, system_description_store)
-      scope_list = process_scope_option(options[:scope], options["ignore-scope"])
 
-      filter = FilterOptionParser.parse("show", options)
 
-      inspected_filters = description.filter_definitions("inspect")
+    desc "Show system description"
+    long_desc <<-LONGDESC
+      Show system description stored under the specified name.
 
-      if options[:verbose]
-        details = ""
+      Multiple scopes can be passed as comma-separated list. If no specific
+      scopes are given, all scopes are shown.
 
-        if description[:environment].system_type == "docker"
-          details += "\n  Type of inspected container: #{description[:environment].system_type}\n"
-        end
+      Available scopes: #{AVAILABLE_SCOPE_LIST}
+    LONGDESC
+    arg "NAME"
+    command "show" do |c|
+      supports_filtering(c)
+      c.flag [:scope, :s],
+        type:     String,
+        required: false,
+        desc:     "Show specified scopes",
+        arg_name: "SCOPE_LIST"
+      c.flag ["ignore-scope", :e],
+        type:     String,
+        required: false,
+        desc:     "Exclude specified scopes",
+        arg_name: "SCOPE_LIST"
+      c.switch "pager",
+        required:      false,
+        default_value: true,
+        desc:          "Pipe output into a pager"
+      c.switch "show-diffs",
+        required:  false,
+        negatable: false,
+        desc:      "Show diffs of changed configuration files changes."
+      c.switch "html",
+        required:  false,
+        negatable: false,
+        desc:      "Open system description in HTML format in your web browser."
+      c.switch "verbose",
+        required:  false,
+        negatable: false,
+        desc:      "Show the filters that were applied before "\
+                   "showing the description."
 
-        unless inspected_filters.empty?
-          details += "\n  The following filters were applied during inspection:"
-          details += "\n    * " + inspected_filters.join("\n    * ") + "\n\n"
+      c.action do |_global_options, options, args|
+        Machinery::Ui.use_pager = options["pager"]
+
+        if options[:html]
+          begin
+            check_port_validity(@config.http_server_port)
+          rescue Machinery::Errors::ServerPortError => e
+            raise Machinery::Errors::InvalidCommandLine,
+              "#{e.message} The port can be specified in the "\
+              "'http_server_port' section of the configuration file."
+          end
         end
 
-        unless filter.empty?
-          details += "\n  The following filters were applied before showing the description:"
-          details += "\n    * " + filter.to_array.join("\n    * ") + "\n\n"
+        name = shift_arg(args, "NAME")
+        if name == "localhost" && !CurrentUser.new.is_root?
+          Machinery::Ui.puts "You need root rights to access the system "\
+            "description of your locally inspected system."
         end
 
-        Machinery::Ui.puts "# Inspection details\n" + details unless details.empty?
+        description = SystemDescription.load(name, system_description_store)
+        scope_list = process_scope_option(
+          options[:scope],
+          options["ignore-scope"]
+        )
+
+        filter = FilterOptionParser.parse("show", options)
+
+        inspected_filters = description.filter_definitions("inspect")
+
+        if options[:verbose]
+          details = ""
+
+          if description[:environment].system_type == "docker"
+            details += "\n  Type of inspected container: "\
+            "#{description[:environment].system_type}\n"
+          end
+
+          unless inspected_filters.empty?
+            details += "\n  The following filters were applied during "\
+              "inspection:\n    * #{inspected_filters.join("\n    * ")}\n\n"
+          end
+
+          unless filter.empty?
+            details += "\n  The following filters were applied before "\
+              "showing the description:"
+            details += "\n    * " + filter.to_array.join("\n    * ") + "\n\n"
+          end
+
+          unless details.empty?
+            Machinery::Ui.puts "# Inspection details\n#{details}"
+          end
+        end
+        task = ShowTask.new
+        opts = {
+          show_diffs: options["show-diffs"],
+          show_html:  options["html"],
+          ip:         "127.0.0.1",
+          port:       @config.http_server_port
+        }
+        task.show(description, scope_list, filter, opts)
       end
-      task = ShowTask.new
-      opts = {
-        show_diffs: options["show-diffs"],
-        show_html: options["html"],
-        ip: "127.0.0.1",
-        port: @config.http_server_port
-      }
-      task.show(description, scope_list, filter, opts)
     end
-  end
 
 
-  desc "Validate system description"
-  long_desc <<-LONGDESC
-    Validate system description stored under the specified name.
-  LONGDESC
-  arg "NAME"
-  command "validate" do |c|
-    c.action do |global_options,options,args|
-      name = shift_arg(args, "NAME")
-      if name == "localhost" && !CurrentUser.new.is_root?
-        Machinery::Ui.puts "You need root rights to access the system description of your locally inspected system."
-      end
+    desc "Validate system description"
+    long_desc <<-LONGDESC
+      Validate system description stored under the specified name.
+    LONGDESC
+    arg "NAME"
+    command "validate" do |c|
+      c.action do |_global_options, _options, args|
+        name = shift_arg(args, "NAME")
+        if name == "localhost" && !CurrentUser.new.is_root?
+          Machinery::Ui.puts "You need root rights to access the system "\
+            "description of your locally inspected system."
+        end
 
-      task = ValidateTask.new
-      task.validate(system_description_store, name)
+        task = ValidateTask.new
+        task.validate(system_description_store, name)
+      end
     end
-  end
 
-  desc "Upgrade format of system description"
-  long_desc <<-LONGDESC
-    Upgrade the format of one or all system descriptions.
-  LONGDESC
-  arg "NAME"
-  command "upgrade-format" do |c|
-    c.switch :all, negatable: false,
-      desc: "Upgrade all system descriptions"
-    c.switch :force, default_value: false, required: false, negatable: false,
-      desc: "Keep backup after migration and ingnore validation errors"
-
-    c.action do |global_options,options,args|
-      name = shift_arg(args, "NAME") unless options[:all]
-
-      task = UpgradeFormatTask.new
-      task.upgrade(
-        system_description_store,
-        name,
-        all: options[:all],
-        force: options[:force]
-      )
+    desc "Upgrade format of system description"
+    long_desc <<-LONGDESC
+      Upgrade the format of one or all system descriptions.
+    LONGDESC
+    arg "NAME"
+    command "upgrade-format" do |c|
+      c.switch :all,
+        negatable: false,
+        desc:      "Upgrade all system descriptions"
+      c.switch :force,
+        default_value: false,
+        required:      false,
+        negatable:     false,
+        desc:          "Keep backup after migration and ignore "\
+                       "validation errors"
+
+      c.action do |_global_options, options, args|
+        name = shift_arg(args, "NAME") unless options[:all]
+
+        task = UpgradeFormatTask.new
+        task.upgrade(
+          system_description_store,
+          name,
+          all: options[:all],
+          force: options[:force]
+        )
+      end
     end
-  end
 
-  desc "Show or change machinery's configuration"
-  long_desc <<-LONGDESC
-    Show or change machinery's configuration.
+    desc "Show or change machinery's configuration"
+    long_desc <<-LONGDESC
+      Show or change machinery's configuration.
 
-    The value of a key is shown when no value argument is passed.
-    If neither the key argument nor the value argument are specified a list of all keys and their values are shown.
+      The value of a key is shown when no value argument is passed.
+      If neither the key argument nor the value argument are specified a list
+      of all keys and their values are shown.
 
-    ALTERNATIVE SYNOPSIS:
+      ALTERNATIVE SYNOPSIS:
 
-    machinery [global options] config [KEY][=VALUE]
-  LONGDESC
-  arg "KEY", :optional
-  arg "VALUE", :optional
-  command "config" do |c|
-    c.action do |global_options,options,args|
-      if args[0] && args[0].include?("=")
-        if args[1]
-          raise GLI::BadCommandLine, "Too many arguments: got 2 arguments, expected only: KEY=VALUE"
+      machinery [global options] config [KEY][=VALUE]
+    LONGDESC
+    arg "KEY", :optional
+    arg "VALUE", :optional
+    command "config" do |c|
+      c.action do |_global_options, _options, args|
+        if args[0] && args[0].include?("=")
+          if args[1]
+            raise GLI::BadCommandLine,
+              "Too many arguments: got 2 arguments, expected only: KEY=VALUE"
+          else
+            key, value = args[0].split("=")
+          end
         else
-          key, value = args[0].split("=")
+          key = args[0]
+          value = args[1]
         end
-      else
-        key = args[0]
-        value = args[1]
-      end
 
-      task = ConfigTask.new(@config)
-      task.config(key, value)
+        task = ConfigTask.new(@config)
+        task.config(key, value)
 
-      if key == "hints" && (value == "false" || value == "off")
-        Machinery::Ui.puts "Hints can be switched on again by " \
-          "'#{Hint.program_name} config hints=on'."
+        if key == "hints" && (value == "false" || value == "off")
+          Machinery::Ui.puts "Hints can be switched on again by " \
+            "'#{Ui::Hint.program_name} config hints=on'."
+        end
       end
     end
-  end
-
-  desc "Start a web server for viewing system descriptions"
-  long_desc <<-LONGDESC
-    Starts a web server which serves an HTML view of all system descriptions and
-    an overview page listing all descriptions.
-  LONGDESC
-  command "serve" do |c|
-    c.flag [:port, :p], type: Integer, required: false,
-      default_value: @config.http_server_port,
-      desc: "Listen on port PORT. Ports can be selected in a range between 2-65535. Ports between
-        2 and 1023 can only be chosen when `machinery` will be executed as `root` user.",
-        arg_name: "PORT"
-    c.switch "public", required: false, negatable: false,
-      desc: "Makes the server reachable from all IP addresses."
-
-    c.action do |_global_options, options, args|
-      begin
-        check_port_validity(options[:port])
-      rescue Machinery::Errors::ServerPortError => e
-        raise Machinery::Errors::InvalidCommandLine.new(e.message + " The port can be " \
-          "either specified in the 'http_server_port' section of the configuration file " \
-          "or via the --port option.")
-      end
-
-      task = ServeHtmlTask.new
-      task.serve(
-        system_description_store, port: options[:port], public: options[:public]
-      )
-    end
-  end
 
-  if @config.experimental_features
-    desc "Containerize a system description"
+    desc "Start a web server for viewing system descriptions"
     long_desc <<-LONGDESC
-      Detects workloads from a system description and creates a recommendation for a corresponding
-      container setup
+      Starts a web server which serves an HTML view of all system descriptions
+      and an overview page listing all descriptions.
     LONGDESC
-    arg "NAME"
-    command "containerize" do |c|
-      c.flag ["output-dir", :o], type: String, required: true,
-        desc: "Location where the container files will be stored", arg_name: "DIRECTORY"
+    command "serve" do |c|
+      c.flag [:port, :p],
+        type:          Integer,
+        required:      false,
+        default_value: @config.http_server_port,
+        desc:          "Listen on port PORT. Ports can be selected in a range "\
+                       "between 2-65535. Ports between 2 and 1023 can only be "\
+                       "chosen when `machinery` will be executed as `root` "\
+                       "user.",
+        arg_name:      "PORT"
+      c.switch "public",
+        required:  false,
+        negatable: false,
+        desc:      "Makes the server reachable from all IP addresses."
 
       c.action do |_global_options, options, args|
-        name = shift_arg(args, "NAME")
-        description = SystemDescription.load(name, system_description_store)
-        task = ContainerizeTask.new
-        task.containerize(description, File.expand_path(options["output-dir"]))
+        begin
+          check_port_validity(options[:port])
+        rescue Machinery::Errors::ServerPortError => e
+          raise Machinery::Errors::InvalidCommandLine,
+            "#{e.message} The port can be either specified in the "\
+            "'http_server_port' section of the configuration file " \
+            "or via the --port option."
+        end
+
+        task = ServeHtmlTask.new
+        task.serve(
+          system_description_store,
+          port:   options[:port],
+          public: options[:public]
+        )
+      end
+    end
+
+    if @config.experimental_features
+      desc "Containerize a system description"
+      long_desc <<-LONGDESC
+        Detects workloads from a system description and creates a recommendation
+        for a corresponding container setup
+      LONGDESC
+      arg "NAME"
+      command "containerize" do |c|
+        c.flag ["output-dir", :o],
+          type:     String,
+          required: true,
+          desc:     "Location where the container files will be stored",
+          arg_name: "DIRECTORY"
+
+        c.action do |_global_options, options, args|
+          name = shift_arg(args, "NAME")
+          description = SystemDescription.load(name, system_description_store)
+          task = ContainerizeTask.new
+          task.containerize(
+            description, File.expand_path(options["output-dir"])
+          )
+        end
       end
     end
-  end
 
-  def self.system_description_store
-    if ENV.key?("MACHINERY_DIR")
-      SystemDescriptionStore.new(ENV["MACHINERY_DIR"])
-    else
-      SystemDescriptionStore.new
+    def self.system_description_store
+      if ENV.key?("MACHINERY_DIR")
+        SystemDescriptionStore.new(ENV["MACHINERY_DIR"])
+      else
+        SystemDescriptionStore.new
+      end
     end
   end
 end