machinery-tool 1.16.4 → 1.17.0

data/lib/object.rb

@@ -29,10 +29,12 @@ module Machinery
           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)
+            if value.keys.include?("_elements")
+              Machinery::Array.from_json(value)
+            else
+              Machinery::Object.from_json(value)
+            end
           else
             value
           end

data/lib/remote_system.rb

@@ -16,16 +16,23 @@
 # you may find current contact information at www.suse.com
 
 class RemoteSystem < System
-  attr_accessor :host
-  attr_accessor :remote_user
+  attr_reader :host, :remote_user, :ssh_port, :ssh_identity_file
 
   def type
     "remote"
   end
 
-  def initialize(host, remote_user = "root")
+  def initialize(host, opts = {})
+    options = {
+      remote_user: "root",
+      ssh_port: nil,
+      ssh_identity_file: nil
+    }.merge(opts)
+
     @host = host
-    @remote_user = remote_user
+    @remote_user = options[:remote_user]
+    @ssh_port = options[:ssh_port]
+    @ssh_identity_file = options[:ssh_identity_file]
 
     connect
   end
@@ -78,12 +85,13 @@ class RemoteSystem < System
 
     sudo = ["sudo", "-n"] if options[:privileged] && remote_user != "root"
     cmds = [
-      "ssh", "#{remote_user}@#{host}", "-o", "LogLevel=ERROR", sudo, "LANGUAGE=",
-      "LC_ALL=#{locale}", *piped_args, options
+      *build_command(:ssh), "#{remote_user}@#{host}", "-o", \
+      "LogLevel=ERROR", sudo, "LANGUAGE=", "LC_ALL=#{locale}", *piped_args, options
     ].compact.flatten
+
     cheetah_class.run(*cmds)
   rescue Cheetah::ExecutionFailed => e
-    if e.stderr.include?("password is required")
+    if e.stderr && e.stderr.include?("password is required")
       raise Machinery::Errors::InsufficientPrivileges.new(remote_user, host)
     else
       raise e
@@ -93,7 +101,8 @@ class RemoteSystem < System
   # Tries to run the noop-command(:) on the remote system as root (without a password or passphrase)
   # and raises an Machinery::Errors::SshConnectionFailed exception when it's not successful.
   def connect
