tweek 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b847609877ba323a4f9feb924b503cd80f9f553
-  data.tar.gz: 28ca6b95b8f2481c00b85aadf4ef2b4aa690f78d
+  metadata.gz: b8c6ef673ab0665cb66d13f99dc0023475b897e7
+  data.tar.gz: 00de0099ebd776a88efd3179dc7ead5d5306d386
 SHA512:
-  metadata.gz: dd5be7941a09e0351df76b35e99efe7e5a5d905691f656f7fa577b3e15c303fab0296b716cddbf79faf12f3f74185e063b3a367e7c94d7a33099053c69aed342
-  data.tar.gz: 2ef05e618352ec963c405a9f05cc8b279e29f97c3fd2d847cdd1750352f790f559e44acc7475c638d2e24be98c01fe8a45cbfb616f7e5b352e8459193f79d13f
+  metadata.gz: 276719adb0d4db1ed7c326a06b477676ae9a078b561ebe5a45df8b76cb4247a31f252cb0a40234008c76f83b6ba008f9d1b91644824729f64ddbd6dddbeac6b5
+  data.tar.gz: 73b5560399d4374b0b13b21c39eeeffc94fc9023851cbb7e6dc344214a2ecf8f2c6c53defd6dadc6f4c07528ea1f25c14a0e54f7ca7580475b9857de2942bb1b

data/README.md

@@ -55,6 +55,8 @@ Tweek can be used in the following modes:
  * To create a sample settings file that you can edit manually
  * To generate a settings file based on the current system configuration
  * To check the current system configuration against a file of settings.
+ * To set the current system configuration to a file of settings.<br>
+   __NOTE__ this is currently restricted to `sysctl` parameters only. TBD.
 
 In the first case Tweek uses a built-in set of defaults. To check using these simply run:
 
@@ -69,6 +71,55 @@ All the other uses involve the settings file. Documentation is contained within
 sample settings and you should read them for a full understanding of what is possible.
 Use `tweek -s` to show them.
 
