tweek 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7068bcfbf27d73e5c1a20c2f5d52671a8d0ce968
-  data.tar.gz: 8458e63c00fd12cc564a7e7aa3198aecfefe65b7
+  metadata.gz: 2b847609877ba323a4f9feb924b503cd80f9f553
+  data.tar.gz: 28ca6b95b8f2481c00b85aadf4ef2b4aa690f78d
 SHA512:
-  metadata.gz: c09dfbf71eca18073c90a87616d46084f2ec6572d659c5a23beaf9c1044e33d984030d30ac24ff74a4e871f066ddf994529373cfdbe3f69af018c06de22d2b84
-  data.tar.gz: 7c85c2be58f9a2de5383a7f5caa0c433d30678f6a46eb12e7a32191d0c91a65eba57858ef6bb7b07894659958ab9d98bb046836b179623f72c32b071182d890d
+  metadata.gz: dd5be7941a09e0351df76b35e99efe7e5a5d905691f656f7fa577b3e15c303fab0296b716cddbf79faf12f3f74185e063b3a367e7c94d7a33099053c69aed342
+  data.tar.gz: 2ef05e618352ec963c405a9f05cc8b279e29f97c3fd2d847cdd1750352f790f559e44acc7475c638d2e24be98c01fe8a45cbfb616f7e5b352e8459193f79d13f

data/README.md

@@ -72,7 +72,8 @@ Use `tweek -s` to show them.
 ## Settings File Format
 
 The settings file is a plaintext file encoded in UTF-8 (if you are running Ruby 2.0 or
-above) or US-ASCII otherwise.
+above) or US-ASCII otherwise. Although settings files can have any name, please observe the
+convention of using a file extension of `.twk`.
 
 The overall syntax of the file was designed to be Ruby-like so that enabling syntax
 highlighting (using Ruby as the language) makes it very readable.

data/bin/tweek

@@ -1,13 +1,12 @@
 #!/usr/bin/env ruby
 #
 # A script to check a variety of Linux system settings
-# See settings/sample.set for a description of these.
+# See settings/sample.twk for a description of these.
 # By Nick Townsend, June 2017
 #
 require 'rubygems'
 
 require 'optparse'
-require 'ostruct'
 require 'tweek'
 require 'tweek/file'
 require 'tweek/version'
@@ -18,14 +17,16 @@ trap('INT') do
 end
 
 gflag = false
+sflag = false
+qflag = false
 distro = nil
 distro_ver = nil
 kernel_ver = nil
 OptionParser.new do |o|
     o.banner = "Usage: #{$0} [options] [settings_file...]"
     o.separator ""
-    o.separator "Check the system parameters specified in the settings files"
-    o.separator "(If not supplied then built-in defaults are used)"
+    o.separator "Check and/or update the system parameters specified in the settings files"
+    o.separator "(If not supplied then built-in samples are used)"
     o.separator "Options:"
     o.on('--distro=NAME', "Set Distro (default uses lsb_release)" ) do |d|
         distro = d
@@ -39,14 +40,20 @@ OptionParser.new do |o|
     o.on( '-g', '--generate', "Generate a copy of the input file(s)", "containing current values on STDOUT" ) do
         gflag = true
     end
+    o.on( '-q', '--quiet', "No output (default false)" ) do
+        qflag = true
+    end
     o.on( '-s', '--show', "Write the default parameters to STDOUT",
           "Use as a fully documented starting point"
         ) do
-        File.open(File.expand_path('../../settings/sample.set',__FILE__)).each_line do |l|
+        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
+    end
     o.on('-v', "--version", "Show version") do
       puts Tweek::VERSION
       exit
@@ -83,9 +90,13 @@ if kernel_ver.nil?
     exit 2
   end
 end
-cs = Tweek::File.new(gflag, true, distro, distro_ver, kernel_ver)
+cs = Tweek::File.new(distro, distro_ver, kernel_ver, gflag, qflag, sflag)
 if ARGV.empty?
-  fh = File.open(File.expand_path('../../settings/sample.set',__FILE__))
+  if sflag
+    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
 end

data/lib/tweek.rb