-    LoggedCheetah.run "ssh", "-q", "-o", "BatchMode=yes", "#{remote_user}@#{host}", ":"
+    LoggedCheetah.run(*build_command(:ssh), "-q", "-o", "BatchMode=yes",
+      "#{remote_user}@#{host}", ":")
   rescue Cheetah::ExecutionFailed
     raise Machinery::Errors::SshConnectionFailed.new(
       "Could not establish SSH connection to host '#{host}'. Please make sure that " \
@@ -117,7 +126,7 @@ class RemoteSystem < System
 
     cmd = [
       "rsync",
-      "-e", "ssh",
+      "-e", build_command(:ssh).join(" "),
       "--chmod=go-rwx",
       "--files-from=-",
       "--rsync-path=#{rsync_path}",
@@ -153,7 +162,7 @@ class RemoteSystem < System
     destination = "#{remote_user}@#{host}:#{destination}"
 
     cmd = [
-      "scp",
+      *build_command(:scp),
       source,
       destination
     ]
@@ -175,4 +184,28 @@ class RemoteSystem < System
       "Could not remove file '#{file}' on host '#{host}'.\nError: #{e}"
     )
   end
+
+  private
+
+  def build_command(name)
+    raise Machinery::Errors::MachineryError.new("You must set one of these flags in " \
+      "build_command: :ssh or :scp") unless [:ssh, :scp].include?(name)
+
+    command = [name.to_s]
+
+    if name == :ssh && @ssh_port
+      command.push("-p")
+      command.push(@ssh_port.to_s)
+    elsif name == :scp && @ssh_port
+      command.push("-P")
+      command.push(@ssh_port.to_s)
+    end
+
+    if @ssh_identity_file
+      command.push("-i")
+      command.push(@ssh_identity_file)
+    end
+
+    command
+  end
 end

data/lib/renderer.rb

@@ -147,7 +147,7 @@ class Renderer
   end
 
   def render_comparison_only_in(description)
-    return if !description[scope]
+    return if !description[scope] || description[scope].elements.try(:empty?)
 
     puts "Only in '#{description.name}':"
     indent { compare_content_only_in(description) }
@@ -208,7 +208,7 @@ class Renderer
     print_indented "#{s}"
   end
 
-  def list(name = nil, &block)
+  def list(name = nil, options = {}, &block)
     unless block_given?
       raise InvalidStructureError.new(
         "'list' was called without a block"
@@ -217,7 +217,6 @@ class Renderer
 
     @stack << :list
 
-
     if name && !name.empty?
       print_indented "#{name}:"
       indent do
@@ -226,7 +225,7 @@ class Renderer
     else
       block.call
     end
-    @buffer += "\n" unless @buffer.end_with?("\n\n")
+    @buffer += "\n" unless @buffer.end_with?("\n\n") || options[:sublist]
 
     @stack.pop
   end

data/lib/rpm_database.rb

@@ -15,193 +15,17 @@
 # To contact SUSE about this file by physical or electronic mail,
 # you may find current contact information at www.suse.com
 
-class RpmDatabase
-  class ChangedFile < Machinery::Object
-    attr_accessor :type
-
-    def initialize(type, attrs)
-      super(attrs)
-      @type = type
-    end
-
-    def config_file?
-      @type == "c"
-    end
-  end
-
-  def initialize(system)
-    @system = system
-  end
-
-  def changed_files(&block)
-    return @changed_files if @changed_files
-    check_requirements
-
-    out = @system.run_script_with_progress("changed_files.sh", &block)
-    result = out.each_line.map do |line|
-      line.chomp!
-      next unless line.match(/^[^ ]+[ ]+. \/.*$/)
-
-      file, changes, type = parse_rpm_changes_line(line)
-
-      package = @system.run_command("rpm", "-qf", file, stdout: :capture).split.first
-      package_name, package_version = package.scan(/(.*)-([^-]*)-[^-]/).first
-
-      ChangedFile.new(
-        type,
-        name:            file,
-        package_name:    package_name,
-        package_version: package_version,
-        status:          "changed",
-        changes:         changes
-      )
-    end.compact.uniq
-
-    paths = result.reject { |f| f.changes == Machinery::Array.new(["deleted"]) }.map(&:name)
-    path_data = get_path_data(paths)
-    result.each do |pkg|
-      next unless path_data[pkg.name]
-
-      path_data[pkg.name].each do |key, value|
-        pkg[key] = value
-      end
-    end
-
-    @changed_files = result
-  end
-
-  def expected_tag?(character, position)
-    if @rpm_changes[position] == character
-      true
-    else
-      @unknown_tag ||= ![".", "?"].include?(@rpm_changes[position])
-      false
-    end
-  end
-
-  def parse_rpm_changes_line(line)
-    # rpm provides lines per config file where first 9 characters indicate which
-    # properties of the file are modified
-    @rpm_changes, *fields = line.split(" ")
-    # nine rpm changes are known
-    @unknown_tag = @rpm_changes.size > 9
-
-    # For config or documentation files there's an additional field which
-    # contains "c" or "d"
-    type = fields[0].start_with?("/") ? "" : fields.shift
-    path = fields.join(" ")
-
-    changes = []
-    if @rpm_changes == "missing"
-      changes << "deleted"
-    elsif @rpm_changes == "........." && path.end_with?(" (replaced)")
-      changes << "replaced"
-      path.slice!(/ \(replaced\)$/)
-    else
-      changes << "size" if expected_tag?("S", 0)
-      changes << "mode" if expected_tag?("M", 1)
-      changes << "md5" if expected_tag?("5", 2)
-      changes << "device_number" if expected_tag?("D", 3)
-      changes << "link_path" if expected_tag?("L", 4)
-      changes << "user" if expected_tag?("U", 5)
-      changes << "group" if expected_tag?("G", 6)
-      changes << "time" if expected_tag?("T", 7)
-      changes << "capabilities" if @rpm_changes.size > 8 && expected_tag?("P", 8)
-    end
-
-    if @unknown_tag
-      changes << "other_rpm_changes"
-    end
-
-    if @rpm_changes.include?("?")
-      message = "Could not perform all tests on rpm changes for file '#{path}'."
-      Machinery.logger.warn(message)
-      Machinery::Ui.warn("Warning: #{message}")
-    end
-
-    [path, changes, type]
-  end
-
-  def parse_stat_line(line)
-    mode, user, group, uid, gid, type, *path_line = line.split(":")
-    path = path_line.join(":").chomp
-
-    user = uid if user == "UNKNOWN"
-    group = gid if group == "UNKNOWN"
-
-    type = case type
-    when "directory"
-      "dir"
-    when "symbolic link"
-      "link"
-    when /file$/
-      "file"
-    else
-      raise(
-        "The inspection failed because of the unknown type `#{type}` of file `#{path}`."
-      )
-    end
-
-    [path,
-      {
-        mode:  mode,
-        user:  user,
-        group: group,
-        type:  type
-      }
-    ]
-  end
-
-  def get_link_target(link)
-    @system.run_command(
-      "find", link, "-prune", "-printf", "%l",
-      stdout:     :capture,
-      privileged: true
-    ).strip
-  end
-
-  # get path data for list of files
-  # cur_files is guaranteed to not exceed max command line length
-  def get_file_properties(cur_files)
-    ret = {}
-    out = @system.run_command(
-      "stat", "--printf", "%a:%U:%G:%u:%g:%F:%n\\n",
-      *cur_files,
-      stdout: :capture,
-      privileged: true
-    )
-    out.each_line do |l|
-      path, values       = parse_stat_line(l)
-      ret[path]          = values
-      ret[path][:target] = get_link_target(path) if values[:type] == "link"
-    end
-    ret
+class RpmDatabase < ManagedFilesDatabase
+  def managed_files_list(&block)
+    @system.run_script_with_progress("changed_files.sh", &block)
   end
 
-  def get_path_data(paths)
-    ret = {}
-    path_index = 0
-    # arbitrary number for maximum command line length that should always work
-    max_len = 50000
-    cur_files = []
-    cur_len = 0
-    while path_index < paths.size
-      if cur_files.empty? || paths[path_index].size + cur_len + 1 < max_len
-        cur_files << paths[path_index]
-        cur_len += paths[path_index].size + 1
-        path_index += 1
-      else
-        ret.merge!(get_file_properties(cur_files))
-        cur_files.clear
-        cur_len = 0
-      end
-    end
-    ret.merge!(get_file_properties(cur_files)) unless cur_files.empty?
-    ret
+  def package_for_file_path(file)
+    package = @system.run_command("rpm", "-qf", file, stdout: :capture).split.first
+    package_name, package_version = package.scan(/(.*)-([^-]*)-[^-]/).first
+    [package_name, package_version]
   end
 
-  private
-
   def check_requirements
     @system.check_requirement("rpm", "--version")
     @system.check_requirement("stat", "--version")

data/lib/scope_file_access_archive.rb

@@ -22,7 +22,7 @@ module ScopeFileAccessArchive
     FileUtils.cp(File.join(scope_file_store.path, "files.tgz"), destination)
 
     target = File.join(destination, "trees")
-    files.select(&:directory?).each do |system_file|
+    self.select(&:directory?).each do |system_file|
       raise Machinery::Errors::FileUtilsError if !system_file.directory?
 
       tarball_target = File.join(target, File.dirname(system_file.name))
@@ -33,8 +33,8 @@ module ScopeFileAccessArchive
   end
 
   def has_file?(name)
-    return true if files.any? { |file| file.name == name }
-    if files.any? { |file| file.name == File.join(File.dirname(name), "") }
+    return true if any? { |file| file.name == name }
+    if any? { |file| file.name == File.join(File.dirname(name), "") }
       tgz_file = File.join(scope_file_store.path, "trees", "#{File.dirname(name)}.tgz")
       return Cheetah.run("tar", "ztf", tgz_file, stdout: :capture).split(/\n/).
         any? { |f| "/#{f}" == name }

data/lib/scope_file_access_flat.rb

@@ -34,6 +34,6 @@ module ScopeFileAccessFlat
   end
 
   def has_file?(name)
-    return true if files.any? { |file| file.name == name }
+    return true if any? { |file| file.name == name }
   end
 end

data/lib/server.rb

@@ -88,6 +88,11 @@ class Server < Sinatra::Base
       object.length.to_s + " " + Machinery.pluralize(object.length, singular, plural)
     end
 
+    def repository_changes
+      klass = @diff["repositories"].changed.first.first.class
+      changed_elements("repositories", attributes: klass.attributes, key: klass.key)
+    end
+
     def changed_elements(scope, opts)
       optional_attributes = opts[:optional_attributes] || []
 
@@ -199,7 +204,7 @@ class Server < Sinatra::Base
     description = SystemDescription.load(params[:id], settings.system_description_store)
     filename = File.join("/", params["splat"].first)
 
-    file = description[params[:scope]].files.find { |f| f.name == filename }
+    file = description[params[:scope]].find { |f| f.name == filename }
 
     if request.accept.first.to_s == "text/plain" && file.binary?
       status 406
@@ -298,7 +303,7 @@ class Server < Sinatra::Base
     diffs_dir = @description.scope_file_store("analyze/config_file_diffs").path
     if @description.config_files && diffs_dir
       # Enrich description with the config file diffs
-      @description.config_files.files.each do |file|
+      @description.config_files.each do |file|
         path = File.join(diffs_dir, file.name + ".diff")
         file.diff = diff_to_object(File.read(path)) if File.exists?(path)
       end

data/lib/system.rb

@@ -33,9 +33,9 @@ class System
 
   attr_writer :locale
 
-  def self.for(host, remote_user = "root")
+  def self.for(host, opts = {})
     if host && host != "localhost"
-      RemoteSystem.new(host, remote_user)
+      RemoteSystem.new(host, opts)
     else
       LocalSystem.new
     end
@@ -113,14 +113,61 @@ class System
   #       Machinery::Ui.progress("Found #{count} changed files...")
   #     end
   def run_script_with_progress(*script, &callback)
+    run_with_progress(*script, :script, &callback)
+  end
+
+  def run_command_with_progress(*command, &callback)
+    run_with_progress(*command, :command, &callback)
+  end
+
+  def has_command?(command)
+    run_command("bash", "-c", "type -P #{command}", stdout: :capture)
+    true
+  rescue Cheetah::ExecutionFailed
+    false
+  end
+
+  def arch
+    run_command("uname", "-m", stdout: :capture).chomp
+  end
+
+  def locale
+    @locale || "C"
+  end
+
+  def managed_files_database
+    if @managed_files_database
+      return @managed_files_database
+    elsif has_command?("rpm")
+      @managed_files_database = RpmDatabase.new(self)
+    elsif has_command?("dpkg")
+      @managed_files_database = DpkgDatabase.new(self)
+    else
+      raise Machinery::Errors::MissingRequirement.new(
+        "Need binary 'rpm' or 'dpkg' to be available on the inspected system."
+      )
+    end
+  end
+
+  private
+
+  def run_with_progress(*command, type, &callback)
     output = ""
     error = ""
     write_io = StringIO.new(output, "a")
     error_io = StringIO.new(error, "a")
     read_io = StringIO.new(output, "r")
 
+    options = command.last.is_a?(Hash) ? command.pop : {}
+    options[:stdout] = write_io
+    options[:stderr] = error_io
+
     inspect_thread = Thread.new do
-      run_script(*script, stdout: write_io, stderr: error_io)
+      if type == :script
+        run_script(*command, options)
+      else
+        run_command(*command, options)
+      end
     end
 
     while inspect_thread.alive?
@@ -135,23 +182,4 @@ class System
 
     output
   end
-
-  def has_command?(command)
-    run_command("bash", "-c", "type -P #{command}", stdout: :capture)
-    true
-  rescue Cheetah::ExecutionFailed
-    false
-  end
-
-  def arch
-    run_command("uname", "-m", stdout: :capture).chomp
-  end
-
-  def locale
-    @locale || "C"
-  end
-
-  def rpm_database
-    @rpm_database ||= RpmDatabase.new(self)
-  end
 end