machinery-tool 1.5.0 → 1.6.0

data/lib/array.rb

@@ -22,30 +22,36 @@ module Machinery
         @element_class = options[:class]
       end
 
-      def from_json(json)
-        elements = json.map do |element|
-          if @element_class
-            @element_class.from_json(element)
+      def convert_element(element)
+        if @element_class
+          element.is_a?(@element_class) ? element : @element_class.from_json(element)
+        else
+          case element
+          when ::Array
+            Machinery::Array.from_json(element)
+          when Hash
+            Machinery::Object.from_json(element)
           else
-            case element
-              when ::Array
-                Machinery::Array.from_json(element)
-              when Hash
-                Machinery::Object.from_json(element)
-              else
-                element
-            end
+            element
           end
         end
+      end
 
-        new(elements)
+      def convert_raw_array(array)
+        array.map do |element|
+          convert_element(element)
+        end
+      end
+
+      def from_json(json_object)
+        new(json_object)
       end
     end
 
     attr_reader :elements
 
     def initialize(elements = [])
-      @elements = elements
+      @elements = self.class.convert_raw_array(elements)
     end
 
     def ==(other)
@@ -69,6 +75,22 @@ module Machinery
       self.class.new(@elements & other.elements)
     end
 
+    def push(element)
+      @elements.push(self.class.convert_element(element))
+    end
+
+    def <<(element)
+      @elements << self.class.convert_element(element)
+    end
+
+    def +(array)
+      self.class.new(@elements + self.class.new(array).elements)
+    end
+
+    def insert(index, *elements)
+      @elements.insert(index, *self.class.new(elements).elements)
+    end
+
     def as_json
       @elements.map do |element|
         if element.is_a?(Machinery::Array) || element.is_a?(Machinery::Object)

data/lib/cli.rb

@@ -22,9 +22,13 @@ class Cli
   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"
+  if @config.experimental_features
+    flag :exclude, negatable: false, desc: "Exclude elements matching the filter criteria"
+  end
 
   sort_help :manually
   pre do |global_options,command,options,args|
@@ -39,14 +43,15 @@ class Cli
     if command.is_a?(GLI::Commands::Help) && !global_options[:version]
 
       Machinery::Ui.puts "\nMachinery can show hints which guide through a typical workflow."
-      if Machinery::Config.new.hints
+      if @config.hints
         Machinery::Ui.puts "These hints can be switched off by '#{$0} config hints off'."
       else
         Machinery::Ui.puts "These hints can be switched on by '#{$0} config hints on'."
       end
 
-      Hint.get_started
+      Hint.print(:get_started)
     end
+    Machinery::Ui.close_pager
   end
 
   GLI::Commands::Help.skips_post = false
@@ -68,9 +73,12 @@ class Cli
     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
       Machinery::Ui.error "Machinery experienced an unexpected error. Please file a " \
-        "bug report at https://github.com/SUSE/machinery/issues/new.\n"
+        "bug report at: https://github.com/SUSE/machinery/issues/new\n"
       if e.is_a?(Cheetah::ExecutionFailed)
         result = ""
         result << "#{e.message}\n"
@@ -208,7 +216,7 @@ class Cli
         when "config-file-diffs"
           task = AnalyzeConfigFileDiffsTask.new
           task.analyze(description)
-          Hint.show_analyze_data(name: name)
+          Hint.print(:show_analyze_data, name: name)
         else
           raise Machinery::Errors::InvalidCommandLine.new(
             "The operation '#{options[:operation]}' is not supported. " \
@@ -270,6 +278,8 @@ class Cli
       desc: "Pipe output into a pager"
 
     c.action do |global_options,options,args|
+      Machinery::Ui.use_pager = options[:pager]
+
       name1 = shift_arg(args, "NAME1")
       name2 = shift_arg(args, "NAME2")
       store = system_description_store
@@ -279,8 +289,7 @@ class Cli
 
       task = CompareTask.new
       opts = {
-          show_all: options["show-all"],
-          no_pager: !options["pager"]
+        show_all: options["show-all"]
       }
       task.compare(description1, description2, scope_list, opts)
     end
@@ -428,6 +437,8 @@ class Cli
       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"
 
     c.action do |global_options,options,args|
       host = shift_arg(args, "HOSTNAME")
@@ -455,12 +466,12 @@ class Cli
         inspect_options[:extract_unmanaged_files] = true
       end
 
-      if options["skip-files"] && !(scope_list & ["config_files", "changed_managed_files"]).empty?
-        Machinery::Ui.warn("Warning: The --skip-files option is currently only supported for the " \
-          "\"unmanaged-files\" scope")
-      end
+      filter = FilterOptionParser.parse("inspect", options, global_options)
 
-      filter = prepare_filter("inspect", options)
+      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"
+      end
 
       inspector_task.inspect_system(
         system_description_store,
@@ -472,10 +483,10 @@ class Cli
         inspect_options
       )
 
-      Hint.show_data(name: name)
+      Hint.print(:show_data, name: name)
 
       if !options["extract-files"] || Inspector.all_scopes.count != scope_list.count
-        Hint.do_complete_inspection(name: name, host: host)
+        Hint.print(:do_complete_inspection, name: name, host: host)
       end
     end
   end
@@ -545,8 +556,12 @@ class Cli
       desc: "Show diffs of 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"]
+
       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."
@@ -554,14 +569,28 @@ class Cli
       description = SystemDescription.load(name, system_description_store)
       scope_list = process_scope_option(options[:scope], options["exclude-scope"])
 
+      filter = FilterOptionParser.parse("show", options, global_options)
+
+      inspected_filters = description.filter_definitions("inspect")
+
+      if options["verbose"]
+        if !inspected_filters.empty?
+          Machinery::Ui.puts "\nThe following filters were applied during inspection:"
+          Machinery::Ui.puts inspected_filters.join("\n") + "\n\n"
+        end
+
+        if !filter.empty?
+          Machinery::Ui.puts "\nThe following filters were applied before showing the description:"
+          Machinery::Ui.puts filter.to_array.join("\n") + "\n\n"
+        end
+      end
 
       task = ShowTask.new
       opts = {
-          no_pager:   !options["pager"],
           show_diffs: options["show-diffs"],
           show_html:  options["html"]
       }
-      task.show(description, scope_list, opts)
+      task.show(description, scope_list, filter, opts)
     end
   end
 
@@ -639,7 +668,7 @@ class Cli
       task = ConfigTask.new
       task.config(key, value)
 
-      if key == "hints" && !Machinery::Config.new.hints
+      if key == "hints" && !@config.hints
         Machinery::Ui.puts "Hints can be switched on again by '#{$0} config hints on'."
       end
     end
@@ -652,38 +681,4 @@ class Cli
       SystemDescriptionStore.new
     end
   end
-
-
-  def self.prepare_filter(command, options)
-    filter = Filter.from_default_definition(command)
-
-    skip_files = options.delete("skip-files")
-    if skip_files
-      files = skip_files.split(/(?<!\\),/) # Do not split on escaped commas
-      files = files.flat_map do |file|
-        if file.start_with?("@")
-          filename = File.expand_path(file[1..-1])
-
-          if !File.exists?(filename)
-            raise Machinery::Errors::MachineryError.new(
-              "The filter file '#{filename}' does not exist."
-            )
-          end
-          File.read(filename).lines.map(&:strip)
-        else
-          file
-        end
-      end
-
-      files.reject!(&:empty?) # Ignore empty filters
-      files.map! { |file| file.gsub("\\@", "@") } # Unescape escaped @s
-      files.map! { |file| file.chomp("/") } # List directories without the trailing /, in order to
-                                            # not confuse the unmanaged files inspector
-      files.each do |file|
-        filter.add_element_filter_from_definition("/unmanaged_files/files/name=#{file}")
-      end
-    end
-
-    filter
-  end
 end

data/lib/compare_task.rb

@@ -19,7 +19,7 @@ class CompareTask
   def compare(description1, description2, scopes, options = {})
     output = render_comparison(description1, description2, scopes, options)
 
-    Machinery::Ui.print_output(output, :no_pager => options[:no_pager])
+    Machinery::Ui.puts output
   end
 
   def render_comparison(description1, description2, scopes, options = {})

data/lib/config.rb