@@ -31,6 +31,15 @@ module Tweek
     ::File.open("/proc/sys/#{name}", &:read).chomp.gsub(/\s+/,' ') rescue $!.message
   end
 
+  def self.set_sysctl name, value
+    begin
+      ::File.open("/proc/sys/#{name}", "w"){|f| f.write value}
+      value
+    rescue
+      $!.message
+    end
+  end
+
   def self.net_driver name
     ::File.basename(::File.readlink("/sys/class/net/#{name}/device/driver"))
   end

data/lib/tweek/file.rb

@@ -1,14 +1,13 @@
 require 'rubygems'
-require 'optparse'
-require 'ostruct'
 require 'tweek'
 require 'tweek/section'
+require 'tweek/entry'
 
 class Tweek::File
 
-  attr_reader :distro, :distro_version, :kernel_version
+  attr_reader :distro, :distro_version, :kernel_version, :gflag, :qflag, :sflag
 
-  def initialize( gflag, tty, distro, distro_version, kernel_version)
+  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)
@@ -18,34 +17,43 @@ class Tweek::File
     @skips = []
     @warns = []
     @generated = []
+    if gflag
+      @generated << "# Generated at #{Time.now.strftime("%c %Z")}"
+      @generated << "# Distro: #{@distro} Version: #{@distro_version} Kernel: #{@kernel_version}"
+    end
     @gflag = gflag
-    @tty = tty
+    @qflag = qflag
+    @sflag = sflag
   end
 
-  def generate type, e
+  # Generate an output file recording what was found (check) or done (set)
+  #
+  def generate type, entry
     return unless @gflag
     case type
     when :line
-      @generated.push "#{e.line}#{e.comment}"
+      @generated.push "#{entry.line}#{entry.comment}"
     when :section
-      @generated.push "#{e.type} #{e.list} #{e.comment}"
+      return if entry.type.nil?
+      @generated.push "#{entry.type} #{entry.list} #{entry.comment}"
     when :entry
-      cond = e.cond.nil? ? "": " if #{e.cond}"
-      if e.actual.nil?
-        line = "#{e.param} = #{e.value}#{cond}"
+      cond = entry.cond.nil? ? "": " if #{entry.cond}"
+      if entry.actual.nil?
+        line = "#{entry.param} = #{entry.value}#{cond}"
         note = "[condition not met]"
       else
-        line = "#{e.param} = #{e.actual}#{cond}"
-        if e.value === e.actual
+        entry.swap!
+        line = "#{entry.param} = #{entry.actual}#{cond}"
+        if entry.value === entry.actual
           note = nil
         else
-          note = "[expected #{e.value}]"
+          note = "[#{entry.set ? 'was' : 'expected'} #{entry.value}]"
         end
       end
-      if e.comment.nil?
+      if entry.comment.nil?
         @generated.push (note ? line + " # " + note : line)
       else
-        @generated.push (note ? line + " " + comment + " " + note : line + " " + comment)
+        @generated.push (note ? line + " " + entry.comment + " " + note : line + " " + entry.comment)
       end
     end
   end
@@ -96,10 +104,10 @@ class Tweek::File
   def assert_equal expected, actual, msg = ''
     @nparams += 1
     if expected === actual
-      STDERR.print "." if @tty
+      STDERR.print "." if not @qflag and STDERR.isatty
       return 0
     else
-      STDERR.print "F" if @tty
+      STDERR.print "F" if not @qflag and STDERR.isatty
       @mismatches.push "#{msg}: Expected #{expected}\n#{" "*(msg.size+4)}Actual #{actual}"
     end
     return 1
@@ -108,23 +116,23 @@ class Tweek::File
   # Read the entire file and split into sections
   #
   def read_sections handle
-    section = Tweek::Section.new(0,'<initial>','','')
+    section = Tweek::Section.new( 0, nil, '', '' )
     while line = handle.gets
       line.chomp!
       if (line =~ /^=begin/)..(line =~ /^=end/)