+### Output
+
+The output of Tweek is controlled by the `output` option, which takes the following
+values (default `1`):
+
+0. No output, just a return code.
+
+1. Summary output only is written to STDERR. It consists of a string of dots (when a
+   parameter is OK) or the letter 'F' (when a parameter doesn't match) followed by a
+   summary line.
+
+2. Only the settings that didn't match are written to STDOUT in a form that can be reused
+   as input. The summary is written to STDERR
+
+3. All the settings are written to STDOUT in a form that can be reused as input.
+
+The latter formats differ slightly depending on whether the utility is operating in query
+mode, set mode or reset mode. See below.
+
+Note that the output is colorized by default. Disable this with `--no-color`.
+
+* red: a value that doesn't match or conditions that are not met
+* yellow: expected values
+* green: conditions that are met
+* bold: emphasis
+
+### Operating Mode
+
+The actions of Tweek are controlled by the `mode` option, which takes the following values
+(default `query`):
+
+<dl>
+
+<dt>query</dt>
+
+<dd>the settings are checked against the actual values and mismatches are highlighted and
+noted in a comment with the syntax '[expected xxx]'</dd>
+
+<dt>set</dt>
+
+<dd>the settings are set to the given value, mismatches are highlighted and noted in a
+trailing comment with the syntax '[was xxx]'</dd>
+
+<dt>reset</dt>
+
+<dd>action as above but the settings are taken from the '[was xxx]' comments</dd>
+
+</dl>
+
 ## Settings File Format
 
 The settings file is a plaintext file encoded in UTF-8 (if you are running Ruby 2.0 or

data/bin/tweek

@@ -6,19 +6,23 @@
 #
 require 'rubygems'
 
+require 'fileutils'
 require 'optparse'
+require 'open-uri'
 require 'tweek'
 require 'tweek/file'
 require 'tweek/version'
+require 'colorize'
 
 trap('INT') do
   print "\n"
   exit(1)
 end
 
-gflag = false
-sflag = false
-qflag = false
+modes = [:query, :set, :reset]
+mflag = modes[0]
+oflag = 1
+cflag = true
 distro = nil
 distro_ver = nil
 kernel_ver = nil
@@ -37,11 +41,20 @@ OptionParser.new do |o|
     o.on('--kernel-ver=X.Y.Z', "Set Kernel version (default uses uname)" ) do |k|
         kernel_ver = k
     end
-    o.on( '-g', '--generate', "Generate a copy of the input file(s)", "containing current values on STDOUT" ) do
-        gflag = true
+    o.on( '-c', '--[no-]color', "Colorize output (default #{cflag})" ) do |c|
+        cflag = c
     end
-    o.on( '-q', '--quiet', "No output (default false)" ) do
-        qflag = true
+    o.on( '-m', '--mode MODE', modes, "Select mode from: #{modes.join(',')} (default #{mflag})" ) do |m|
+        mflag = m
+    end
+    o.on( '-o', '--output LEVEL', Integer, "Output level (default 1)",
+                                        "0: no output", "1: progress and stats",
+                                        "2: mismatches only", "3: all" ) do |o|
+      oflag = o.to_i
+      unless (0..3).include? oflag
+        puts o
+        exit 2
+      end
     end
     o.on( '-s', '--show', "Write the default parameters to STDOUT",
           "Use as a fully documented starting point"
@@ -49,10 +62,7 @@ OptionParser.new do |o|
         File.open(File.expand_path('../../settings/sample.twk',__FILE__)).each_line do |l|
           STDOUT.puts l # no copy_stream in 1.8.7
         end
-        exit
-    end
-    o.on( '--set', "Set the tweak file(s)" ) do
-        sflag = true
+        exit 99
     end
     o.on('-v', "--version", "Show version") do
       puts Tweek::VERSION
@@ -64,21 +74,26 @@ OptionParser.new do |o|
     end
     o.separator <<MSG
 
-Returns:
+Exit code:
    0: If no mismatches, >0 number of mismatches
 MSG
     o.parse! rescue (puts "Error: #{$!}"; puts o; exit)
 end
+
+String.disable_colorization = !cflag
+
 if distro.nil? or distro_ver.nil?
   if RUBY_PLATFORM !~ /\blinux\b/
-    STDERR.puts "Tweek only runs on Linux!" 
+    STDERR.puts "Tweek only runs on Linux!".colorize(:red)
     exit 2
   end 
   begin
     distro ||= `lsb_release -i`.partition(':').last.strip
+    raise unless $? == 0
     distro_ver ||= `lsb_release -r`.partition(':').last.strip
+    raise unless $? == 0
   rescue
-    puts "'lsb_release' not found! Install or specify --distro and --distro-ver on command line"
+    STDERR.puts "'lsb_release' not found! Install or specify --distro and --distro-ver on command line"
     exit 2
   end
 end
@@ -86,19 +101,24 @@ if kernel_ver.nil?
   begin
     kernel_ver ||= `uname -r`.partition('-').first
   rescue
-    puts "'uname' not found! Install or specify --kernel-ver on command line"
+    STDERR.puts "'uname' not found! Install or specify --kernel-ver on command line"
     exit 2
   end
 end
-cs = Tweek::File.new(distro, distro_ver, kernel_ver, gflag, qflag, sflag)
+cs = Tweek::File.new(distro, distro_ver, kernel_ver, mflag, oflag)
 if ARGV.empty?
-  if sflag
-    puts "You can't update the system with the sample settings, specify one or more Tweek files!"
+  if mflag != :query
+    STDERR.puts "You can't update the system with the sample settings, specify one or more Tweek files!"
     exit 2
   end
   fh = File.open(File.expand_path('../../settings/sample.twk',__FILE__))
 else
-  fh = ARGF
+  dir = FileUtils.pwd
+  ARGV.each do |file|
+    FileUtils.chdir dir
+    open(file) do |fh|
+      cs.read_sections(fh)
+    end
+  end
 end
-cs.read_sections(fh)
 exit cs.results

data/lib/tweek/file.rb

@@ -2,77 +2,77 @@ require 'rubygems'
 require 'tweek'
 require 'tweek/section'
 require 'tweek/entry'
+require 'colorize'
 
 class Tweek::File
 
-  attr_reader :distro, :distro_version, :kernel_version, :gflag, :qflag, :sflag
+  attr_reader :distro, :distro_version, :kernel_version, :mflag, :oflag, :mismatches, :skips
 
-  def initialize( distro, distro_version, kernel_version, gflag = false, qflag = true, sflag = false)
-    @distro = distro
-    @distro_version = Gem::Version.new(distro_version)
-    @kernel_version = Gem::Version.new(kernel_version)
+  def initialize( distro, distro_version, kernel_version, mflag = :query, oflag = 0)
+    @distrov = distro
+    @dv = Gem::Version.new(distro_version)
+    @kv = Gem::Version.new(kernel_version)
+    @distro_version = distro_version.bold
+    @kernel_version = kernel_version.bold
+    @distro = distro.bold
     @nparams = 0
-    @mismatches = []
+    @mismatches = 0
     @errors = []
-    @skips = []
+    @skips = 0
     @warns = []
     @generated = []
-    if gflag
-      @generated << "# Generated at #{Time.now.strftime("%c %Z")}"
-      @generated << "# Distro: #{@distro} Version: #{@distro_version} Kernel: #{@kernel_version}"
-    end
-    @gflag = gflag
-    @qflag = qflag
-    @sflag = sflag
+    @mflag = mflag
+    @oflag = oflag
+
   end
 
-  # Generate an output file recording what was found (check) or done (set)
+  # Called for every entry, generates output as required
   #
-  def generate type, entry
-    return unless @gflag
-    case type
-    when :line
-      @generated.push "#{entry.line}#{entry.comment}"
+  def generate entry
+
+    line = entry.generate
+
+    case entry.type
+
+    when :literal
+      @generated.push line if @oflag > 1
+
     when :section
-      return if entry.type.nil?
-      @generated.push "#{entry.type} #{entry.list} #{entry.comment}"
-    when :entry
-      cond = entry.cond.nil? ? "": " if #{entry.cond}"
-      if entry.actual.nil?
-        line = "#{entry.param} = #{entry.value}#{cond}"
-        note = "[condition not met]"
+      @generated.push line unless entry.section_type.nil? or @oflag < 2
+
+    when :parameter
+      @nparams += 1
+      if entry.condfail
+        @generated.push line if @oflag > 1
+        STDERR.print "s".colorize(:yellow) if @oflag == 1
       else
-        entry.swap!
-        line = "#{entry.param} = #{entry.actual}#{cond}"
-        if entry.value === entry.actual
-          note = nil
+        @generated.push line if @oflag == 3 or ((@oflag == 2) and entry.mismatch)
+        if entry.mismatch
+          @mismatches += 1
+          STDERR.print "F".colorize(:red) if @oflag == 1
         else
-          note = "[#{entry.set ? 'was' : 'expected'} #{entry.value}]"
+          STDERR.print ".".colorize(:green) if @oflag == 1
         end
       end
-      if entry.comment.nil?
-        @generated.push (note ? line + " # " + note : line)
-      else
-        @generated.push (note ? line + " " + entry.comment + " " + note : line + " " + entry.comment)
-      end
     end
   end
 
-  def error msg
-    @errors.push msg unless @errors.first == msg
+  def error msg, lineno = 0
+    line = (lineno == 0) ? msg : sprintf("%3d: #{msg}", lineno)
+    @errors.push line unless @errors.first == line
   end
 
-  def messages
-    strings =  @errors + @mismatches
-    return strings.size == 0 ? "": strings.join("\n")
+  def warn msg, lineno = 0
+    line = (lineno == 0) ? msg : sprintf("%3d: #{msg}", lineno)
+    @warns.push line unless @warns.first == line
   end
 
-  def warn msg
-    @warns.push msg unless @warns.first == msg
+  def messages
+    return @errors.size > 0 ? @errors.join("\n") : ""
   end
 
-  def skipcond entry
-    @skips.push entry
+  def generated
+    return @generated.size > 0 ? @generated.join("\n") : ""
   end
 
   def condfail cond
@@ -81,85 +81,79 @@ class Tweek::File
     failures = 0
     reqs = cond.split(/\s*,\s*/)
     reqs.each do |req|
-      ok =  case var = req.slice!(0)
+      raise ArgumentError.new("entry has invalid condition variable: #{req}") unless /^[kvd]/ =~ req
+      var = $&
+      ver = $'
+      ok =  case var
             when 'k'
-              Gem::Requirement.new(req).satisfied_by?(kernel_version)
+              Gem::Requirement.new(ver).satisfied_by?(@kv)
             when 'v'
-              Gem::Requirement.new(req).satisfied_by?(distro_version)
+              Gem::Requirement.new(ver).satisfied_by?(@dv)
             when 'd'
-              op = req.slice!(/^[<>~!=]+/)
+              op = ver.slice!(/^[<>~!=]+/)
               begin
-                eval "distro #{op} #{req}"
+                eval "@distrov #{op} #{ver}"
               rescue Exception => e
                 raise ArgumentError.new("entry has condition error: #{e.message}")
               end
-            else
-              raise ArgumentError.new("entry has invalid condition variable: #{var}")
             end
       failures += 1 unless ok
     end
-    return failures > 0
-  end
-
-  def assert_equal expected, actual, msg = ''
-    @nparams += 1
-    if expected === actual
-      STDERR.print "." if not @qflag and STDERR.isatty
-      return 0
-    else
-      STDERR.print "F" if not @qflag and STDERR.isatty
-      @mismatches.push "#{msg}: Expected #{expected}\n#{" "*(msg.size+4)}Actual #{actual}"
-    end
-    return 1
+    skipped = (failures > 0)
+    @skips += 1 if skipped
+    return skipped
   end
 
   # Read the entire file and split into sections
   #
   def read_sections handle
-    section = Tweek::Section.new( 0, nil, '', '' )
+    section = Tweek::Section.initial self
     while line = handle.gets
       line.chomp!
       if (line =~ /^=begin/)..(line =~ /^=end/)
-        section.push Tweek::Entry.new( :line => line, :lineno => handle.lineno )
+        entry = Tweek::Entry.new(section, :literal, :line => line, :lineno => handle.lineno )
+        section.push entry
         next
       end
 
-      comment = line.slice!(/#.*$/)
-      if line.empty?
-        section.push Tweek::Entry.new( :line => line, :lineno => handle.lineno, :comment => comment )
-        next
-      end
+      begin
+        entry = Tweek::Entry.parse(section, line)
+        entry.lineno = handle.lineno
+        case entry.type
 
-      if /^\s*([A-Z0-9]+)\s*(.*?)\s*$/ =~ line # We've hit a new section
-        section.process(self)
-        section = Tweek::Section.new( handle.lineno, $1, $2, comment )
-        next
-      end
+        when :literal
+          section.push entry
+
+        when :section
+          section.process
+          section = Tweek::Section.new(self, entry)
+
+        when :parameter
+          section.push entry
 
-      if /^\s*(.+?)\s*=\s*(.*?)\s*(\bif\b(.*))?$/ =~ line
-        if $4 and $4.strip.empty?
-          error "#{handle.lineno}: Missing condition after 'if'"
         else
-          section.push Tweek::Entry.new(  :lineno => handle.lineno, :param => $1, :value => $2,
-                                          :cond => $4, :comment => comment )
+          error "#{handle.lineno}: Unrecognized line: #{line}"
         end
-        next
+      rescue
+        error "#{handle.lineno}: #{$!.message}"
       end
-      error "#{handle.lineno}: Unrecognized line: #{line}"
     end
-    section.process(self)
-
+    section.process
   end
 
   def results
-    unless @qflag
-      STDERR.puts "\nDistro: #{@distro} Version: #{@distro_version} Kernel: #{@kernel_version}"
-      STDERR.puts "\n#{@nparams} parameters checked, #{@skips.size} conditions not met, #{@mismatches.size} mismatches, #{@warns.size} warnings, #{@errors.size} errors"
-      STDERR.puts "\n#{@errors.join("\n")}" unless @errors.empty?
-      STDERR.puts "\n#{@warns.join("\n")}" unless @warns.empty?
-      STDERR.puts "\n#{@mismatches.join("\n")}" unless @mismatches.empty?
+    unless @oflag == 0
+      STDERR.puts "" if @oflag == 1
+      STDERR.puts "Mode: #{@mflag.to_s.bold} Distro: #{@distro} Version: #{@distro_version} Kernel: #{@kernel_version}"
+      STDERR.puts "#{@nparams} parameters checked, #{@skips} conditions not met, #{@mismatches} mismatches, #{@warns.size} warnings, #{@errors.size} errors"
+      STDERR.puts "#{@errors.join("\n")}" unless @errors.empty?
+      STDERR.puts "#{@warns.join("\n")}" unless @warns.empty?
+      if oflag > 1
+        @generated.unshift "# Generated at #{Time.now.strftime("%c %Z")}"
+        @generated.unshift "# Mode: #{@mflag} Distro: #{@distro} Version: #{@distro_version} Kernel: #{@kernel_version}"
+      end
       @generated.each { |l| STDOUT.puts l}
     end
-    return @mismatches.size
+    return @mismatches
   end
 end

data/lib/tweek/section.rb

@@ -1,224 +1,230 @@
-# A section is an array of the parsed lines, each element is an OpenStruct
-# There are the following types of Entry
-# With line attributes - single lines
-# With section type and list attributes
-# With parameter value and conditional attributes
-# All entries may have an optional comment attribute
+# A section is an array of lines, each line is an Entry
+# The section line itself is stored in a separate Entry object
 #
 class Tweek::Section < Array
 
-  attr_reader :lineno, :type, :list, :comment
+  attr_reader :section_entry, :twf
 
-  def initialize lineno, type, list, comment
-    @lineno = lineno
-    @type = type
-    @list = list
-    @comment = comment
+  def initialize twf, entry
+    @twf = twf
+    @section_entry = entry
   end
 
-  # Iterate through each entry in the section.
-  # If it's a comment then pass to the generate method
-  # If it has a condition which is not met then pass to generate
-  # If it passes yield the entry
+  # Return an initial section used to hold anything (such as comments) prior to
+  # the first real section
+  def self.initial twf
+    Tweek::Section.new(twf, Tweek::Entry.new(self, :section, :section_type => :initial) )
+  end
+
+  # Helper method to easily iterate through each actionable entry in the section.
   #
-  def each_entry twf, &block
+  def each_entry &block
     self.each do |entry|
-      if entry.line
-        twf.generate :line, entry
-        next
-      end
-      begin
-        if twf.condfail entry.cond
-          twf.generate :entry, entry
-          twf.skipcond entry
-          next
+      case entry.type
+      when :literal
+        @twf.generate entry
+      when :parameter
+        begin
+          if entry.condfail
+            @twf.generate entry
+          else
+            yield entry if block_given?
+          end
+        rescue Exception => e
+          @twf.error e.message, entry.lineno
+          STDERR.puts "#{e.message}\n#{e.backtrace.join("\n")}" if ENV['DEBUG_TWEEK']
         end
-        yield entry
-      rescue Exception => e
-        twf.error "#{entry.lineno}: #{e.message}"
+      else
+        raise "Unknown entry type: #{entry.type}"
       end
     end
   end
 
-  def process twf
-
-    twf.generate :section, Tweek::Entry.new( :lineno => lineno, :type => type, :list => list, :comment => comment )
+  def process
 
     return if self.empty?
 
-    case self.type
-    when nil
-        each_entry (twf) do |entry|
-        end
-
-    when 'BLKDEV' # BLOCK DEVICE PARAMETERS
+    case section_entry.section_type
 
-      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
+    when :initial
+      self.each do |entry|
+        case entry.type
+        when :literal
+          @twf.generate entry
+        else
+          @twf.warn "Parameter line ignored outside section", entry.lineno
+        end
+      end
 
+    when :BLKDEV # BLOCK DEVICE PARAMETERS
+      @twf.warn "Set/Reset is not currently implemented for #{section_entry.section_type} section" if [:set, :reset].include? @twf.mflag
       Dir.chdir('/dev')
-      devices = Dir.glob(self.list.split(' ').map{|dev| dev.gsub(/^\/dev\//,'')})
-
-      twf.warn "Block device check skipped: no devices found" if devices.empty?
-
+      devices = Dir.glob(section_entry.list.split(' ').map{|dev| dev.gsub(/^\/dev\//,'')})
+      @twf.warn("Block device check skipped: no devices found", section_entry.lineno) if devices.empty?
       devices.each do |blk|
-        each_entry (twf) do |entry|
+        section_entry.list_element = blk
+        @twf.generate section_entry
+        each_entry do |entry|
           entry.actual = Tweek.blk_param(blk, entry.param)
           if entry.param == 'scheduler'
             entry.actual = entry.actual.slice(/\[(.*?)\]/,1) unless entry.actual == 'none'
           end
-          twf.assert_equal entry.value, entry.actual, "/dev/#{blk} #{entry.param}"
-          twf.generate :entry, entry
+          @twf.generate entry
         end
       end
 
-    when 'KERNEL' # KERNEL PARAMETERS
-      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
-      each_entry (twf) do |entry|
+    when :KERNEL # KERNEL PARAMETERS
+      @twf.warn "Set/Reset is not currently implemented for #{section_entry.section_type} section" if [:set, :reset].include? @twf.mflag
+      @twf.generate section_entry
+      each_entry do |entry|
         actual = /\b(#{entry.param})(=\S+)?\b/.match(Tweek.bootline)
         case
         when (entry.value == 'true' and actual)
-          observed = actual.to_s
-          expected = entry.param
+          entry.actual = actual[2].nil? ? 'true' : actual[2][1..-1]
         when (entry.value == 'true' and actual.nil?)
-          expected = 'to be found'
-          observed = 'was not found'
+          entry.actual = 'false'
         when (entry.value == 'false' and actual)
-          expected = 'to not be found'
-          observed = 'was found'
+          entry.actual = 'true'
         when (entry.value == 'false' and actual.nil?)
-          expected = nil
-          observed = nil
-	else
-	  expected = entry.value
-          observed = actual.nil? ? 'was not found' : actual[2][1..-1]
+          entry.actual = 'false'
+        else
+         entry.actual = actual.nil? ? 'false' : actual[2][1..-1]
         end
-        twf.assert_equal expected, observed, "Kernel parameter #{entry.param}"
-        entry.actual = !actual.nil?
-        twf.generate :entry, entry
+        @twf.generate entry
       end
 
-    when 'CLOCKSOURCE'
-      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
-      each_entry (twf) do |entry|
+    when :CLOCKSOURCE
+      @twf.warn "Set/Reset is not currently implemented for #{section_entry.section_type} section" if [:set, :reset].include? @twf.mflag
+      @twf.generate section_entry
+      each_entry do |entry|
         entry.actual = Tweek.clocksource(entry.param)
-        twf.assert_equal entry.value, entry.actual, entry.param
-        twf.generate :entry, entry
+        @twf.generate entry
       end
 
-    when 'SYSCTL' # SYSCTL SETTINGS
-      each_entry (twf) do |entry|
+    when :SYSCTL # SYSCTL SETTINGS
+      @twf.generate section_entry
+      each_entry do |entry|
         file = entry.param.gsub(/\./,'/')
         entry.actual = Tweek.sysctl(file)
-        twf.assert_equal entry.value, entry.actual, entry.param
-        if twf.sflag
+        case @twf.mflag
+        when :set
           entry.value = Tweek.set_sysctl(file, entry.value)
-          entry.set = true
+          entry.mode = :set
+        when :reset
+          if entry.was
+            if entry.actual == entry.value
+              entry.value = Tweek.set_sysctl(file, entry.was)
+              entry.mode = :reset
+            else
+              @twf.warn "Current value of #{entry.param.bold} does not match, cannot reset", entry.lineno
+            end
+          else
+            @twf.warn "Previous value of #{entry.param.bold} not found, cannot reset", entry.lineno
+          end
         end
-        twf.generate :entry, entry
+        @twf.generate entry
       end
 
-    when 'NET'  # NETWORK DEVICES
-      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
-      devices = self.list.split(' ').map{|dev| dev.gsub(/^\/dev\//,'')}
-      twf.warn "Network device check skipped: no devices found" if devices.empty?
+    when :NET  # NETWORK DEVICES
+      @twf.warn "Set/Reset is not currently implemented for #{section_entry.section_type} section" if [:set, :reset].include? @twf.mflag
+      devices = section_entry.list.split(' ').map{|dev| dev.gsub(/^\/dev\//,'')}
+      @twf.warn("Network device check skipped: no devices found", section_entry.lineno) if devices.empty?
 
       devices.each do |netdev|
-        each_entry (twf) do |entry|
+        unless Tweek.net_dev_exist? netdev
+          @twf.warn("NET device #{netdev} not found", section_entry.lineno)
+          next
+        end
+        section_entry.list_element = netdev
+        @twf.generate section_entry
+        each_entry do |entry|
 
 	  case entry.param
 	  when 'driver'
             entry.actual = Tweek.net_driver(netdev)
+            @twf.generate entry
 
 	  when 'irqs'
-
             balpid = Tweek.balance_pid
-
             if entry.value == 'balance'
               entry.actual = balpid.zero? ? 'IRQ balance daemon not running' : 'balance'
             else
               if balpid.zero?
-                handle_irqs(netdev, twf, entry)
-                next
+                handle_irqs(netdev, entry)
               else
                 entry.actual = 'IRQ balance daemon running'
+                @twf.generate entry
               end
             end
 
 	  else # treat the parameter as a name
-	    begin
-              entry.actual = Tweek.net_param(netdev, entry.param)
-	    rescue
-	      twf.error "#{entry.lineno}: Network parameter #{entry.param} not handled: #{$!.message}"
-	      next
-	    end
+            entry.actual = Tweek.net_param(netdev, entry.param)
+            @twf.generate entry
           end
 
-          twf.assert_equal entry.value, entry.actual, entry.param
-	  twf.generate :entry, entry
         end
       end
 
-    when 'EXT4' # EXT4 filesystems info via `dumpe2fs -h /dev/#{device}`
-      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
+    when :EXT4 # EXT4 filesystems info via `dumpe2fs -h /dev/#{device}`
+      @twf.warn "Set/Reset is not currently implemented for #{section_entry.section_type} section" if [:set, :reset].include? @twf.mflag
       mounted = Tweek.mounted
-      mounts = Dir.glob(self.list.split(' '))
+      mounts = Dir.glob(section_entry.list.split(' '))
+      @twf.warn("EXT4 check skipped: no mountpoints found", section_entry.lineno) if mounts.empty?
       mounts.each do |mount|
         unless this = mounted.select{|m| (mount == m[0] or mount == m[1]) and m[2] == 'ext4'}.first
-          twf.warn "EXT4 path #{mount} is not mounted or is not mounted as ext4"
+          @twf.warn "EXT4 path #{mount} is not mounted or is not mounted as ext4", section_entry.lineno
           next
         end
+        section_entry.list_element = mount
+        @twf.generate section_entry
         device = this[0].gsub('/dev/','')
         optstring = File.open("/proc/fs/ext4/#{device}/options",&:read)
         options = Hash[optstring.scan(/([^=\s]+)=([^=\s,]+)/)] # options a=b
         optstring.split(/\n/).reject{|o| o.index('=')}.each{|o| options[o] = 'true'}
-        each_entry (twf) do |entry|
+        each_entry do |entry|
           entry.actual = options[entry.param] || "<not found>"
-          twf.assert_equal entry.value, entry.actual, "EXT4 #{mount}: #{entry.param}"
-          twf.generate :entry, entry
+          @twf.generate entry
         end
       end
 
-    when 'XFS' # XFS filesystems info  via `xfs_info`
-      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
+    when :XFS # XFS filesystems info  via `xfs_info`
+      @twf.warn "Set/Reset is not currently implemented for #{section_entry.section_type} section" if [:set, :reset].include? @twf.mflag
       # Dynamically via: /proc/fs/xfs/... ?
-      mounts = self.list.split(' ')
-      if mounts.empty?
-        twf.warn "#{self.lineno}: XFS device check skipped: no mountpoints found"
-      end
+      mounts = section_entry.list.split(' ')
+      @twf.warn("XFS device check skipped: no mountpoints found", section_entry.lineno) if mounts.empty?
       mounts.each do |mount|
         xfsinfo = Tweek.xfsinfo(mount)
         unless xfsinfo
-          twf.warn "No XFS filesystem at #{mount}"
-          each_entry (twf) { |entry| twf.generate :entry, entry }
+          @twf.warn "No XFS filesystem at #{mount}", section_entry.lineno
           next
         end
+        section_entry.list_element = mount
+        @twf.generate section_entry
         data = Hash[xfsinfo.slice!(/^meta-data.*(?=^naming)/m).scan(/([^=\s]+)=([^=\s,]+)/)]
         naming = Hash[xfsinfo.slice!(/^naming.*(?=^log)/m).scan(/([^=\s]+)=([^=\s,]+)/)]
         log = Hash[xfsinfo.slice!(/^log.*(?=^realtime)/m).scan(/([^=\s]+)=([^=\s,]+)/)]
         realtime = Hash[xfsinfo.slice!(/^realtime.*$/m).scan(/([^=\s]+)=([^=\s,]+)/)]
         xfsparms = { 'data' => data, 'naming' => naming, 'log' => log, 'realtime' => realtime }
 
-        each_entry (twf) do |entry|
+        each_entry do |entry|
           parameter = entry.param.split('.',2)
           entry.actual = xfsparms[parameter[0]][parameter[1]] rescue "<invalid name>"
-          twf.assert_equal entry.value, entry.actual, "XFS #{mount}: #{entry.param}"
-          twf.generate :entry, entry
+          @twf.generate entry
         end
       end
 
     else
-      twf.error "#{self.lineno}: Unknown type #{self.type}"
+      @twf.error "Unknown type #{section_entry.section_type}", section_entry.lineno
     end
 
   end
 
-  def handle_irqs netdev, twf, entry
+  def handle_irqs netdev, entry
     irqs = Tweek.irqs(netdev)
 
     if irqs.empty?
-      twf.warn "#{netdev} IRQ check skipped: none found"
+      @twf.warn "#{netdev} IRQ check skipped: none found", entry.lineno
       entry.actual = 'null'
-      twf.generate :entry, entry
       return
     end
 
@@ -240,7 +246,7 @@ class Tweek::Section < Array
           expected_rps << "0000"
           expected_rss << sprintf("%04x", 1<<ix)
         else
-          twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle #{ncores} cores"
+          @twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle #{ncores} cores", entry.lineno
           return
         end
 
@@ -256,7 +262,7 @@ class Tweek::Section < Array
             expected_rps << ("00000000," * 3) + "fffefe00"
             expected_rss << ("00000000," * 3) + sprintf("%08x", 1<<(ix+1))
           else
-            twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}"
+            @twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}", entry.lineno
             return
           end
 
@@ -269,29 +275,37 @@ class Tweek::Section < Array
             expected_rps << ("00000000," * 2) + "ffff0000," + "ffe00000"
             expected_rss << ("00000000," * 3) + sprintf("%08x", 1<<(ix + 9))
           else
-            twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}"
+            @twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}", entry.lineno
             return
           end
 
         else
-          twf.error "#{entry.lineno}: Can't handle #{ncores} cores in IRQ strategy '#{entry.value}'"
+          @twf.error "Can't handle #{ncores} cores in IRQ strategy '#{entry.value}'", entry.lineno
           return
         end
 
       else
-        twf.error "#{entry.lineno}: Unrecognized #{netdev} IRQ strategy '#{entry.value}'"
+        @twf.error "Unrecognized #{netdev} IRQ strategy '#{entry.value}'", entry.lineno
         return
       end
     end
+    rss = [] # sadly map.with_index doesn't work in 1.8.7, no other compatible way
     irqs.each_with_index do |irq, ix|
-      actual_rss = Tweek.net_rss(irq)
-      mismatches += twf.assert_equal expected_rss[ix], actual_rss, "#{netdev}_irq_#{irq}_rss"
+      rss << Tweek::Entry.new(self, :parameter, :param => "#{netdev}_irq_#{irq}_rss",
+                              :actual => Tweek.net_rss(irq),
+                              :value => expected_rss[ix])
     end
+    rps = []
     irqs.each_with_index do |irq, ix|
-      actual_rps = Tweek.net_rps(netdev, ix)
-      mismatches += twf.assert_equal expected_rps[ix], actual_rps, "#{netdev}_irq_#{irq}_rps"
+      rps << Tweek::Entry.new(self, :parameter, :param => "#{netdev}_irq_rx-#{ix}_rps",
+                              :actual => Tweek.net_rps(netdev, ix),
+                              :value => expected_rps[ix])
     end
-    entry.actual = 'null' if mismatches > 0
+    mismatches = rss.reduce(0){|sum, r| sum += 1 if r.mismatch}
+    mismatches += rps.reduce(0){|sum, r| sum += 1 if r.mismatch}
+    entry.actual = 'explicit' if mismatches > 0
+    @twf.generate entry
+    (rss+rps).each {|e| @twf.generate e}
     return
   end
 

data/lib/tweek/version.rb

@@ -1,3 +1,3 @@
 module Tweek
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/tweek.rb

@@ -3,11 +3,13 @@
 module Tweek
 
   def self.bootline
-    @bootline ||= ::File.open("/proc/cmdline", &:read).chomp
+    @bootline ||= ::File.open("/proc/cmdline", &:read).strip
   end
 
   def self.balance_pid
-    @balance_pid ||= `pgrep irqbalance`.chomp.to_i
+    @balance_pid ||= `pgrep irqbalance`.strip.to_i
+    raise "pgrep appears to be missing!" if $? == 127
+    return @balance_pid
   end
 
   # Determine the queue processing interrupts for the network device
@@ -20,15 +22,15 @@ module Tweek
   end
 
   def self.ncores
-    `getconf _NPROCESSORS_ONLN`.chomp.to_i rescue 0
+    `getconf _NPROCESSORS_ONLN`.strip.to_i rescue 0
   end
 
   def self.clocksource param
-     ::File.open("/sys/devices/system/clocksource/#{param}/current_clocksource",&:read).chomp rescue $!.message
+     ::File.open("/sys/devices/system/clocksource/#{param}/current_clocksource",&:read).strip rescue $!.message
   end
 
   def self.sysctl name
-    ::File.open("/proc/sys/#{name}", &:read).chomp.gsub(/\s+/,' ') rescue $!.message
+    ::File.open("/proc/sys/#{name}", &:read).strip.gsub(/\s+/,' ') rescue $!.message
   end
 
   def self.set_sysctl name, value
@@ -40,26 +42,30 @@ module Tweek
     end
   end
 
+  def self.net_dev_exist? name
+    ::File.readable?("/sys/class/net/#{name}")
+  end
+
   def self.net_driver name
     ::File.basename(::File.readlink("/sys/class/net/#{name}/device/driver"))
   end
 
   def self.blk_param blkdev, name
-    ::File.open("/sys/block/#{blkdev}/queue/#{name}", &:read).chomp rescue $!.message
+    ::File.open("/sys/block/#{blkdev}/queue/#{name}", &:read).strip rescue $!.message
   end
 
   # Receive Side Scaling - hardware
   def self.net_rss irq
-    ::File.open("/proc/irq/#{irq}/smp_affinity",&:read).chomp rescue $!.message
+    ::File.open("/proc/irq/#{irq}/smp_affinity",&:read).strip rescue $!.message
   end
 
   # Receive Packet Steering - software
   def self.net_rps netdev, ix
-    ::File.open("/sys/class/net/#{netdev}/queues/rx-#{ix}/rps_cpus", &:read).chomp rescue $!.message
+    ::File.open("/sys/class/net/#{netdev}/queues/rx-#{ix}/rps_cpus", &:read).strip rescue $!.message
   end
 
   def self.net_param netdev, name
-    ::File.open("/sys/class/net/#{netdev}/#{name}", &:read).chomp.gsub(/\s+/,' ')
+    ::File.open("/sys/class/net/#{netdev}/#{name}", &:read).strip.gsub(/\s+/,' ') rescue $!.message
   end
 
   def self.mounted
@@ -67,7 +73,7 @@ module Tweek
   end
 
   def self.xfsinfo mount
-    info = `xfs_info #{mount} 2>/dev/null`.chomp
+    info = `xfs_info #{mount} 2>/dev/null`.strip
     return $?.exitstatus > 0 ? nil : info
   end
 end

data/settings/sample.twk

@@ -81,6 +81,7 @@ NET eth0
 #       RSS allocated across 1-4 (node 0) then 17-20 (node 1)
 #
 # balance: Use the irqbalance daemon
+# explicit: Describe each parameter individually (try it to get documentation!)
 # null: Ignore this device
 #
 irqs = aws

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tweek
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Nick Townsend
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-29 00:00:00.000000000 Z
+date: 2017-10-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement