machinery-tool 1.5.0 → 1.6.0

data/lib/filter_option_parser.rb

@@ -0,0 +1,83 @@
+# Copyright (c) 2013-2015 SUSE LLC
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 3 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE about this file by physical or electronic mail,
+# you may find current contact information at www.suse.com
+
+# This class takes care of transforming the user-provided filter options into
+# actual Filter objects.
+class FilterOptionParser
+  class <<self
+    def parse(command, options, global_options)
+      filter = Filter.from_default_definition(command)
+
+      definitions = skip_files_definitions(options.delete("skip-files"))
+      definitions += exclude_definitions(global_options["exclude"])
+
+      definitions.map! { |definition| definition.gsub("\\@", "@") } # Unescape escaped @s
+      definitions.each do |definition|
+        filter.add_element_filter_from_definition(definition)
+      end
+
+      filter
+    end
+
+    private
+
+    def exclude_definitions(exclude)
+      return [] if !exclude
+
+      filters = exclude.scan(/(@[^,]+)|\"([^,]+?=[^\"]+)\"|([^,]+=[^=]+)$|([^,]+=[^,]+)/).
+        map(&:compact).flat_map do |filter_definition|
+        if filter_definition[0].start_with?("@")
+          expand_filter_file(filter_definition[0])
+        else
+          filter_definition
+        end
+      end
+
+      filters.reject!(&:empty?) # Ignore empty filters
+      filters
+    end
+
+    def skip_files_definitions(skip_files)
+      return [] if !skip_files
+
+      files = skip_files.split(/(?<!\\),/) # Do not split on escaped commas
+      files = files.flat_map do |file|
+        if file.start_with?("@")
+          expand_filter_file(file)
+        else
+          file
+        end
+      end
+
+      files.reject!(&:empty?) # Ignore empty filters
+      files.map! { |file| file.chomp("/") } # List directories without the trailing /, in order to
+                                            # not confuse the unmanaged files inspector
+      files.map { |file| "/unmanaged_files/files/name=#{file}" }
+    end
+
+    def expand_filter_file(path)
+      filename = File.expand_path(path[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)
+    end
+  end
+end

data/lib/generate_html_task.rb

@@ -17,6 +17,8 @@
 
 class GenerateHtmlTask
   def generate(description)
-    Html.generate(description)
+    output = Html.generate(description)
+    Machinery::Ui.puts "The generated HTML file is stored in: \n" +
+      "#{output}"
   end
 end

data/lib/hint.rb

@@ -16,29 +16,47 @@
 # you may find current contact information at www.suse.com
 
 class Hint
-  def self.get_started
-    output "You can get started by inspecting a system. Run:\n#{$0} inspect HOSTNAME"
-  end
+  class << self
+    def print(method, options = {})
+      return if !Machinery::Config.new.hints
 
-  def self.show_data(options)
-    output "To show the data of the system you just inspected run:\n#{$0} show #{options[:name]}"
-  end
+      Machinery::Ui.puts to_string(method, options)
+    end
 
-  def self.show_analyze_data(options)
-    output "To show the config file diffs you just created run:\n" \
-      "#{$0} show --scope config-files --show-diffs #{options[:name]}"
-  end
+    def to_string(method, options = {})
+      return "" if !Machinery::Config.new.hints
 
-  def self.do_complete_inspection(options)
-    output "To do a full inspection containing all scopes and to extract files run:\n" \
-     "#{$0} inspect #{options[:host]} --name #{options[:name]} --extract-files"
-  end
+      "\nHint: #{send(method, options)}\n"
+    end
+
+    private
+
+    def get_started(_options)
+      "You can get started by inspecting a system. Run:\n#{$0} inspect HOSTNAME"
+    end
+
+    def upgrade_format_force(options)
+      "To force an upgrade of system descriptions run:\n" \
+      "#{$0} upgrade-format --force #{options[:name]}"
+    end
+
+    def show_data(options)
+      "To show the data of the system you just inspected run:\n#{$0} show #{options[:name]}"
+    end
+
+    def show_analyze_data(options)
+      "To show the config file diffs you just created run:\n" \
+        "#{$0} show --scope config-files --show-diffs #{options[:name]}"
+    end
 
-  private
+    def do_complete_inspection(options)
+      "To do a full inspection containing all scopes and to extract files run:\n" \
+       "#{$0} inspect #{options[:host]} --name #{options[:name]} --extract-files"
+    end
 
-  def self.output(text)
-    if Machinery::Config.new.hints
-      Machinery::Ui.puts "\nHint: #{text}\n"
+    def upgrade_system_description(_options)
+      "To upgrade all system descriptions run:\n" \
+       "#{$0} upgrade-format --all"
     end
   end
 end

data/lib/html.rb

@@ -44,6 +44,7 @@ class Html
       }
       EOT
     )