@@ -25,8 +25,14 @@ module Machinery
       default_config_file(Machinery::DEFAULT_CONFIG_FILE)
 
       entry("hints",
-        default:     true,
-        description: "Show hints about usage of Machinery in the context of the commands ran by the user"
+        default: true,
+        description: "Show hints about usage of Machinery in the context of the commands ran by" \
+          " the user"
+      )
+      entry("experimental-features",
+        default: false,
+        description: "Enable experimental features. See " \
+          "https://github.com/SUSE/machinery/wiki/Experimental-Features for more details."
       )
     end
   end

data/lib/config_base.rb

@@ -32,6 +32,8 @@ class ConfigBase
   end
 
   def entry(key, parameters = {})
+    key = normalize_key(key)
+
     @entries[key] = { value: parameters[:default], description: parameters[:description] }
      create_method(key.to_sym) { get(key) }
      create_method("#{key}=".to_sym) { |value| set(key, value) }
@@ -42,15 +44,18 @@ class ConfigBase
   end
 
   def each(&block)
-    @entries.each(&block)
+    @entries.map { |key, value| [unnormalize_key(key), value] }.each(&block)
   end
 
   def get(key)
+    key = normalize_key(key)
+
     ensure_config_exists(key)
     @entries[key][:value]
   end
 
   def set(key, value, options = {auto_save: true} )
+    key = normalize_key(key)
     ensure_config_exists(key)
 
     # Check if data type is correct. true and false are not of the same type which makes the check complex
@@ -114,4 +119,12 @@ class ConfigBase
   def create_method(name, &block)
     self.class.send(:define_method, name, &block)
   end
+
+  def normalize_key(key)
+    key.gsub("-", "_")
+  end
+
+  def unnormalize_key(key)
+    key.gsub("_", "-")
+  end
 end

data/lib/element_filter.rb

@@ -18,28 +18,65 @@
 class ElementFilter
   attr_accessor :path, :matchers
 
-  def initialize(path, matchers = nil)
+  def initialize(path, operator = nil, matchers = nil)
     @path = path
-    @matchers = []
+    @matchers = {}
 
-    raise("Wrong type") if ![NilClass, String, Array].include?(matchers.class)
+    if ![NilClass, String, Array].include?(matchers.class)
+      raise Machinery::Errors::InvalidFilter.new("Wrong filter type")
+    end
 
-    add_matchers(matchers) if matchers
+    add_matchers(operator, matchers) if operator && matchers
   end
 
-  def add_matchers(matchers)
-    @matchers += Array(matchers)
+  def add_matchers(operator, matchers)
+    if ![Filter::OPERATOR_EQUALS, Filter::OPERATOR_EQUALS_NOT].include?(operator)
+      raise Machinery::Errors::InvalidFilter.new("Wrong filter operator '#{operator}'")
+    end
+
+    @matchers[operator] ||= []
+    @matchers[operator] += Array(matchers)
   end
 
   def matches?(value)
-    @matchers.each do |matcher|
-      if matcher.end_with?("*")
-        return true if value.start_with?(matcher[0..-2])
-      else
-        return true if value == matcher
+    @matchers.each do |operator, matchers|
+      matchers.each do |matcher|
+        values_equal = case value
+        when Machinery::Array
+          value_array = value.elements
+
+          (value_array - Array(matcher)).empty? && (Array(matcher) - value_array).empty?
+        when String
+          if matcher.is_a?(Array)
+            exception = Machinery::Errors::ElementFilterTypeMismatch.new
+            exception.failed_matcher =
+              "#{path}#{operator}#{matcher.join(",")}"
+            raise exception
+          end
+
+          if matcher.end_with?("*")
+            value.start_with?(matcher[0..-2])
+          else
+            value == matcher
+          end
+        end
+        if operator == Filter::OPERATOR_EQUALS
+          return true if values_equal
+        elsif operator == Filter::OPERATOR_EQUALS_NOT
+          return true if !values_equal
+        end
       end
     end
 
     false
   end