-        section.push OpenStruct.new( :line => line, :lineno => handle.lineno )
+        section.push Tweek::Entry.new( :line => line, :lineno => handle.lineno )
         next
       end
 
       comment = line.slice!(/#.*$/)
       if line.empty?
-        section.push OpenStruct.new( :line => line, :lineno => handle.lineno, :comment => comment )
+        section.push Tweek::Entry.new( :line => line, :lineno => handle.lineno, :comment => comment )
         next
       end
 
       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)
+        section = Tweek::Section.new( handle.lineno, $1, $2, comment )
         next
       end
 
@@ -132,8 +140,8 @@ class Tweek::File
         if $4 and $4.strip.empty?
           error "#{handle.lineno}: Missing condition after 'if'"
         else
-          section.push OpenStruct.new( :lineno => handle.lineno, :param => $1, :value => $2,
-                                       :cond => $4, :comment => comment )
+          section.push Tweek::Entry.new(  :lineno => handle.lineno, :param => $1, :value => $2,
+                                          :cond => $4, :comment => comment )
         end
         next
       end
@@ -144,13 +152,12 @@ class Tweek::File
   end
 
   def results
-    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?
-    if @gflag
-      @generated.unshift "# Generated at #{Time.now.strftime("%c %Z")}\n# Distro: #{@distro} Version: #{@distro_version} Kernel: #{@kernel_version}"
+    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?
       @generated.each { |l| STDOUT.puts l}
     end
     return @mismatches.size

data/lib/tweek/section.rb

@@ -8,6 +8,7 @@
 class Tweek::Section < Array
 
   attr_reader :lineno, :type, :list, :comment
+
   def initialize lineno, type, list, comment
     @lineno = lineno
     @type = type
@@ -15,65 +16,64 @@ class Tweek::Section < Array
     @comment = comment
   end
 
-  def section_entry
-      OpenStruct.new(:lineno => lineno, :type => type, :list => list, :comment => comment )
-  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
   #
-  def each_entry cs, &block
+  def each_entry twf, &block
     self.each do |entry|
       if entry.line
-        cs.generate :line, entry
+        twf.generate :line, entry
         next
       end
       begin
-        if cs.condfail entry.cond
-          cs.generate :entry, entry
-          cs.skipcond entry
+        if twf.condfail entry.cond
+          twf.generate :entry, entry
+          twf.skipcond entry
           next
         end
         yield entry
       rescue Exception => e
-        cs.error "#{entry.lineno}: #{e.message}"
+        twf.error "#{entry.lineno}: #{e.message}"
       end
     end
   end
 
-  def process cs
+  def process twf
 
-    cs.generate :section, section_entry unless type == '<initial>'
+    twf.generate :section, Tweek::Entry.new( :lineno => lineno, :type => type, :list => list, :comment => comment )
 
     return if self.empty?
 
-    case type
-    when '<initial>'
-        each_entry (cs) do |entry|
+    case self.type
+    when nil
+        each_entry (twf) do |entry|
         end
 
     when 'BLKDEV' # BLOCK DEVICE PARAMETERS
 