+    target
   end
 
   # Template helpers

data/lib/inspect_task.rb

@@ -58,16 +58,6 @@ class InspectTask
     end
   end
 
-  def adapt_filter_in_metadata(filter_in_metadata, scope, filter)
-    filter_in_metadata.element_filters.
-      reject! { |path, _filter| path.start_with?("/#{scope}") }
-    filter.element_filters.
-      select { |path, _filter| path.start_with?("/#{scope}") }.
-      each do |_path, element_filter|
-      filter_in_metadata.add_element_filter(element_filter)
-    end
-  end
-
   def build_description(store, name, system, scopes, filter, options)
     begin
       description = SystemDescription.load(name, store)
@@ -83,16 +73,17 @@ class InspectTask
 
     failed_inspections = {}
 
-    if description.filters["inspect"]
-      filter_in_metadata = description.filters["inspect"]
-    else
-      filter_in_metadata = Filter.new
-    end
+    effective_filter = Filter.new(description.filter_definitions("inspect"))
 
-    scopes.map { |s| Inspector.for(s) }.each do |inspector|
+    scopes.each do |scope|
+      inspector = Inspector.for(scope).new(system, description)
       Machinery::Ui.puts "Inspecting #{Machinery::Ui.internal_scope_list_to_string(inspector.scope)}..."
+
+      element_filters = filter.element_filters_for_scope(scope)
+      effective_filter.set_element_filters_for_scope(scope, element_filters)
+
       begin
-        summary = inspector.inspect(system, description, filter, options)
+        inspector.inspect(effective_filter, options)
       rescue Machinery::Errors::MachineryError => e
         Machinery::Ui.puts " -> Inspection failed!"
         failed_inspections[inspector.scope] = e
@@ -100,13 +91,13 @@ class InspectTask
       end
       description[inspector.scope].set_metadata(timestring, host)
 
-      adapt_filter_in_metadata(filter_in_metadata, inspector.scope, filter)
-
       if !description.attributes.empty?
-        description.set_filter("inspect", filter_in_metadata)
+        effective_filter.apply!(description)
+        description.set_filter_definitions("inspect", effective_filter.to_array)
         description.save
       end
-      Machinery::Ui.puts " -> " + summary
+
+      Machinery::Ui.puts " -> " + inspector.summary
     end
 
     return description, failed_inspections

data/lib/inspector.rb

@@ -33,6 +33,7 @@
 # The description object can also be used to store files in the description.
 class Inspector
   abstract_method :inspect
+  abstract_method :summary
 
   @inspectors = []
 
@@ -44,22 +45,28 @@ class Inspector
     def for(scope)
       class_name = "#{scope.split("_").map(&:capitalize).join}Inspector"
 
-      Object.const_get(class_name).new if Object.const_defined?(class_name)
+      Object.const_get(class_name) if Object.const_defined?(class_name)
     end
 
     def all
-      @inspectors.map(&:new)
+      @inspectors
     end
 
     def all_scopes
       all.map(&:scope)
     end
+
+    def scope
+      # Return the un-camelcased name of the inspector,
+      # e.g. "foo_bar" for "FooBarInspector"
+      scope = self.name.match(/^(.*)Inspector$/)[1]
+      scope.gsub(/([^A-Z])([A-Z])/, "\\1_\\2").downcase
+    end
   end
 
+  attr_accessor :system, :description
+
   def scope
-    # Return the un-camelcased name of the inspector,
-    # e.g. "foo_bar" for "FooBarInspector"
-    scope = self.class.name.match(/^(.*)Inspector$/)[1]
-    scope.gsub(/([^A-Z])([A-Z])/, "\\1_\\2").downcase
+    self.class.scope
   end
 end

data/lib/kiwi_config.rb

@@ -148,20 +148,23 @@ suseImportBuildKey
 suseConfig
 EOF
     case @system_description.os
-      when OsOpenSuse13_1
-        boot = "vmxboot/suse-13.1"
-        bootloader = "grub2"
-      when OsSles12
-        boot = "vmxboot/suse-SLES12"
-        bootloader = "grub2"
-      when OsSles11
-        boot = "vmxboot/suse-SLES11"
-        bootloader = "grub"
-      else
-        raise Machinery::Errors::ExportFailed.new(
-          "Export is not possible because the operating system " \
-          "'#{@system_description.os.display_name}' is not supported."
-        )
+    when OsOpenSuse13_2
+      boot = "vmxboot/suse-13.2"
+      bootloader = "grub2"
+    when OsOpenSuse13_1
+      boot = "vmxboot/suse-13.1"
+      bootloader = "grub2"
+    when OsSles12
+      boot = "vmxboot/suse-SLES12"
+      bootloader = "grub2"
+    when OsSles11
+      boot = "vmxboot/suse-SLES11"
+      bootloader = "grub"
+    else
+      raise Machinery::Errors::ExportFailed.new(
+        "Export is not possible because the operating system " \
+        "'#{@system_description.os.display_name}' is not supported."
+      )
     end
 
     builder = Nokogiri::XML::Builder.new do |xml|