+
+  def filters_scope?(scope)
+    (path =~ /\/#{scope}(\/|$)/) ? true : false
+  end
+
+  def ==(other)
+    path == other.path &&
+      matchers == other.matchers
+  end
 end

data/lib/exceptions.rb

@@ -101,6 +101,11 @@ module Machinery
 
     class MigrationError < MachineryError; end
 
+    class InvalidFilter < MachineryError; end
+    class ElementFilterTypeMismatch < MachineryError
+      attr_accessor :failed_matcher
+    end
+
     class BuildFailed < MachineryError; end
     class DeployFailed < MachineryError; end
     class InspectionFailed < MachineryError; end

data/lib/filter.rb

@@ -46,19 +46,22 @@
 class Filter
   attr_accessor :element_filters
 
+  OPERATOR_EQUALS = "="
+  OPERATOR_EQUALS_NOT = "!="
+
   def self.parse_filter_definitions(filter_definitions)
     element_filters = {}
     Array(filter_definitions).each do |definition|
-      path, matcher_definition = definition.split("=", 2)
+      path, operator, matcher_definition = definition.scan(/([a-zA-Z_\/]+)(.*=)(.*)/)[0]
 
       element_filters[path] ||= ElementFilter.new(path)
       if matcher_definition.index(",")
         matchers = matcher_definition.split(/(?<!\\),/)
         matchers.map! { |matcher| matcher.gsub("\\,", ",") } # Unescape escaped commas
 
-        element_filters[path].add_matchers([matchers])
+        element_filters[path].add_matchers(operator, [matchers])
       else
-        element_filters[path].add_matchers(matcher_definition)
+        element_filters[path].add_matchers(operator, matcher_definition)
       end
     end
 
@@ -86,24 +89,44 @@ class Filter
   end
 
   def add_element_filter_from_definition(filter_definition)
-    new_element_filters = Filter.parse_filter_definitions(filter_definition)
+    add_element_filters(Filter.parse_filter_definitions(filter_definition).values)
+  end
 
-    new_element_filters.each do |path, element_filter|
+  def add_element_filters(element_filters)
+    Array(element_filters).each do |element_filter|
+      path = element_filter.path
       @element_filters[path] ||= ElementFilter.new(path)
-      @element_filters[path].add_matchers(element_filter.matchers)
+
+      element_filter.matchers.each do |operator, matchers|
+        @element_filters[path].add_matchers(operator, matchers)
+      end
+    end
+  end
+
+  def element_filter_for(path)
+    element_filters[path]
+  end
+
+  def element_filters_for_scope(scope)
+    @element_filters.values.select do |element_filter|
+      element_filter.filters_scope?(scope)
     end
   end
 
-  def add_element_filter(element_filter)
-    path = element_filter.path
-    @element_filters[path] ||= ElementFilter.new(path)
-    @element_filters[path].add_matchers(element_filter.matchers)
+  def set_element_filters_for_scope(scope, element_filters)
+    @element_filters.reject! do |_path, element_filter|
+      element_filter.filters_scope?(scope)
+    end
+
+    add_element_filters(element_filters)
   end
 
   def to_array
     @element_filters.flat_map do |path, element_filter|
-      element_filter.matchers.map do |matcher|
-        "#{path}=#{Array(matcher).join(",")}"
+      element_filter.matchers.flat_map do |operator, matchers|
+        matchers.map do |matcher|
+          "#{path}#{operator}#{Array(matcher).join(",")}"
+        end
       end
     end
   end
@@ -115,7 +138,33 @@ class Filter
     filter.matches?(value)
   end
 
-  def element_filter_for(path)
-    element_filters[path]
+  def apply!(system_description)
+    element_filters.each do |path, element_filter|
+      steps = path.split("/").reject(&:empty?)
+      target = steps.pop
+
+      pointer = system_description
+      container = nil
+      steps.each do |step|
+        break if !pointer
+        pointer = pointer[step]
+        container ||= pointer if pointer.is_a?(Machinery::Array)
+      end
+
+      next if !pointer
+
+      begin
+        pointer.delete_if do |element|
+          element_filter.matches?(element[target])
+        end
+      rescue Machinery::Errors::ElementFilterTypeMismatch => e
+        Machinery::Ui.warn("Warning: Filter '#{e.failed_matcher}' tries to match an array, " \
+          "but the according element is not an array.")
+      end
+    end
+  end
+
+  def empty?
+    element_filters.empty?
   end
 end