+      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
+
       Dir.chdir('/dev')
       devices = Dir.glob(self.list.split(' ').map{|dev| dev.gsub(/^\/dev\//,'')})
 
-      cs.warn "Block device check skipped: no devices found" if devices.empty?
+      twf.warn "Block device check skipped: no devices found" if devices.empty?
 
       devices.each do |blk|
-        each_entry (cs) do |entry|
+        each_entry (twf) 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
-          cs.assert_equal entry.value, entry.actual, "/dev/#{blk} #{entry.param}"
-          cs.generate :entry, entry
+          twf.assert_equal entry.value, entry.actual, "/dev/#{blk} #{entry.param}"
+          twf.generate :entry, entry
         end
       end
 
     when 'KERNEL' # KERNEL PARAMETERS
-      each_entry (cs) do |entry|
+      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
+      each_entry (twf) do |entry|
         actual = /\b(#{entry.param})(=\S+)?\b/.match(Tweek.bootline)
         case
         when (entry.value == 'true' and actual)
@@ -92,32 +92,38 @@ class Tweek::Section < Array
 	  expected = entry.value
           observed = actual.nil? ? 'was not found' : actual[2][1..-1]
         end
-        cs.assert_equal expected, observed, "Kernel parameter #{entry.param}"
+        twf.assert_equal expected, observed, "Kernel parameter #{entry.param}"
         entry.actual = !actual.nil?
-        cs.generate :entry, entry
+        twf.generate :entry, entry
       end
 
     when 'CLOCKSOURCE'
-      each_entry (cs) do |entry|
+      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
+      each_entry (twf) do |entry|
         entry.actual = Tweek.clocksource(entry.param)
-        cs.assert_equal entry.value, entry.actual, entry.param
-        cs.generate :entry, entry
+        twf.assert_equal entry.value, entry.actual, entry.param
+        twf.generate :entry, entry
       end
 
     when 'SYSCTL' # SYSCTL SETTINGS
-      each_entry (cs) do |entry|
+      each_entry (twf) do |entry|
         file = entry.param.gsub(/\./,'/')
         entry.actual = Tweek.sysctl(file)
-        cs.assert_equal entry.value, entry.actual, entry.param
-        cs.generate :entry, entry
+        twf.assert_equal entry.value, entry.actual, entry.param
+        if twf.sflag
+          entry.value = Tweek.set_sysctl(file, entry.value)
+          entry.set = true
+        end
+        twf.generate :entry, 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\//,'')}
-      cs.warn "Network device check skipped: no devices found" if devices.empty?
+      twf.warn "Network device check skipped: no devices found" if devices.empty?
 
       devices.each do |netdev|
-        each_entry (cs) do |entry|
+        each_entry (twf) do |entry|
 
 	  case entry.param
 	  when 'driver'
@@ -131,7 +137,7 @@ class Tweek::Section < Array
               entry.actual = balpid.zero? ? 'IRQ balance daemon not running' : 'balance'
             else
               if balpid.zero?
-                handle_irqs(netdev, cs, entry)
+                handle_irqs(netdev, twf, entry)
                 next
               else
                 entry.actual = 'IRQ balance daemon running'
@@ -142,46 +148,48 @@ class Tweek::Section < Array
 	    begin
               entry.actual = Tweek.net_param(netdev, entry.param)
 	    rescue
-	      cs.error "#{entry.lineno}: Network parameter #{entry.param} not handled: #{$!.message}"
+	      twf.error "#{entry.lineno}: Network parameter #{entry.param} not handled: #{$!.message}"
 	      next
 	    end
           end
 
-          cs.assert_equal entry.value, entry.actual, entry.param
-	  cs.generate :entry, entry
+          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
       mounted = Tweek.mounted
       mounts = Dir.glob(self.list.split(' '))
       mounts.each do |mount|
         unless this = mounted.select{|m| (mount == m[0] or mount == m[1]) and m[2] == 'ext4'}.first
-          cs.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"
           next
         end
         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 (cs) do |entry|
+        each_entry (twf) do |entry|
           entry.actual = options[entry.param] || "<not found>"
-          cs.assert_equal entry.value, entry.actual, "EXT4 #{mount}: #{entry.param}"
-          cs.generate :entry, entry
+          twf.assert_equal entry.value, entry.actual, "EXT4 #{mount}: #{entry.param}"
+          twf.generate :entry, entry
         end
       end
 
     when 'XFS' # XFS filesystems info  via `xfs_info`
+      twf.warn "Set is not currently implemented for #{type} section" if twf.sflag
       # Dynamically via: /proc/fs/xfs/... ?
       mounts = self.list.split(' ')
       if mounts.empty?
-        cs.warn "#{self.lineno}: XFS device check skipped: no mountpoints found"
+        twf.warn "#{self.lineno}: XFS device check skipped: no mountpoints found"
       end
       mounts.each do |mount|
         xfsinfo = Tweek.xfsinfo(mount)
         unless xfsinfo
-          cs.warn "No XFS filesystem at #{mount}"
-          each_entry (cs) { |entry| cs.generate :entry, entry }
+          twf.warn "No XFS filesystem at #{mount}"
+          each_entry (twf) { |entry| twf.generate :entry, entry }
           next
         end
         data = Hash[xfsinfo.slice!(/^meta-data.*(?=^naming)/m).scan(/([^=\s]+)=([^=\s,]+)/)]
@@ -190,27 +198,27 @@ class Tweek::Section < Array
         realtime = Hash[xfsinfo.slice!(/^realtime.*$/m).scan(/([^=\s]+)=([^=\s,]+)/)]
         xfsparms = { 'data' => data, 'naming' => naming, 'log' => log, 'realtime' => realtime }
 
-        each_entry (cs) do |entry|
+        each_entry (twf) do |entry|
           parameter = entry.param.split('.',2)
           entry.actual = xfsparms[parameter[0]][parameter[1]] rescue "<invalid name>"
-          cs.assert_equal entry.value, entry.actual, "XFS #{mount}: #{entry.param}"
-          cs.generate :entry, entry
+          twf.assert_equal entry.value, entry.actual, "XFS #{mount}: #{entry.param}"
+          twf.generate :entry, entry
         end
       end
 
     else
-      cs.error "#{self.lineno}: Unknown type #{self.type}"
+      twf.error "#{self.lineno}: Unknown type #{self.type}"
     end
 
   end
 
-  def handle_irqs netdev, cs, entry
+  def handle_irqs netdev, twf, entry
     irqs = Tweek.irqs(netdev)
 
     if irqs.empty?
-      cs.warn "#{netdev} IRQ check skipped: none found"
+      twf.warn "#{netdev} IRQ check skipped: none found"
       entry.actual = 'null'
-      cs.generate :entry, entry
+      twf.generate :entry, entry
       return
     end
 
@@ -232,7 +240,7 @@ class Tweek::Section < Array
           expected_rps << "0000"
           expected_rss << sprintf("%04x", 1<<ix)
         else
-          cs.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle #{ncores} cores"
+          twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle #{ncores} cores"
           return
         end
 
@@ -248,7 +256,7 @@ class Tweek::Section < Array
             expected_rps << ("00000000," * 3) + "fffefe00"
             expected_rss << ("00000000," * 3) + sprintf("%08x", 1<<(ix+1))
           else
-            cs.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}"
+            twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}"
             return
           end
 
@@ -261,27 +269,27 @@ class Tweek::Section < Array
             expected_rps << ("00000000," * 2) + "ffff0000," + "ffe00000"
             expected_rss << ("00000000," * 3) + sprintf("%08x", 1<<(ix + 9))
           else
-            cs.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}"
+            twf.warn "#{netdev} IRQ strategy '#{entry.value}' can't handle IRQ#{ix}"
             return
           end
 
         else
-          cs.error "#{entry.lineno}: Can't handle #{ncores} cores in IRQ strategy '#{entry.value}'"
+          twf.error "#{entry.lineno}: Can't handle #{ncores} cores in IRQ strategy '#{entry.value}'"
           return
         end
 
       else
-        cs.error "#{entry.lineno}: Unrecognized #{netdev} IRQ strategy '#{entry.value}'"
+        twf.error "#{entry.lineno}: Unrecognized #{netdev} IRQ strategy '#{entry.value}'"
         return
       end
     end
     irqs.each_with_index do |irq, ix|
       actual_rss = Tweek.net_rss(irq)
-      mismatches += cs.assert_equal expected_rss[ix], actual_rss, "#{netdev}_irq_#{irq}_rss"
+      mismatches += twf.assert_equal expected_rss[ix], actual_rss, "#{netdev}_irq_#{irq}_rss"
     end
     irqs.each_with_index do |irq, ix|
       actual_rps = Tweek.net_rps(netdev, ix)
-      mismatches += cs.assert_equal expected_rps[ix], actual_rps, "#{netdev}_irq_#{irq}_rps"
+      mismatches += twf.assert_equal expected_rps[ix], actual_rps, "#{netdev}_irq_#{irq}_rps"
     end
     entry.actual = 'null' if mismatches > 0
     return

data/lib/tweek/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tweek
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Nick Townsend
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-22 00:00:00.000000000 Z
+date: 2017-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,7 +68,7 @@ files:
 - lib/tweek/file.rb
 - lib/tweek/section.rb
 - lib/tweek/version.rb
-- settings/sample.set
+- settings/sample.twk
 homepage: https://github.com/townsen/tweek
 licenses:
 - MIT