data/lib/list_task.rb

@@ -17,7 +17,8 @@
 
 class ListTask
   def list(store, options = {})
-    descriptions = store.list.sort
+    descriptions = store.list
+    has_incompatible_version = false
 
     descriptions.each do |name|
       begin
@@ -28,6 +29,7 @@ class ListTask
         elsif e.format_version < SystemDescription::CURRENT_FORMAT_VERSION
           show_error("#{name}: format version #{e.format_version}, " \
             "needs to be upgraded.\n", options)
+          has_incompatible_version = true
         else
           show_error("#{name}: format version #{e.format_version}. " \
             "Please upgrade Machinery to the latest version.\n", options)
@@ -77,6 +79,8 @@ class ListTask
         Machinery::Ui.puts " #{name}:\n   * " + scopes .join("\n   * ") + "\n\n"
       end
     end
+
+    Hint.print(:upgrade_system_description) if has_incompatible_version
   end
 
   private

data/lib/local_system.rb

@@ -21,10 +21,9 @@ class LocalSystem < System
   class << self
     def os
       if !@@os
-        description = SystemDescription.new("localhost",
-          SystemDescriptionMemoryStore.new)
-        inspector = OsInspector.new
-        inspector.inspect(System.for("localhost"), description, nil)
+        description = SystemDescription.new("localhost", SystemDescriptionMemoryStore.new)
+        inspector = OsInspector.new(System.for("localhost"), description)
+        inspector.inspect(nil)
         @@os = description.os
       end
       @@os

data/lib/logged_cheetah.rb

@@ -20,6 +20,8 @@ class LoggedCheetah
     command = args.select{|e| e.is_a?(String)}.join(" ")
     Machinery.logger.info("Running '#{command}'")
 
-    Cheetah.run(*args)
+    with_c_locale do
+      Cheetah.run(*args)
+    end
   end
 end

data/lib/machinery.rb

@@ -89,6 +89,7 @@ require_relative "json_validation_error_cleaner"
 require_relative "file_validator"
 require_relative "element_filter"
 require_relative "filter"
+require_relative "filter_option_parser"
 
 Dir[File.join(Machinery::ROOT, "plugins", "**", "*.rb")].each { |f| require(f) }
 

data/lib/object.rb

@@ -23,31 +23,34 @@ module Machinery
         @property_classes[name.to_s] = options[:class]
       end
 
-      def object_hash_from_json(json)
-        return nil unless json
-
-        entries = json.map do |key, value|
-          value_converted = if @property_classes && @property_classes[key.to_s]
-            @property_classes[key.to_s].from_json(value)
+      def convert_element(key, value)
+        property_class = @property_classes[key.to_s] if @property_classes
+        if property_class
+          value.is_a?(property_class) ? value : property_class.from_json(value)
+        else
+          case value
+          when ::Array
+            Machinery::Array.from_json(value)
+          when Hash
+            Machinery::Object.from_json(value)
           else
-            case value
-              when ::Array
-                Machinery::Array.from_json(value)
-              when Hash
-                Machinery::Object.from_json(value)
-              else
-                value
-            end
+            value
           end
+        end
+      end
+
+      def convert_raw_hash(hash)
+        return nil unless hash
 
-          [key, value_converted]
+        entries = hash.map do |key, value|
+          [key, convert_element(key, value)]
         end
 
         Hash[entries]
       end
 
-      def from_json(json)
-        new(object_hash_from_json(json))
+      def from_json(json_object)
+        new(json_object)
       end
     end
 
@@ -58,6 +61,7 @@ module Machinery
     end
 
     def set_attributes(attrs)
+      attrs = self.class.convert_raw_hash(attrs) if attrs.is_a?(Hash)
       @attributes = attrs.inject({}) do |attributes, (key, value)|
         key = key.to_s if key.is_a?(Symbol)
 
@@ -84,7 +88,7 @@ module Machinery
     end
 
     def []=(key, value)
-      @attributes[key.to_s] = value
+      @attributes[key.to_s] = self.class.convert_element(key, value)
     end
 
     def empty?
@@ -96,7 +100,8 @@ module Machinery
         if args.size != 1
           raise ArgumentError, "wrong number of arguments (#{args.size} for 1)"
         end
-        @attributes[name.to_s[0..-2].to_s] = args.first
+        key = name.to_s[0..-2]
+        @attributes[key] = self.class.convert_element(key, args.first)
       else
         if @attributes.has_key?(name.to_s)
           if !args.empty?